--- /dev/null
+# Top level makefile fragment for the GNU compiler for the Java(TM)
+# language.
+# Copyright (C) 1996, 1998 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, 59 Temple Place - Suite 330,
+#Boston, MA 02111-1307, USA.
+
+#Java and all Java-based marks are trademarks or registered trademarks
+#of Sun Microsystems, Inc. in the United States and other countries.
+#The Free Software Foundation is independent of Sun Microsystems, Inc.
+
+# This file provides the language dependent support in the main Makefile.
+# Each language makefile fragment must provide the following targets:
+#
+# foo.all.build, foo.all.cross, foo.start.encap, foo.rest.encap,
+# foo.info, foo.dvi,
+# foo.install-normal, foo.install-common, foo.install-info, foo.install-man,
+# foo.uninstall, foo.distdir,
+# foo.mostlyclean, foo.clean, foo.distclean, foo.extraclean,
+# foo.maintainer-clean, foo.stage1, foo.stage2, foo.stage3, foo.stage4
+#
+# where `foo' is the name of the language.
+#
+# It should also provide rules for:
+#
+# - making any compiler driver (eg: g++)
+# - the compiler proper (eg: jc1)
+# - define the names for selecting the language in LANGUAGES.
+\f
+# Extra flags to pass to recursive makes.
+JAVA_FLAGS_TO_PASS = \
+ "JAVA_FOR_BUILD=$(JAVA_FOR_BUILD)" \
+ "JAVAFLAGS=$(JAVAFLAGS)" \
+ "JAVA_FOR_TARGET=$(JAVA_FOR_TARGET)"
+
+# Actual names to use when installing a native compiler.
+JAVA_INSTALL_NAME = `t='$(program_transform_name)'; echo gcj | sed $$t`
+
+# Actual names to use when installing a cross-compiler.
+JAVA_CROSS_NAME = `t='$(program_transform_cross_name)'; echo gcj | sed $$t`
+
+\f
+# Define the names for selecting java in LANGUAGES.
+java: jc1$(exeext) $(GCJ)$(exeext) jvgenmain$(exeext) gcjh$(exeext)
+
+# Define the name of target independant tools to be installed in $(bindir)
+# Names are subject to changes
+JAVA_TARGET_INDEPENDENT_BIN_TOOLS = gcjh jv-scan jcf-dump
+
+# Tell GNU make to ignore these if they exist.
+.PHONY: java
+
+GCJ = gcj
+
+# Remember to keep this list in sync with JAVA_OBJS in Makefile.in!!!
+#
+JAVA_SRCS = $(srcdir)/java/parse.y $(srcdir)/java/class.c \
+ $(srcdir)/java/decl.c $(srcdir)/java/expr.c $(srcdir)/java/constants.c \
+ $(srcdir)/java/lang.c $(srcdir)/java/typeck.c $(srcdir)/java/except.c \
+ $(srcdir)/java/verify.c $(srcdir)/java/zextract.c $(srcdir)/java/jcf-io.c \
+ $(srcdir)/java/jcf-parse.c $(srcdir)/java/mangle.c \
+ $(srcdir)/java/jcf-write.c $(srcdir)/java/buffer.c
+
+jc1$(exeext): $(P) $(JAVA_SRCS) $(LIBDEPS) stamp-objlist
+ cd java; $(MAKE) $(FLAGS_TO_PASS) $(JAVA_FLAGS_TO_PASS) ../jc1$(exeext)
+
+$(GCJ).c: $(srcdir)/gcc.c
+ -rm -f $@
+ $(LN_S) $(srcdir)/gcc.c $@
+
+jvspec.o: $(srcdir)/java/jvspec.c
+ $(CC) -c -DWITH_THREAD_$(GCC_THREAD_FILE) \
+ $(ALL_CFLAGS) $(ALL_CPPFLAGS) \
+ $(INCLUDES) $(srcdir)/java/jvspec.c
+
+# N.B.: This is a copy of the gcc.o rule, with -DLANG_SPECIFIC_DRIVER added.
+# It'd be nice if we could find an easier way to do this---rather than have
+# to track changes to the toplevel gcc Makefile as well.
+# We depend on $(GCJ).c last, to make it obvious where it came from.
+$(GCJ).o: $(CONFIG_H) multilib.h config.status $(lang_specs_files) $(GCJ).c \
+ system.h
+ $(CC) $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \
+ $(DRIVER_DEFINES) \
+ -DLANG_SPECIFIC_DRIVER \
+ -c $(GCJ).c
+
+# Create the compiler driver for $(GCJ).
+$(GCJ)$(exeext): $(GCJ).o jvspec.o version.o choose-temp.o\
+ pexecute.o prefix.o mkstemp.o $(LIBDEPS) $(EXTRA_GCC_OBJS)
+ $(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ $(GCJ).o jvspec.o prefix.o \
+ version.o choose-temp.o pexecute.o mkstemp.o $(EXTRA_GCC_OBJS) $(LIBS)
+
+# Create a version of the $(GCJ) driver which calls the cross-compiler.
+$(GCJ)-cross$(exeext): $(GCJ)$(exeext)
+ -rm -f $(GCJ)-cross$(exeext)
+ cp $(GCJ)$(exeext) $(GCJ)-cross$(exeext)
+
+# Dependencies here must be kept in sync with dependencies in Makefile.in.
+jvgenmain$(exeext): $(srcdir)/java/jvgenmain.c $(srcdir)/java/mangle.c \
+ $(OBSTACK)
+ cd java && $(MAKE) $(FLAGS_TO_PASS) $(JAVA_FLAGS_TO_PASS) ../jvgenmain$(exeext)
+
+# This must be kept in sync with dependencies in Makefile.in.
+GCJH_SOURCES = $(srcdir)/java/gjavah.c $(srcdir)/java/jcf-io.c \
+ $(srcdir)/java/zextract.c $(srcdir)/java/jcf-reader.c \
+ $(srcdir)/java/jcf.h $(srcdir)/java/javaop.h \
+ $(srcdir)/java/javaop.def
+
+gcjh$(exeext): $(GCJH_SOURCES)
+ cd java && $(MAKE) $(FLAGS_TO_PASS) $(JAVA_FLAGS_TO_PASS) ../gcjh$(exeext)
+
+
+\f
+# Build hooks:
+
+java.all.build: $(GCJ)$(exeext) jvgenmain$(exeext) gcjh$(exeext)
+java.all.cross: $(GCJ)-cross$(exeext) jvgenmain$(exeext) gcjh$(exeext)
+java.start.encap: $(GCJ)$(exeext)
+java.rest.encap: jvgenmain$(exeext) gcjh$(exeext)
+
+java.info:
+
+# Install hooks:
+# jc1, gcj, jvgenmain, and gcjh are installed elsewhere as part
+# of $(COMPILERS).
+
+# Nothing to do here.
+java.install-normal:
+
+java.install-common:
+ -if [ -f $(GCJ)$(exeext) ]; then \
+ if [ -f $(GCJ)-cross$(exeext) ]; then \
+ rm -f $(bindir)/$(JAVA_CROSS_NAME)$(exeext); \
+ $(INSTALL_PROGRAM) $(GCJ)-cross$(exeext) $(bindir)/$(JAVA_CROSS_NAME)$(exeext); \
+ chmod a+x $(bindir)/$(JAVA_CROSS_NAME)$(exeext); \
+ else \
+ rm -f $(bindir)/$(JAVA_INSTALL_NAME)$(exeext); \
+ $(INSTALL_PROGRAM) $(GCJ)$(exeext) $(bindir)/$(JAVA_INSTALL_NAME)$(exeext); \
+ chmod a+x $(bindir)/$(JAVA_INSTALL_NAME)$(exeext); \
+ fi ; \
+ fi ; \
+ for tool in $(JAVA_TARGET_INDEPENDENT_BIN_TOOLS); do \
+ if [ -f $$tool$(exeext) ]; then \
+ rm -f $(bindir)/$$tool$(exeext); \
+ $(INSTALL_PROGRAM) $$tool$(exeext) $(bindir)/$$tool$(exeext); \
+ chmod a+x $(bindir)/$$tool$(exeext); \
+ fi ; \
+ done
+
+java.install-man:
+
+java.uninstall:
+ -rm -rf $(bindir)/$(JAVA_INSTALL_NAME)$(exeext)
+ -rm -rf $(bindir)/$(JAVA_CROSS_NAME)$(exeext)
+
+java.install-info:
+
+\f
+# Clean hooks:
+# A lot of the ancillary files are deleted by the main makefile.
+# We just have to delete files specific to us.
+
+java.mostlyclean:
+ -rm -f java/*$(objext) $(DEMANGLER_PROG)
+java.clean:
+java.distclean:
+ -rm -f java/config.status java/Makefile
+ -rm -f java/parse.output
+java.extraclean:
+java.maintainer-clean:
+ -rm -f java/parse.h
+\f
+# Stage hooks:
+# The main makefile has already created stage?/java.
+
+java.stage1:
+ -mv java/*$(objext) stage1/java
+java.stage2:
+ -mv java/*$(objext) stage2/java
+java.stage3:
+ -mv java/*$(objext) stage3/java
+java.stage4:
+ -mv java/*$(objext) stage4/java
+\f
+# Maintenance hooks:
+
+# This target creates the files that can be rebuilt, but go in the
+# distribution anyway. It then copies the files to the distdir directory.
+java.distdir:
+ mkdir tmp/java
+ cd java ; $(MAKE) $(FLAGS_TO_PASS) $(JAVA_FLAGS_TO_PASS) parse.c hash.h
+ cd java; \
+ for file in *[0-9a-zA-Z+]; do \
+ ln $$file ../tmp/java >/dev/null 2>&1 || cp $$file ../tmp/java; \
+ done
--- /dev/null
+# Makefile for GNU compiler for the Java(TM) language.
+# Copyright (C) 1987, 88, 90-4, 1995, 1998 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, 59 Temple Place - Suite 330,
+#Boston, MA 02111-1307, USA.
+
+#Java and all Java-based marks are trademarks or registered trademarks
+#of Sun Microsystems, Inc. in the United States and other countries.
+#The Free Software Foundation is independent of Sun Microsystems, Inc.
+
+# The makefile built from this file lives in the language subdirectory.
+# Its purpose is to provide support for:
+#
+# 1) recursion where necessary, and only then (building .o's), and
+# 2) building and debugging cc1 from the language subdirectory, and
+# 3) nothing else.
+#
+# The parent makefile handles all other chores, with help from the
+# language makefile fragment, of course.
+#
+# The targets for external use are:
+# all, TAGS, ???mostlyclean, ???clean.
+
+# 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.
+
+ALLOCA =
+
+# 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@
+BISON = `if [ -f ../../bison/bison ] ; then echo ../../bison/bison -L $(srcdir)/../../bison/ ; else echo bison ; fi`
+BISONFLAGS =
+JAVABISONFLAGS = --name-prefix=java_
+LEX = `if [ -f ../../flex/flex ] ; then echo ../../flex/flex ; else echo flex ; fi`
+LEXFLAGS =
+AR = ar
+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 in the definition of SUBDIR_USE_ALLOCA.
+# ??? Perhaps it would be better if it just looked for *gcc*.
+OLDCC = cc
+
+# 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.
+
+# 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=@target@
++xmake_file=@dep_host_xmake_file@
++tmake_file=@dep_tmake_file@
+#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 = @srcdir@
+VPATH = @srcdir@
+
+# Additional system libraries to link with.
+CLIB=
+
+# Change this to a null string if obstacks are installed in the
+# system library.
+OBSTACK=obstack.o
+
+# 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
+@target_overrides@
+####host overrides
+@host_overrides@
+####cross overrides
+@cross_overrides@
+####build overrides
+@build_overrides@
+####site overrides
+\f
+# Now figure out from those variables how to compile and link.
+
+all.indirect: Makefile ../jc1$(exeext) ../jcf-dump$(exeext) \
+ ../jvgenmain$(exeext) ../gcjh$(exeext) ../jv-scan$(exeext)
+
+# IN_GCC tells obstack.h that we are using gcc's <stddef.h> file.
+INTERNAL_CFLAGS = $(CROSS) -DIN_GCC @extra_c_flags@
+
+# 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)
+
+# Even if ALLOCA is set, don't use it if compiling with GCC.
+
+SUBDIR_OBSTACK = `if [ x$(OBSTACK) != x ]; then echo ../$(OBSTACK); else true; fi`
+SUBDIR_USE_ALLOCA = `case "${CC}" in "${OLDCC}") if [ x$(ALLOCA) != x ]; then echo ../$(ALLOCA); else true; fi ;; esac`
+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)
+
+# Specify the directories to be searched for header files.
+# Both . and srcdir are used, in that order,
+# so that tm.h and config.h will be found in the compilation
+# subdirectory rather than in the source directory.
+INCLUDES = -I. -I.. -I$(srcdir) -I$(srcdir)/.. -I$(srcdir)/../config
+
+# 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 Gcc/Java:
+
+# Remember to keep this list in sync with JAVA_SRCS in Make-lang.in!!!
+#
+JAVA_OBJS = parse.o class.o decl.o expr.o constants.o lang.o typeck.o \
+ except.o verify.o zextract.o jcf-io.o jcf-parse.o mangle.o jcf-write.o \
+ buffer.o
+
+JAVA_OBJS_LITE = parse-scan.o jv-scan.o
+
+# Language-independent object files.
+OBJS = `cat ../stamp-objlist`
+OBJDEPS = ../stamp-objlist
+
+compiler: ../jc1$(exeext) ../jv-scan$(exeext)
+../jc1$(exeext): $(P) $(JAVA_OBJS) $(OBJDEPS) $(LIBDEPS)
+ rm -f ../jc1$(exeext)
+ $(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ \
+ $(JAVA_OBJS) $(OBJS) $(LIBS)
+../jv-scan$(exeext): $(P) $(JAVA_OBJS_LITE) $(OBJDEPS) $(LIBDEPS)
+ rm -f ../jv-scan$(exeext)
+ $(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ \
+ $(JAVA_OBJS_LITE) $(LIBS)
+
+../jcf-dump$(exeext): jcf-dump.o jcf-io.o zextract.o
+ $(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ jcf-dump.o jcf-io.o zextract.o
+
+# Dependencies here must be kept in sync with dependencies in Make-lang.in.
+../jvgenmain$(exeext): jvgenmain.o mangle.o
+ $(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ jvgenmain.o mangle.o ../obstack.o
+
+../gcjh$(exeext): gjavah.o jcf-io.o zextract.o
+ $(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ gjavah.o jcf-io.o zextract.o
+
+Makefile: $(srcdir)/Makefile.in $(srcdir)/../configure
+ cd ..; $(SHELL) config.status
+
+native: config.status ../jc1$(exeext)
+\f
+# Compiling object files from source files.
+
+PARSE_H = $(srcdir)/parse.h
+PARSE_C = $(srcdir)/parse.c
+PARSE_SCAN_C = $(srcdir)/parse-scan.c
+
+$(PARSE_H): $(PARSE_C)
+$(PARSE_C): $(srcdir)/parse.y $(srcdir)/lex.c $(PARSE_H) $(srcdir)/lex.h
+ $(BISON) -t -v $(BISONFLAGS) $(JAVABISONFLAGS) -o $(PARSE_C) \
+ $(srcdir)/parse.y
+$(PARSE_SCAN_C): $(srcdir)/parse-scan.y $(srcdir)/lex.c $(PARSE_H) \
+ $(srcdir)/lex.h
+ $(BISON) -t -v $(BISONFLAGS) -o $(PARSE_SCAN_C) $(srcdir)/parse-scan.y
+
+lex.c: keyword.h lex.h
+
+keyword.h: keyword.gperf
+ gperf -p -t -j1 -i 1 -g -o -N java_keyword -k1,3,$$ \
+ keyword.gperf > keyword.h
+
+# These exist for maintenance purposes.
+
+# 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: TAGS
+
+mostlyclean:
+ rm -f *.o
+
+clean: mostlyclean
+ rm -f parse.c
+
+force:
+
+parse.o: $(PARSE_C) jcf-reader.c
+jcf-dump.o: jcf-reader.c jcf.h javaop.h javaop.def
+gjavah.o: jcf-reader.c jcf.h javaop.h
--- /dev/null
+/* A "buffer" utility type.
+ Copyright (C) 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+/* Written by Per Bothner <bothner@cygnus.com>, July 1998. */
+
+#include "gansidecl.h"
+#include "buffer.h"
+
+/* Grow BUFP so there is room for at least SIZE more bytes. */
+
+void
+buffer_grow (bufp, size)
+ struct buffer *bufp;
+ int size;
+{
+ if (bufp->limit - bufp->ptr >= size)
+ return;
+ if (bufp->data == 0)
+ {
+ if (size < 120)
+ size = 120;
+ bufp->data = (unsigned char*) xmalloc (size);
+ bufp->ptr = bufp->data;
+ }
+ else
+ {
+ int index = bufp->ptr - bufp->data;
+ size += 2 * (bufp->limit - bufp->data);
+ bufp->data = (unsigned char *) xrealloc (bufp->data, size);
+ bufp->ptr = bufp->data + index;
+ }
+ bufp->limit = bufp->data + size;
+}
--- /dev/null
+/* A "buffer" utility type.
+ Copyright (C) 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+/* Written by Per Bothner <bothner@cygnus.com>, July 1998. */
+
+/* A simple data structure for an expandable buffer. */
+
+struct buffer
+{
+ /* The start of the actual data buffer. */
+ unsigned char *data;
+
+ /* Where to write next in the buffer. */
+ unsigned char *ptr;
+
+ /* The end of the allocated data buffer. */
+ unsigned char *limit;
+};
+
+#define NULL_BUFFER { (void*) 0, (void*) 0, (void*) 0 }
+
+#define BUFFER_LENGTH(BUFP) ((BUFP)->ptr - (BUFP)->data)
+
+#define BUFFER_RESET(BUFP) ((BUFP)->ptr = (BUFP)->data)
+
+extern void buffer_grow PROTO ((struct buffer*, int));
--- /dev/null
+/* Functions related to building classes and their related objects.
+ Copyright (C) 1996, 1997, 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Written by Per Bothner <bothner@cygnus.com> */
+
+#include <stdio.h>
+#include "config.h"
+#include "tree.h"
+#include "rtl.h"
+#include "java-tree.h"
+#include "jcf.h"
+#include "obstack.h"
+
+static tree mangle_class_field PROTO ((tree class));
+
+static rtx registerClass_libfunc;
+
+extern struct obstack permanent_obstack;
+extern struct obstack temporary_obstack;
+
+/* Return an IDENTIFIER_NODE the same as (OLD_NAME, OLD_LENGTH).
+ except that characters matching OLD_CHAR are substituted by NEW_CHAR.
+ Also, PREFIX is prepended, and SUFFIX is appended. */
+
+tree
+ident_subst (old_name, old_length, prefix, old_char, new_char, suffix)
+ const char* old_name;
+ int old_length;
+ const char *prefix;
+ int old_char;
+ int new_char;
+ const char *suffix;
+{
+ int prefix_len = strlen (prefix);
+ int suffix_len = strlen (suffix);
+ int i = prefix_len + old_length + suffix_len + 1;
+#ifdef __GNUC__
+ char buffer[i];
+#else
+ char *buffer = (char *)alloca (i);
+#endif
+ strcpy (buffer, prefix);
+ for (i = 0; i < old_length; i++)
+ {
+ char ch = old_name[i];
+ if (ch == old_char)
+ ch = new_char;
+ buffer[prefix_len + i] = ch;
+ }
+ strcpy (buffer + prefix_len + old_length, suffix);
+ return get_identifier (buffer);
+}
+
+/* Return an IDENTIFIER_NODE the same as OLD_ID,
+ except that characters matching OLD_CHAR are substituted by NEW_CHAR.
+ Also, PREFIX is prepended, and SUFFIX is appended. */
+
+tree
+identifier_subst (old_id, prefix, old_char, new_char, suffix)
+ const tree old_id;
+ const char *prefix;
+ int old_char;
+ int new_char;
+ const char *suffix;
+{
+ return ident_subst (IDENTIFIER_POINTER (old_id), IDENTIFIER_LENGTH (old_id),
+ prefix, old_char, new_char, suffix);
+}
+
+/* Generate a valid C identifier from the name of the class TYPE,
+ prefixed by PREFIX. */
+
+tree
+mangled_classname (prefix, type)
+ char *prefix;
+ tree type;
+{
+ tree ident = TYPE_NAME (type);
+ if (TREE_CODE (ident) != IDENTIFIER_NODE)
+ ident = DECL_NAME (ident);
+ return identifier_subst (ident, prefix, '/', '_', "");
+}
+
+tree
+make_class ()
+{
+ tree type;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ type = make_node (RECORD_TYPE);
+#ifdef JAVA_USE_HANDLES
+ tree field1 = build_decl (FIELD_DECL, get_identifier ("obj"),
+ build_pointer_type (type));
+ tree field2 = build_decl (FIELD_DECL, get_identifier ("methods"),
+ methodtable_ptr_type);
+ tree handle_type = make_node (RECORD_TYPE);
+ TREE_CHAIN (field1) = field2;
+ TYPE_FIELDS (handle_type) = field1;
+ TYPE_BINFO (type) = make_tree_vec (7);
+ TYPE_BINFO (handle_type) = make_tree_vec (7);
+ BINFO_HANDLE (TYPE_BINFO (handle_type)) = type;
+ BINFO_HANDLE (TYPE_BINFO (type)) = handle_type;
+#else
+ TYPE_BINFO (type) = make_tree_vec (6);
+#endif
+ CLASS_P (type) = 1;
+ pop_obstacks ();
+
+ return type;
+}
+
+/* Given a fully-qualified classname in NAME (whose length is NAME_LENGTH),
+ and where each of the constituents is separated by '/',
+ return a corresponding IDENTIFIER_NODE, except using '.' as separator. */
+
+tree
+unmangle_classname (name, name_length)
+ const char *name; int name_length;
+{
+ return ident_subst (name, name_length, "", '/', '.', "");
+}
+
+tree
+push_class (class_type, class_name)
+ tree class_type, class_name;
+{
+ tree decl, signature;
+ char *save_input_filename = input_filename;
+ int save_lineno = lineno;
+ tree source_name = identifier_subst (class_name, "", '.', '/', ".java");
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ input_filename = IDENTIFIER_POINTER (source_name);
+ lineno = 0;
+ decl = build_decl (TYPE_DECL, class_name, class_type);
+ input_filename = save_input_filename;
+ lineno = save_lineno;
+ signature = identifier_subst (class_name, "L", '.', '/', ";");
+ IDENTIFIER_SIGNATURE_TYPE (signature) = class_type;
+
+ /* Setting DECL_ARTIFICAL forces dbxout.c to specific the type is
+ both a typedef and in the struct name-space. We may want to re-visit
+ this later, but for now it reduces the changes needed for gdb. */
+ DECL_ARTIFICIAL (decl) = 1;
+
+ pushdecl_top_level (decl);
+#ifdef JAVA_USE_HANDLES
+ {
+ tree handle_name = identifier_subst (class_name,
+ "Handle$", '.', '.', "");
+ tree handle_decl = build_decl (TYPE_DECL, handle_name,
+ CLASS_TO_HANDLE_TYPE (class_type));
+ pushdecl (handle_decl);
+ }
+#endif
+
+ pop_obstacks ();
+ return decl;
+}
+
+/* Finds the (global) class named NAME. Creates the class if not found.
+ Also creates associated TYPE_DECL.
+ Does not check if the class actually exists, load the class,
+ fill in field or methods, or do layout_type. */
+
+tree
+lookup_class (name)
+ tree name;
+{
+ tree decl = IDENTIFIER_CLASS_VALUE (name);
+ if (decl == NULL_TREE)
+ decl = push_class (make_class (), name);
+ return TREE_TYPE (decl);
+}
+
+void
+set_super_info (access_flags, this_class, super_class, interfaces_count)
+ int access_flags;
+ tree this_class;
+ tree super_class;
+ int interfaces_count;
+{
+ int total_supers = interfaces_count;
+ tree class_decl = TYPE_NAME (this_class);
+ if (super_class)
+ total_supers++;
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ TYPE_BINFO_BASETYPES (this_class) = make_tree_vec (total_supers);
+ if (super_class)
+ {
+ tree super_binfo = make_tree_vec (6);
+ BINFO_TYPE (super_binfo) = super_class;
+ BINFO_OFFSET (super_binfo) = integer_zero_node;
+ TREE_VIA_PUBLIC (super_binfo) = 1;
+ TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (this_class)), 0)
+ = super_binfo;
+ CLASS_HAS_SUPER (this_class) = 1;
+ }
+ pop_obstacks ();
+
+ if (access_flags & ACC_PUBLIC) CLASS_PUBLIC (class_decl) = 1;
+ if (access_flags & ACC_FINAL) CLASS_FINAL (class_decl) = 1;
+ if (access_flags & ACC_SUPER) CLASS_SUPER (class_decl) = 1;
+ if (access_flags & ACC_INTERFACE) CLASS_INTERFACE (class_decl) = 1;
+ if (access_flags & ACC_ABSTRACT) CLASS_ABSTRACT (class_decl) = 1;
+}
+
+/* Return length of inheritance chain of CLAS, where java.lang.Object is 0,
+ direct sub-classes of Object are 1, and so on. */
+
+int
+class_depth (clas)
+ tree clas;
+{
+ int depth = 0;
+ if (! CLASS_LOADED_P (clas))
+ load_class (clas, 1);
+ while (clas != object_type_node)
+ {
+ depth++;
+ clas = TYPE_BINFO_BASETYPE (clas, 0);
+ }
+ return depth;
+}
+
+/* Return true iff TYPE2 is an interface that extends interface TYPE1 */
+
+int
+interface_of_p (type1, type2)
+ tree type1, type2;
+{
+ int n, i;
+ tree basetype_vec;
+
+ if (!(basetype_vec = TYPE_BINFO_BASETYPES (type2)))
+ return 0;
+ n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; i < n; i++)
+ {
+ tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
+ if (vec_elt && BINFO_TYPE (vec_elt) == type1)
+ return 1;
+ }
+ for (i = 0; i < n; i++)
+ {
+ tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
+ if (vec_elt && BINFO_TYPE (vec_elt)
+ && interface_of_p (type1, BINFO_TYPE (vec_elt)))
+ return 1;
+ }
+ return 0;
+}
+
+/* Return true iff TYPE1 inherits from TYPE2. */
+
+int
+inherits_from_p (type1, type2)
+ tree type1, type2;
+{
+ while (type1 != NULL_TREE && TREE_CODE (type1) == RECORD_TYPE)
+ {
+ if (type1 == type2)
+ return 1;
+ type1 = CLASSTYPE_SUPER (type1);
+ }
+ return 0;
+}
+
+static void
+add_interface_do (basetype_vec, interface_class, i)
+ tree basetype_vec, interface_class;
+ int i;
+{
+ tree interface_binfo = make_tree_vec (6);
+ BINFO_TYPE (interface_binfo) = interface_class;
+ BINFO_OFFSET (interface_binfo) = integer_zero_node;
+ TREE_VIA_VIRTUAL (interface_binfo) = 1;
+ TREE_VIA_PUBLIC (interface_binfo) = 1;
+ TREE_VEC_ELT (basetype_vec, i) = interface_binfo;
+}
+
+/* Add INTERFACE_CLASS to THIS_CLASS iff INTERFACE_CLASS can't be
+ found in THIS_CLASS. Returns NULL_TREE upon success, INTERFACE_CLASS
+ if attempt is made to add it twice. */
+
+tree
+maybe_add_interface (this_class, interface_class)
+ tree this_class, interface_class;
+{
+ tree basetype_vec = TYPE_BINFO_BASETYPES (this_class);
+ tree interface_binfo = make_tree_vec (6);
+ int i;
+ int n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; ; i++)
+ {
+ if (i >= n)
+ {
+ error ("internal error - too many interface type");
+ return NULL_TREE;
+ }
+ else if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
+ break;
+ else if (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)) == interface_class)
+ return interface_class;
+ }
+ add_interface_do (basetype_vec, interface_class, i);
+ return NULL_TREE;
+}
+
+/* Add the INTERFACE_CLASS as one of the interfaces of THIS_CLASS. */
+
+void
+add_interface (this_class, interface_class)
+ tree this_class, interface_class;
+{
+ tree basetype_vec = TYPE_BINFO_BASETYPES (this_class);
+ int i;
+ int n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; ; i++)
+ {
+ if (i >= n)
+ {
+ error ("internal error - too many interface type");
+ return;
+ }
+ else if (TREE_VEC_ELT (basetype_vec, i) == NULL_TREE)
+ break;
+ }
+ add_interface_do (basetype_vec, interface_class, i);
+}
+
+/* Return the address of a pointer to the first FUNCTION_DECL
+ in the list (*LIST) whose DECL_NAME is NAME. */
+
+static tree *
+find_named_method (list, name)
+ tree *list;
+ tree name;
+{
+ while (*list && DECL_NAME (*list) != name)
+ list = &TREE_CHAIN (*list);
+ return list;
+}
+
+tree
+build_java_method_type (fntype, this_class, access_flags)
+ tree fntype;
+ tree this_class;
+ int access_flags;
+{
+ if (access_flags & ACC_STATIC)
+ return fntype;
+ return build_method_type (CLASS_TO_HANDLE_TYPE (this_class), fntype);
+}
+
+tree
+add_method_1 (handle_class, access_flags, name, function_type)
+ tree handle_class;
+ int access_flags;
+ tree name;
+ tree function_type;
+{
+ tree method_type, fndecl;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+
+ method_type = build_java_method_type (function_type,
+ handle_class, access_flags);
+
+ fndecl = build_decl (FUNCTION_DECL, name, method_type);
+ DECL_CONTEXT (fndecl) = handle_class;
+
+ DECL_LANG_SPECIFIC (fndecl)
+ = (struct lang_decl *) permalloc (sizeof (struct lang_decl));
+ bzero (DECL_LANG_SPECIFIC (fndecl), sizeof (struct lang_decl));
+
+ TREE_CHAIN (fndecl) = TYPE_METHODS (handle_class);
+ TYPE_METHODS (handle_class) = fndecl;
+ pop_obstacks ();
+
+ if (access_flags & ACC_PUBLIC) METHOD_PUBLIC (fndecl) = 1;
+ if (access_flags & ACC_PROTECTED) METHOD_PROTECTED (fndecl) = 1;
+ if (access_flags & ACC_PRIVATE) METHOD_PRIVATE (fndecl) = 1;
+ if (access_flags & ACC_NATIVE) METHOD_NATIVE (fndecl) = 1;
+ if (access_flags & ACC_STATIC) METHOD_STATIC (fndecl) = 1;
+ if (access_flags & ACC_FINAL) METHOD_FINAL (fndecl) = 1;
+ if (access_flags & ACC_SYNCHRONIZED) METHOD_SYNCHRONIZED (fndecl) = 1;
+ if (access_flags & ACC_ABSTRACT) METHOD_ABSTRACT (fndecl) = 1;
+ if (access_flags & ACC_TRANSIENT) METHOD_TRANSIENT (fndecl) = 1;
+ return fndecl;
+}
+
+/* Add a method to THIS_CLASS.
+ The method's name is NAME.
+ Its signature (mangled type) is METHOD_SIG (an IDENTIFIER_NODE). */
+
+tree
+add_method (this_class, access_flags, name, method_sig)
+ tree this_class;
+ int access_flags;
+ tree name;
+ tree method_sig;
+{
+ tree handle_class = CLASS_TO_HANDLE_TYPE (this_class);
+ tree function_type, method_type, fndecl;
+ unsigned char *sig = (unsigned char*)IDENTIFIER_POINTER (method_sig);
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ if (sig[0] != '(')
+ fatal ("bad method signature");
+ function_type = get_type_from_signature (method_sig);
+ fndecl = add_method_1 (handle_class, access_flags, name, function_type);
+ set_java_signature (TREE_TYPE (fndecl), method_sig);
+ pop_obstacks ();
+ return fndecl;
+}
+
+tree
+add_field (class, name, field_type, flags)
+ tree class;
+ tree name;
+ tree field_type;
+ int flags;
+{
+ int is_static = (flags & ACC_STATIC) != 0;
+ tree field;
+ /* Push the obstack of field_type ? FIXME */
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+#if ! JAVA_PROMOTE_TO_INT
+ if (TREE_CODE (field_type) == RECORD_TYPE)
+#endif
+ field_type = promote_type (field_type);
+ field = build_decl (is_static ? VAR_DECL : FIELD_DECL, name, field_type);
+ pop_obstacks ();
+ TREE_CHAIN (field) = TYPE_FIELDS (class);
+ TYPE_FIELDS (class) = field;
+ DECL_CONTEXT (field) = class;
+
+ if (flags & ACC_PUBLIC) FIELD_PUBLIC (field) = 1;
+ if (flags & ACC_PROTECTED) FIELD_PROTECTED (field) = 1;
+ if (flags & ACC_PRIVATE) FIELD_PRIVATE (field) = 1;
+ if (flags & ACC_FINAL) FIELD_FINAL (field) = 1;
+ if (flags & ACC_VOLATILE) FIELD_VOLATILE (field) = 1;
+ if (flags & ACC_TRANSIENT) FIELD_TRANSIENT (field) = 1;
+ if (is_static)
+ {
+ FIELD_STATIC (field) = 1;
+ if (! FIELD_PRIVATE (field) || FIELD_PROTECTED (field))
+ TREE_PUBLIC (field) = 1;
+ }
+ return field;
+}
+
+/* Associate a constant value CONSTANT with VAR_DECL FIELD. */
+
+void
+set_constant_value (field, constant)
+ tree field, constant;
+{
+ if (field == NULL_TREE)
+ warning ("misplaced ConstantValue attribute (not in any field)");
+ else if (DECL_INITIAL (field) != NULL_TREE)
+ warning ("duplicate ConstanValue atribute for field '%s'",
+ IDENTIFIER_POINTER (DECL_NAME (field)));
+ else
+ DECL_INITIAL (field) = constant;
+}
+
+/* Count the number of Unicode chars encoded in a given Ut8 string. */
+
+int
+strLengthUtf8 (str, len)
+ char *str;
+ int len;
+{
+ register unsigned char* ptr = (unsigned char*) str;
+ register unsigned char *limit = ptr + len;
+ int str_length = 0;
+ for (; ptr < limit; str_length++) {
+ if (UTF8_GET (ptr, limit) < 0)
+ return -1;
+ }
+ return str_length;
+}
+
+
+/* Calculate a hash value for a string encoded in Utf8 format.
+ * This returns the same hash value as specified for java.lang.String.hashCode.
+ */
+
+int32
+hashUtf8String (str, len)
+ char *str;
+ int len;
+{
+ register unsigned char* ptr = (unsigned char*) str;
+ register unsigned char *limit = ptr + len;
+ int32 hash = 0;
+ for (; ptr < limit;)
+ {
+ int ch = UTF8_GET (ptr, limit);
+ /* Updated specification from
+ http://www.javasoft.com/docs/books/jls/clarify.html. */
+ hash = (31 * hash) + ch;
+ }
+ return hash;
+}
+
+tree utf8_decl_list = NULL_TREE;
+
+tree
+build_utf8_ref (name)
+ tree name;
+{
+ char* name_ptr = IDENTIFIER_POINTER(name);
+ int name_len = IDENTIFIER_LENGTH(name);
+ char buf[60];
+ char *buf_ptr;
+ tree ctype, field, str_type, cinit, string;
+ static int utf8_count = 0;
+ int name_hash;
+ tree ref = IDENTIFIER_UTF8_REF (name);
+ tree decl;
+ if (ref != NULL_TREE)
+ return ref;
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ ctype = make_node (RECORD_TYPE);
+ str_type = build_prim_array_type (unsigned_byte_type_node,
+ name_len + 1); /* Allow for final '\0'. */
+ PUSH_FIELD (ctype, field, "hash", unsigned_short_type_node);
+ PUSH_FIELD (ctype, field, "length", unsigned_short_type_node);
+ PUSH_FIELD (ctype, field, "data", str_type);
+ FINISH_RECORD (ctype);
+ START_RECORD_CONSTRUCTOR (cinit, ctype);
+ name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
+ PUSH_FIELD_VALUE (cinit, "hash", build_int_2 (name_hash, 0));
+ PUSH_FIELD_VALUE (cinit, "length", build_int_2 (name_len, 0));
+ string = build_string (name_len, name_ptr);
+ TREE_TYPE (string) = str_type;
+ PUSH_FIELD_VALUE (cinit, "data", string);
+ FINISH_RECORD_CONSTRUCTOR (cinit);
+
+ /* Build a unique identifier based on buf. */
+ sprintf(buf, "_Utf%d", ++utf8_count);
+ buf_ptr = &buf[strlen (buf)];
+ while (--name_len >= 0)
+ {
+ char c = *name_ptr++;
+ if (c & 0x80)
+ continue;
+ if (!isalpha(c) && !isdigit(c))
+ c = '_';
+ *buf_ptr++ = c;
+ if (buf_ptr >= buf + 50)
+ break;
+ }
+ *buf_ptr = '\0';
+
+ decl = build_decl (VAR_DECL, get_identifier (buf), utf8const_type);
+ /* FIXME get some way to force this into .text, not .data. */
+ TREE_STATIC (decl) = 1;
+ DECL_ARTIFICIAL (decl) = 1;
+ DECL_IGNORED_P (decl) = 1;
+ TREE_READONLY (decl) = 1;
+ DECL_INITIAL (decl) = cinit;
+ TREE_CHAIN (decl) = utf8_decl_list;
+ layout_decl (decl, 0);
+ pushdecl (decl);
+ rest_of_decl_compilation (decl, (char*) 0, global_bindings_p (), 0);
+ utf8_decl_list = decl;
+ make_decl_rtl (decl, (char*) 0, 1);
+ ref = build1 (ADDR_EXPR, utf8const_ptr_type, decl);
+ IDENTIFIER_UTF8_REF (name) = ref;
+ pop_obstacks ();
+ return ref;
+}
+
+/* Build a reference to the class TYPE.
+ Also handles primitive types and array types. */
+
+tree
+build_class_ref (type)
+ tree type;
+{
+ int is_compiled = is_compiled_class (type);
+ if (is_compiled)
+ {
+ tree ref, decl_name, decl;
+ if (TREE_CODE (type) == POINTER_TYPE)
+ type = TREE_TYPE (type);
+ if (TREE_CODE (type) == RECORD_TYPE)
+ {
+ if (TYPE_SIZE (type) == error_mark_node)
+ return null_pointer_node;
+ decl_name = identifier_subst (DECL_NAME (TYPE_NAME (type)),
+ "", '/', '/', ".class");
+ decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
+ if (decl == NULL_TREE)
+ {
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ decl = build_decl (VAR_DECL, decl_name, class_type_node);
+ DECL_SIZE (decl) = TYPE_SIZE (class_type_node);
+ TREE_STATIC (decl) = 1;
+ TREE_PUBLIC (decl) = 1;
+ DECL_IGNORED_P (decl) = 1;
+ DECL_ARTIFICIAL (decl) = 1;
+ DECL_ASSEMBLER_NAME (decl) = mangle_class_field (type);
+ make_decl_rtl (decl, NULL, 1);
+ pushdecl_top_level (decl);
+ if (is_compiled == 1)
+ DECL_EXTERNAL (decl) = 1;
+ pop_obstacks ();
+ }
+ }
+ else
+ {
+ char *name;
+ char buffer[20];
+ decl_name = TYPE_NAME (type);
+ if (TREE_CODE (decl_name) == TYPE_DECL)
+ decl_name = DECL_NAME (decl_name);
+ name = IDENTIFIER_POINTER (decl_name);
+ if (strncmp (name, "promoted_", 9) == 0)
+ name += 9;
+ sprintf (buffer, "%sClass", name);
+ decl_name = get_identifier (buffer);
+ decl = IDENTIFIER_GLOBAL_VALUE (decl_name);
+ if (decl == NULL_TREE)
+ {
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ decl = build_decl (VAR_DECL, decl_name, class_type_node);
+ TREE_STATIC (decl) = 1;
+ TREE_PUBLIC (decl) = 1;
+ make_decl_rtl (decl, NULL, 1);
+ pushdecl_top_level (decl);
+ if (is_compiled == 1)
+ DECL_EXTERNAL (decl) = 1;
+ pop_obstacks ();
+ }
+ }
+
+ ref = build1 (ADDR_EXPR, class_ptr_type, decl);
+ return ref;
+ }
+ else
+ {
+ int index;
+ tree cl;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ index = alloc_class_constant (type);
+ cl = build_ref_from_constant_pool (index);
+ TREE_TYPE (cl) = promote_type (class_ptr_type);
+ pop_obstacks ();
+ return cl;
+ }
+}
+
+tree
+build_static_field_ref (fdecl)
+ tree fdecl;
+{
+ tree fclass = DECL_CONTEXT (fdecl);
+ int is_compiled = is_compiled_class (fclass);
+ if (is_compiled)
+ {
+ if (DECL_RTL (fdecl) == 0)
+ {
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ make_decl_rtl (fdecl, NULL, 1);
+ pop_obstacks ();
+ if (is_compiled == 1)
+ DECL_EXTERNAL (fdecl) = 1;
+ }
+ return fdecl;
+ }
+ else
+ {
+ /* Compile as:
+ * *(FTYPE*)build_class_ref(FCLASS)->fields[INDEX].info.addr
+ */
+ static tree fields_ident = NULL_TREE;
+ static tree info_ident = NULL_TREE;
+ tree ref = build_class_ref (fclass);
+ tree fld;
+ int field_index = 0;
+ ref = build1 (INDIRECT_REF, class_type_node, ref);
+ if (fields_ident == NULL_TREE)
+ fields_ident = get_identifier ("fields");
+ if (info_ident == NULL_TREE)
+ info_ident = get_identifier ("info");
+ ref = build (COMPONENT_REF, field_ptr_type_node, ref,
+ lookup_field (&class_type_node, fields_ident));
+
+ for (fld = TYPE_FIELDS (fclass); ; fld = TREE_CHAIN (fld))
+ {
+ if (fld == fdecl)
+ break;
+ if (fld == NULL_TREE)
+ fatal ("field '%s' not found in class",
+ IDENTIFIER_POINTER (DECL_NAME (fdecl)));
+ if (FIELD_STATIC (fld))
+ field_index++;
+ }
+ field_index *= int_size_in_bytes (field_type_node);
+ ref = fold (build (PLUS_EXPR, field_ptr_type_node,
+ ref, build_int_2 (field_index, 0)));
+ ref = build1 (INDIRECT_REF, field_type_node, ref);
+ ref = build (COMPONENT_REF, field_info_union_node,
+ ref, lookup_field (&field_type_node, info_ident));
+ ref = build (COMPONENT_REF, ptr_type_node,
+ ref, TREE_CHAIN (TYPE_FIELDS (field_info_union_node)));
+ return fold (build1 (INDIRECT_REF, TREE_TYPE(fdecl), ref));
+ }
+}
+
+int
+get_access_flags_from_decl (decl)
+ tree decl;
+{
+ int access_flags = 0;
+ if (TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL)
+ {
+ if (FIELD_STATIC (decl))
+ access_flags |= ACC_STATIC;
+ if (FIELD_PUBLIC (decl))
+ access_flags |= ACC_PUBLIC;
+ if (FIELD_PROTECTED (decl))
+ access_flags |= ACC_PROTECTED;
+ if (FIELD_PRIVATE (decl))
+ access_flags |= ACC_PRIVATE;
+ if (FIELD_FINAL (decl))
+ access_flags |= ACC_FINAL;
+ if (FIELD_VOLATILE (decl))
+ access_flags |= ACC_VOLATILE;
+ if (FIELD_TRANSIENT (decl))
+ access_flags |= ACC_TRANSIENT;
+ return access_flags;
+ }
+ if (TREE_CODE (decl) == TYPE_DECL)
+ {
+ if (CLASS_PUBLIC (decl))
+ access_flags |= ACC_PUBLIC;
+ if (CLASS_FINAL (decl))
+ access_flags |= ACC_FINAL;
+ if (CLASS_SUPER (decl))
+ access_flags |= ACC_SUPER;
+ if (CLASS_INTERFACE (decl))
+ access_flags |= ACC_INTERFACE;
+ if (CLASS_ABSTRACT (decl))
+ access_flags |= ACC_ABSTRACT;
+ return access_flags;
+ }
+ if (TREE_CODE (decl) == FUNCTION_DECL)
+ {
+ if (METHOD_PUBLIC (decl))
+ access_flags |= ACC_PUBLIC;
+ if (METHOD_PRIVATE (decl))
+ access_flags |= ACC_PRIVATE;
+ if (METHOD_PROTECTED (decl))
+ access_flags |= ACC_PROTECTED;
+ if (METHOD_STATIC (decl))
+ access_flags |= ACC_STATIC;
+ if (METHOD_FINAL (decl))
+ access_flags |= ACC_FINAL;
+ if (METHOD_SYNCHRONIZED (decl))
+ access_flags |= ACC_SYNCHRONIZED;
+ if (METHOD_NATIVE (decl))
+ access_flags |= ACC_NATIVE;
+ if (METHOD_ABSTRACT (decl))
+ access_flags |= ACC_ABSTRACT;
+ if (METHOD_TRANSIENT (decl))
+ access_flags |= ACC_TRANSIENT;
+ return access_flags;
+ }
+ abort ();
+}
+
+tree
+make_field_value (tree fdecl)
+{
+ tree finit, info;
+ int bsize, flags;
+ tree type = TREE_TYPE (fdecl);
+ int resolved = is_compiled_class (type);
+ START_RECORD_CONSTRUCTOR (finit, field_type_node);
+ PUSH_FIELD_VALUE (finit, "name", build_utf8_ref (DECL_NAME (fdecl)));
+ if (resolved)
+ type = build_class_ref (type);
+ else
+ type = build_utf8_ref (build_java_signature (type));
+ PUSH_FIELD_VALUE (finit, "type", type);
+ flags = get_access_flags_from_decl (fdecl);
+ if (! resolved)
+ flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
+ PUSH_FIELD_VALUE (finit, "accflags", build_int_2 (flags, 0));
+ bsize = TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (fdecl))) / BITS_PER_UNIT;
+ PUSH_FIELD_VALUE (finit, "bsize", build_int_2 (bsize, 0));
+ if (FIELD_STATIC (fdecl))
+ {
+ tree cfield = TREE_CHAIN (TYPE_FIELDS(field_info_union_node));
+ tree faddr = build_address_of (build_static_field_ref (fdecl));
+ info = build (CONSTRUCTOR, field_info_union_node, NULL_TREE,
+ build_tree_list (cfield, faddr));
+ }
+ else
+ {
+ int boffset
+ = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (fdecl)) / BITS_PER_UNIT;
+ info = build (CONSTRUCTOR, field_info_union_node, NULL_TREE,
+ build_tree_list (TYPE_FIELDS(field_info_union_node),
+ build_int_2 (boffset, 0)));
+ }
+ PUSH_FIELD_VALUE (finit, "info", info);
+
+ FINISH_RECORD_CONSTRUCTOR (finit);
+ return finit;
+}
+
+tree
+make_method_value (mdecl, this_class_addr)
+ tree mdecl;
+ tree this_class_addr;
+{
+ tree minit;
+ tree code;
+#define ACC_TRANSLATED 0x4000
+ int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED;
+ code = null_pointer_node;
+ if (DECL_RTL (mdecl))
+ code = build1 (ADDR_EXPR, nativecode_ptr_type_node, mdecl);
+ START_RECORD_CONSTRUCTOR (minit, method_type_node);
+ PUSH_FIELD_VALUE (minit, "name",
+ build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ?
+ init_identifier_node
+ : DECL_NAME (mdecl)));
+ PUSH_FIELD_VALUE (minit, "signature",
+ build_utf8_ref (build_java_signature (TREE_TYPE (mdecl))));
+ PUSH_FIELD_VALUE (minit, "accflags", build_int_2 (accflags, 0));
+ PUSH_FIELD_VALUE (minit, "ncode", code);
+ FINISH_RECORD_CONSTRUCTOR (minit);
+ return minit;
+}
+
+tree
+get_dispatch_vector (type)
+ tree type;
+{
+ tree vtable = TYPE_VTABLE (type);
+ if (vtable == NULL)
+ {
+ int i;
+ tree method;
+ tree super = CLASSTYPE_SUPER (type);
+ int nvirtuals = TREE_INT_CST_LOW (TYPE_NVIRTUALS (type));
+ vtable = make_tree_vec (nvirtuals);
+ TYPE_VTABLE (type) = vtable;
+ if (super != NULL_TREE)
+ {
+ tree super_vtable = get_dispatch_vector (super);
+ for ( i = TREE_INT_CST_LOW (TYPE_NVIRTUALS (super)); --i >= 0; )
+ TREE_VEC_ELT (vtable, i) = TREE_VEC_ELT (super_vtable, i);
+ }
+ for (method = TYPE_METHODS (type); method != NULL_TREE;
+ method = TREE_CHAIN (method))
+ {
+ if (DECL_VINDEX (method) != NULL_TREE
+ && TREE_CODE (DECL_VINDEX (method)) == INTEGER_CST)
+ {
+ TREE_VEC_ELT (vtable, TREE_INT_CST_LOW (DECL_VINDEX (method)))
+ = method;
+ }
+ }
+ }
+ return vtable;
+}
+
+tree
+get_dispatch_table (type, this_class_addr)
+ tree type, this_class_addr;
+{
+ tree vtable = get_dispatch_vector (type);
+ int i;
+ tree list = NULL_TREE;
+ int nvirtuals = TREE_VEC_LENGTH (vtable);
+ for (i = nvirtuals; --i >= 0; )
+ {
+ tree method = TREE_VEC_ELT (vtable, i);
+ if (METHOD_ABSTRACT (method))
+ warning_with_decl (method, "abstract method in non-abstract class");
+ if (DECL_RTL (method) == 0)
+ make_decl_rtl (method, NULL, 1);
+ list = tree_cons (NULL_TREE /*DECL_VINDEX (method) + 2*/,
+ build1 (ADDR_EXPR, nativecode_ptr_type_node, method),
+ list);
+ }
+ /* Dummy entry for compatibility with G++ -fvtable-thunks. */
+ list = tree_cons (integer_zero_node, null_pointer_node, list);
+ list = tree_cons (integer_zero_node, this_class_addr, list);
+ return build (CONSTRUCTOR, build_prim_array_type (nativecode_ptr_type_node,
+ nvirtuals + 2),
+ NULL_TREE, list);
+}
+
+void
+make_class_data (type)
+ tree type;
+{
+ tree decl, cons, temp;
+ tree field, fields_decl;
+ tree static_fields = NULL_TREE;
+ tree instance_fields = NULL_TREE;
+ HOST_WIDE_INT static_field_count = 0;
+ HOST_WIDE_INT instance_field_count = 0;
+ HOST_WIDE_INT field_count;
+ tree field_array_type;
+ tree method;
+ tree methods = NULL_TREE;
+ tree dtable_decl = NULL_TREE;
+ HOST_WIDE_INT method_count = 0;
+ tree method_array_type;
+ tree methods_decl;
+ tree super;
+ tree this_class_addr;
+ tree constant_pool_constructor;
+ tree interfaces = null_pointer_node;
+ int interface_len = 0;
+ tree type_decl = TYPE_NAME (type);
+
+ this_class_addr = build_class_ref (type);
+ decl = TREE_OPERAND (this_class_addr, 0);
+
+ /* Build Field array. */
+ field = TYPE_FIELDS (type);
+ if (DECL_NAME (field) == NULL_TREE)
+ field = TREE_CHAIN (field); /* Skip dummy field for inherited data. */
+ for ( ; field != NULL_TREE; field = TREE_CHAIN (field))
+ {
+ if (! DECL_ARTIFICIAL (field))
+ {
+ tree init = make_field_value (field);
+ if (FIELD_STATIC (field))
+ {
+ static_field_count++;
+ static_fields = tree_cons (NULL_TREE, init, static_fields);
+ rest_of_decl_compilation (field, (char*) 0, 1, 1);
+ }
+ else
+ {
+ instance_field_count++;
+ instance_fields = tree_cons (NULL_TREE, init, instance_fields);
+ }
+ }
+ }
+ field_count = static_field_count + instance_field_count;
+ if (field_count > 0)
+ {
+ static_fields = nreverse (static_fields);
+ instance_fields = nreverse (instance_fields);
+ static_fields = chainon (static_fields, instance_fields);
+ field_array_type = build_prim_array_type (field_type_node, field_count);
+ fields_decl = build_decl (VAR_DECL, mangled_classname ("_FL_", type),
+ field_array_type);
+ DECL_INITIAL (fields_decl) = build (CONSTRUCTOR, field_array_type,
+ NULL_TREE, static_fields);
+ TREE_STATIC (fields_decl) = 1;
+ DECL_ARTIFICIAL (fields_decl) = 1;
+ DECL_IGNORED_P (fields_decl) = 1;
+ rest_of_decl_compilation (fields_decl, (char*) 0, 1, 0);
+ }
+ else
+ fields_decl = NULL_TREE;
+
+ /* Build Method array. */
+ for (method = TYPE_METHODS (CLASS_TO_HANDLE_TYPE (type));
+ method != NULL_TREE; method = TREE_CHAIN (method))
+ {
+ tree init = make_method_value (method, this_class_addr);
+ method_count++;
+ methods = tree_cons (NULL_TREE, init, methods);
+ }
+ method_array_type = build_prim_array_type (method_type_node, method_count);
+ methods_decl = build_decl (VAR_DECL, mangled_classname ("_MT_", type),
+ method_array_type);
+ DECL_INITIAL (methods_decl) = build (CONSTRUCTOR, method_array_type,
+ NULL_TREE, nreverse (methods));
+ TREE_STATIC (methods_decl) = 1;
+ DECL_ARTIFICIAL (methods_decl) = 1;
+ DECL_IGNORED_P (methods_decl) = 1;
+ rest_of_decl_compilation (methods_decl, (char*) 0, 1, 0);
+
+ if (flag_assume_compiled
+ && ! CLASS_ABSTRACT (type_decl) && ! CLASS_INTERFACE (type_decl))
+ {
+ tree dtable = get_dispatch_table (type, this_class_addr);
+ dtable_decl = build_dtable_decl (type);
+ DECL_INITIAL (dtable_decl) = dtable;
+ TREE_STATIC (dtable_decl) = 1;
+ DECL_ARTIFICIAL (dtable_decl) = 1;
+ DECL_IGNORED_P (dtable_decl) = 1;
+ TREE_PUBLIC (dtable_decl) = 1;
+ rest_of_decl_compilation (dtable_decl, (char*) 0, 1, 0);
+ }
+
+ super = CLASSTYPE_SUPER (type);
+ if (super == NULL_TREE)
+ super = null_pointer_node;
+ else if (flag_assume_compiled)
+ super = build_class_ref (super);
+ else
+ {
+ int super_index = alloc_class_constant (super);
+ super = build_int_2 (super_index, 0);
+ TREE_TYPE (super) == ptr_type_node;
+ }
+
+ /* Build and emit the array of implemented interfaces. */
+ if (type != object_type_node)
+ interface_len = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)) - 1;
+ if (interface_len > 0)
+ {
+ tree init = NULL_TREE;
+ int i;
+ tree interface_array_type, idecl;
+ interface_array_type
+ = build_prim_array_type (class_ptr_type, interface_len);
+ idecl = build_decl (VAR_DECL, mangled_classname ("_IF_", type),
+ interface_array_type);
+ for (i = interface_len; i > 0; i--)
+ {
+ tree child = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i);
+ tree iclass = BINFO_TYPE (child);
+ tree index;
+ if (flag_assume_compiled)
+ index = build_class_ref (iclass);
+ else
+ {
+ int int_index = alloc_class_constant (iclass);
+ index = build_int_2 (int_index, 0);
+ TREE_TYPE (index) == ptr_type_node;
+ }
+ init = tree_cons (NULL_TREE, index, init);
+ }
+ DECL_INITIAL (idecl) = build (CONSTRUCTOR, interface_array_type,
+ NULL_TREE, init);
+ TREE_STATIC (idecl) = 1;
+ DECL_ARTIFICIAL (idecl) = 1;
+ DECL_IGNORED_P (idecl) = 1;
+ interfaces = build1 (ADDR_EXPR, ptr_type_node, idecl);
+ rest_of_decl_compilation (idecl, (char*) 0, 1, 0);
+ }
+
+ constant_pool_constructor = build_constants_constructor ();
+
+ START_RECORD_CONSTRUCTOR (temp, object_type_node);
+#if 0
+ PUSH_FIELD_VALUE (temp, "dtable", NULL_TREE);
+#else
+ PUSH_FIELD_VALUE (temp, "dtable",
+ build1 (ADDR_EXPR, dtable_ptr_type, class_dtable_decl));
+#endif
+ PUSH_FIELD_VALUE (temp, "sync_info", null_pointer_node);
+ FINISH_RECORD_CONSTRUCTOR (temp);
+ START_RECORD_CONSTRUCTOR (cons, class_type_node);
+ PUSH_SUPER_VALUE (cons, temp);
+ PUSH_FIELD_VALUE (cons, "next", null_pointer_node);
+ PUSH_FIELD_VALUE (cons, "name",
+ build_utf8_ref (build_internal_class_name (type)));
+ PUSH_FIELD_VALUE (cons, "accflags",
+ build_int_2 (get_access_flags_from_decl (type_decl), 0));
+
+ PUSH_FIELD_VALUE (cons, "superclass", super);
+ PUSH_FIELD_VALUE (cons, "subclass_head", null_pointer_node);
+ PUSH_FIELD_VALUE (cons, "subclass_next", null_pointer_node);
+ PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor);
+ PUSH_FIELD_VALUE (cons, "methods",
+ build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
+ PUSH_FIELD_VALUE (cons, "nmethods", build_int_2 (method_count, 0));
+ PUSH_FIELD_VALUE (cons, "msize", TYPE_NVIRTUALS (type));
+ PUSH_FIELD_VALUE (cons, "fields",
+ fields_decl == NULL_TREE ? null_pointer_node
+ : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
+ PUSH_FIELD_VALUE (cons, "bfsize", size_in_bytes (type));
+ PUSH_FIELD_VALUE (cons, "nfields", build_int_2 (field_count, 0));
+ PUSH_FIELD_VALUE (cons, "nsfields", build_int_2 (static_field_count, 0));
+ /* For now, we let Kaffe fill in the dtable. */
+ PUSH_FIELD_VALUE (cons, "dtable",
+ dtable_decl == NULL_TREE ? null_pointer_node
+ : build1 (ADDR_EXPR, dtable_ptr_type, dtable_decl));
+ PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
+ PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
+ PUSH_FIELD_VALUE (cons, "interface_len", build_int_2 (interface_len, 0));
+ PUSH_FIELD_VALUE (cons, "state",
+ flag_assume_compiled ? integer_four_node
+ : integer_two_node);
+
+ method = lookup_java_method (type,
+ finalize_identifier_node, void_signature_node);
+ PUSH_FIELD_VALUE (cons, "final",
+ method == NULL ? integer_zero_node : integer_one_node);
+
+ FINISH_RECORD_CONSTRUCTOR (cons);
+
+ DECL_INITIAL (decl) = cons;
+ rest_of_decl_compilation (decl, (char*) 0, 1, 0);
+}
+
+/* Return 2 if CLASS is compiled by this compilation job;
+ return 1 if CLASS can otherwise be assumed to be compiled;
+ return 0 if we cannot assume that CLASS is compiled.
+ Returns 1 for primitive and 0 for array types. */
+int
+is_compiled_class (class)
+ tree class;
+{
+ if (TREE_CODE (class) == POINTER_TYPE)
+ class = TREE_TYPE (class);
+ if (TREE_CODE (class) != RECORD_TYPE) /* Primitive types are static. */
+ return 1;
+ if (TYPE_ARRAY_P (class))
+ return 0;
+ if (class == current_class)
+ return 2;
+ if ((TYPE_LANG_SPECIFIC (class) && TYPE_LANG_SPECIFIC (class)->jcf &&
+ TYPE_LANG_SPECIFIC (class)->jcf->seen_in_zip))
+ {
+ /* The class was seen in the current ZIP file and will be
+ available as a compiled class in the future but may not have
+ been loaded already. Load it if necessary. This prevent
+ build_class_ref () from crashing. This should take into
+ consideration class specified in a multiple class file
+ command line. FIXME if necessary. */
+
+ if (!CLASS_LOADED_P (class))
+ load_class (class, 1);
+ return 2;
+ }
+
+ if (flag_assume_compiled)
+ {
+ if (!CLASS_LOADED_P (class))
+ load_class (class, 1);
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Append the mangled name of TYPE onto OBSTACK. */
+
+void
+append_gpp_mangled_type (obstack, type)
+ struct obstack *obstack;
+ tree type;
+{
+ char buf[8];
+ int len;
+ char *ptr;
+ switch (TREE_CODE (type))
+ {
+ char code;
+ case BOOLEAN_TYPE: code = 'b'; goto primitive;
+ case CHAR_TYPE: code = 'w'; goto primitive;
+ case VOID_TYPE: code = 'v'; goto primitive;
+ case INTEGER_TYPE:
+ /* Get the original type instead of the arguments promoted type.
+ Avoid symbol name clashes. Should call a function to do that.
+ FIXME. */
+ if (type == promoted_short_type_node)
+ type = short_type_node;
+ if (type == promoted_byte_type_node)
+ type = byte_type_node;
+ switch (TYPE_PRECISION (type))
+ {
+ case 8: code = 'c'; goto primitive;
+ case 16: code = 's'; goto primitive;
+ case 32: code = 'i'; goto primitive;
+ case 64: code = 'x'; goto primitive;
+ default: goto bad_type;
+ }
+ primitive:
+ obstack_1grow (obstack, code);
+ break;
+ case REAL_TYPE:
+ switch (TYPE_PRECISION (type))
+ {
+ case 32: code = 'f'; goto primitive;
+ case 64: code = 'd'; goto primitive;
+ default: goto bad_type;
+ }
+ case POINTER_TYPE:
+ type = TREE_TYPE (type);
+ obstack_1grow (obstack, 'P');
+ case RECORD_TYPE:
+ if (TYPE_ARRAY_P (type))
+ {
+ obstack_grow (obstack, "t6JArray1Z", sizeof("t6JArray1Z")-1);
+ append_gpp_mangled_type (obstack, TYPE_ARRAY_ELEMENT (type));
+ }
+ else
+ {
+ char *class_name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
+ append_gpp_mangled_classtype (obstack, class_name);
+ }
+ break;
+ bad_type:
+ default:
+ fatal ("internal error - trying to mangle unknown type");
+ }
+}
+
+/* Build the mangled name of the `class' field. */
+
+static tree
+mangle_class_field (class)
+ tree class;
+{
+ tree name;
+ obstack_grow (&temporary_obstack, "_CL_", 4);
+ append_gpp_mangled_type (&temporary_obstack, class);
+ obstack_1grow (&temporary_obstack, '\0');
+ name = get_identifier (obstack_base (&temporary_obstack));
+ obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
+ return name;
+}
+
+/* Build the mangled (assembly-level) name of the static field FIELD. */
+
+tree
+mangle_static_field (field)
+ tree field;
+{
+ tree class = DECL_CONTEXT (field);
+ tree name = DECL_NAME (field);
+ int encoded_len;
+#if ! defined (NO_DOLLAR_IN_LABEL) || ! defined (NO_DOT_IN_LABEL)
+ obstack_1grow (&temporary_obstack, '_');
+#else
+ obstack_grow (&temporary_obstack, "__static_", 9);
+#endif
+ append_gpp_mangled_type (&temporary_obstack, class);
+ encoded_len = unicode_mangling_length (IDENTIFIER_POINTER (name),
+ IDENTIFIER_LENGTH (name));
+ if (encoded_len > 0)
+ {
+ obstack_1grow (&temporary_obstack, 'U');
+ }
+#ifndef NO_DOLLAR_IN_LABEL
+ obstack_1grow (&temporary_obstack, '$');
+#else /* NO_DOLLAR_IN_LABEL */
+#ifndef NO_DOT_IN_LABEL
+ obstack_1grow (&temporary_obstack, '.');
+#else /* NO_DOT_IN_LABEL */
+ obstack_1grow (&temporary_obstack, '_');
+#endif /* NO_DOT_IN_LABEL */
+#endif /* NO_DOLLAR_IN_LABEL */
+ if (encoded_len > 0)
+ {
+ emit_unicode_mangled_name (&temporary_obstack,
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_LENGTH (name));
+ }
+ else
+ {
+ obstack_grow (&temporary_obstack,
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_LENGTH (name));
+ }
+ obstack_1grow (&temporary_obstack, '\0');
+ name = get_identifier (obstack_base (&temporary_obstack));
+ obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
+ return name;
+}
+
+/* Build a VAR_DECL for the dispatch table (vtable) for class TYPE. */
+
+tree
+build_dtable_decl (type)
+ tree type;
+{
+ tree name;
+ obstack_grow (&temporary_obstack, "__vt_", 5);
+ append_gpp_mangled_type (&temporary_obstack, type);
+ obstack_1grow (&temporary_obstack, '\0');
+ name = get_identifier (obstack_base (&temporary_obstack));
+ obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
+ return build_decl (VAR_DECL, name, dtable_type);
+}
+
+/* Pre-pend the TYPE_FIELDS of THIS_CLASS with a dummy FIELD_DECL for the
+ fields inherited from SUPER_CLASS. */
+
+void
+push_super_field (this_class, super_class)
+ tree this_class, super_class;
+{
+ tree base_decl;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ base_decl = build_decl (FIELD_DECL, NULL_TREE, super_class);
+ pop_obstacks ();
+ DECL_IGNORED_P (base_decl) = 1;
+ TREE_CHAIN (base_decl) = TYPE_FIELDS (this_class);
+ TYPE_FIELDS (this_class) = base_decl;
+ DECL_SIZE (base_decl) = TYPE_SIZE (super_class);
+}
+
+void
+layout_class (this_class)
+ tree this_class;
+{
+ tree super_class = CLASSTYPE_SUPER (this_class);
+ tree handle_type = CLASS_TO_HANDLE_TYPE (this_class);
+ tree method_decl, field;
+ tree dtable_count;
+ int i;
+
+ if (super_class)
+ {
+ /* Class seen in source are now complete and can be layed out.
+ Once layed out, a class seen in the source has its
+ CLASS_LOADED_P flag set */
+ if (CLASS_FROM_SOURCE_P (super_class) && !CLASS_LOADED_P (super_class))
+ safe_layout_class (super_class);
+ if (! CLASS_LOADED_P (super_class))
+ load_class (super_class, 1);
+ if (TREE_CODE (TYPE_SIZE (super_class)) == ERROR_MARK)
+ {
+ TYPE_SIZE (this_class) = error_mark_node;
+ return;
+ }
+ dtable_count = TYPE_NVIRTUALS (super_class);
+
+ if (TYPE_SIZE (this_class) == NULL_TREE)
+ push_super_field (this_class, super_class);
+ }
+ else
+ {
+ dtable_count = integer_zero_node;
+ }
+
+ for (field = TYPE_FIELDS (this_class);
+ field != NULL_TREE; field = TREE_CHAIN (field))
+ {
+ if (FIELD_STATIC (field))
+ {
+ /* Set DECL_ASSEMBLER_NAME to something suitably mangled. */
+ DECL_ASSEMBLER_NAME (field) = mangle_static_field (field);
+ }
+ }
+
+ layout_type (this_class);
+
+ TYPE_METHODS (handle_type) = nreverse (TYPE_METHODS (handle_type));
+
+ for (method_decl = TYPE_METHODS (handle_type), i = 0;
+ method_decl; method_decl = TREE_CHAIN (method_decl), i++)
+ {
+ char *ptr;
+ char buf[8];
+ char *asm_name;
+ tree method_name = DECL_NAME (method_decl);
+#if 1
+ /* Remove this once we no longer need old (Kaffe / JDK 1.0) mangling. */
+ if (! flag_assume_compiled && METHOD_NATIVE (method_decl))
+ {
+ for (ptr = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
+ *ptr; )
+ {
+ int ch = *ptr++;
+ if (ch == '.')
+ ch = '_';
+ obstack_1grow (&temporary_obstack, (char) ch);
+ }
+ obstack_1grow (&temporary_obstack, (char) '_');
+ if (method_name == init_identifier_node)
+ obstack_grow (&temporary_obstack, "INIT", 4);
+ else
+ obstack_grow (&temporary_obstack,
+ IDENTIFIER_POINTER (method_name),
+ IDENTIFIER_LENGTH (method_name));
+ }
+ else
+#endif
+ {
+ int len; tree arg, arglist, t;
+ int method_name_needs_escapes = 0;
+ if (method_name != init_identifier_node)
+ {
+ int encoded_len
+ = unicode_mangling_length (IDENTIFIER_POINTER (method_name),
+ IDENTIFIER_LENGTH (method_name));
+ if (encoded_len > 0)
+ {
+ method_name_needs_escapes = 1;
+ emit_unicode_mangled_name (&temporary_obstack,
+ IDENTIFIER_POINTER (method_name),
+ IDENTIFIER_LENGTH (method_name));
+ }
+ else
+ {
+ obstack_grow (&temporary_obstack,
+ IDENTIFIER_POINTER (method_name),
+ IDENTIFIER_LENGTH (method_name));
+ }
+ }
+
+ obstack_grow (&temporary_obstack, "__", 2);
+ append_gpp_mangled_type (&temporary_obstack, this_class);
+ TREE_PUBLIC (method_decl) = 1;
+
+ t = TREE_TYPE (method_decl);
+ arglist = TYPE_ARG_TYPES (t);
+ if (TREE_CODE (t) == METHOD_TYPE)
+ arglist = TREE_CHAIN (arglist);
+ for (arg = arglist; arg != NULL_TREE; )
+ {
+ tree a = arglist;
+ tree argtype = TREE_VALUE (arg);
+ int tindex = 1;
+ if (TREE_CODE (argtype) == POINTER_TYPE)
+ {
+ /* This is O(N**2). Do we care? Cfr gcc/cp/method.c. */
+ while (a != arg && argtype != TREE_VALUE (a))
+ a = TREE_CHAIN (a), tindex++;
+ }
+ else
+ a = arg;
+ if (a != arg)
+ {
+ char buf[12];
+ int nrepeats = 0;
+ do
+ {
+ arg = TREE_CHAIN (arg); nrepeats++;
+ }
+ while (arg != NULL_TREE && argtype == TREE_VALUE (arg));
+ if (nrepeats > 1)
+ {
+ obstack_1grow (&temporary_obstack, 'N');
+ sprintf (buf, "%d", nrepeats);
+ obstack_grow (&temporary_obstack, buf, strlen (buf));
+ if (nrepeats > 9)
+ obstack_1grow (&temporary_obstack, '_');
+ }
+ else
+ obstack_1grow (&temporary_obstack, 'T');
+ sprintf (buf, "%d", tindex);
+ obstack_grow (&temporary_obstack, buf, strlen (buf));
+ if (tindex > 9)
+ obstack_1grow (&temporary_obstack, '_');
+ }
+ else
+ {
+ append_gpp_mangled_type (&temporary_obstack, argtype);
+ arg = TREE_CHAIN (arg);
+ }
+ }
+ if (method_name_needs_escapes)
+ obstack_1grow (&temporary_obstack, 'U');
+ }
+ obstack_1grow (&temporary_obstack, '\0');
+ asm_name = obstack_finish (&temporary_obstack);
+ DECL_ASSEMBLER_NAME (method_decl) = get_identifier (asm_name);
+ if (! METHOD_ABSTRACT (method_decl))
+ make_function_rtl (method_decl);
+ obstack_free (&temporary_obstack, asm_name);
+
+ if (method_name == init_identifier_node)
+ {
+ char *p = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (this_class)));
+ for (ptr = p; *ptr; )
+ {
+ if (*ptr++ == '.')
+ p = ptr;
+ }
+ DECL_NAME (method_decl) = get_identifier (p);
+ DECL_CONSTRUCTOR_P (method_decl) = 1;
+ }
+ else if (! METHOD_STATIC (method_decl))
+ {
+ tree method_sig = build_java_argument_signature (TREE_TYPE (method_decl));
+ tree super_method = lookup_argument_method (super_class, method_name,
+ method_sig);
+ if (super_method != NULL_TREE)
+ {
+ DECL_VINDEX (method_decl) = DECL_VINDEX (super_method);
+ if (DECL_VINDEX (method_decl) == NULL_TREE)
+ error_with_decl (method_decl,
+ "non-static method '%s' overrides static method");
+#if 0
+ else if (TREE_TYPE (TREE_TYPE (method_decl))
+ != TREE_TYPE (TREE_TYPE (super_method)))
+ {
+ error_with_decl (method_decl,
+ "Method `%s' redefined with different return type");
+ error_with_decl (super_method,
+ "Overridden decl is here");
+ }
+#endif
+ }
+ else if (! METHOD_FINAL (method_decl)
+ && ! CLASS_FINAL (TYPE_NAME (this_class)))
+ {
+ DECL_VINDEX (method_decl) = dtable_count;
+ dtable_count = build_int_2 (1+TREE_INT_CST_LOW (dtable_count), 0);
+ }
+ }
+ }
+ TYPE_NVIRTUALS (this_class) = dtable_count;
+
+#ifdef JAVA_USE_HANDLES
+ layout_type (handle_type);
+#endif
+}
+
+static tree registered_class = NULL_TREE;
+
+void
+register_class ()
+{
+ static tree end;
+ tree node = TREE_OPERAND (build_class_ref (current_class), 0);
+ tree current = copy_node (node);
+
+ XEXP (DECL_RTL (current), 0) = copy_rtx (XEXP (DECL_RTL(node), 0));
+ if (!registered_class)
+ registered_class = current;
+ else
+ TREE_CHAIN (end) = current;
+
+ end = current;
+}
+
+/* Generate a function that gets called at start-up (static contructor) time,
+ which calls registerClass for all the compiled classes. */
+
+void
+emit_register_class ()
+{
+ tree decl = getdecls ();
+
+ extern tree get_file_function_name PROTO((int));
+ tree init_name = get_file_function_name ('I');
+ tree init_type = build_function_type (void_type_node, NULL_TREE);
+ tree init_decl;
+ tree t;
+
+ start_sequence ();
+ init_decl = build_decl (FUNCTION_DECL, init_name, init_type);
+ DECL_ASSEMBLER_NAME (init_decl) = init_name;
+ TREE_STATIC (init_decl) = 1;
+ current_function_decl = init_decl;
+ DECL_RESULT (init_decl) = build_decl(RESULT_DECL, NULL_TREE, void_type_node);
+ /* DECL_EXTERNAL (init_decl) = 1;*/
+ TREE_PUBLIC (init_decl) = 1;
+ pushlevel (0);
+ make_function_rtl (init_decl);
+ init_function_start (init_decl, input_filename, 0);
+ expand_function_start (init_decl, 0);
+
+ for ( t = registered_class; t; t = TREE_CHAIN (t))
+ emit_library_call (registerClass_libfunc, 0, VOIDmode, 1,
+ XEXP (DECL_RTL (t), 0), Pmode);
+
+ expand_function_end (input_filename, 0, 0);
+ poplevel (1, 0, 1);
+ {
+ /* Force generation, even with -O3 or deeper. Gross hack. FIXME */
+ extern int flag_inline_functions;
+ int saved_flag = flag_inline_functions;
+ flag_inline_functions = 0;
+ rest_of_compilation (init_decl);
+ flag_inline_functions = saved_flag;
+ }
+ current_function_decl = NULL_TREE;
+ assemble_constructor (IDENTIFIER_POINTER (init_name));
+}
+
+void
+init_class_processing ()
+{
+ registerClass_libfunc = gen_rtx (SYMBOL_REF, Pmode, "registerClass");
+}
--- /dev/null
+# Top level configure fragment for the GNU compiler for the Java(TM)
+# language.
+# Copyright (C) 1994, 1995 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, 59 Temple Place - Suite 330,
+#Boston, MA 02111-1307, USA.
+
+#Java and all Java-based marks are trademarks or registered trademarks
+#of Sun Microsystems, Inc. in the United States and other countries.
+#The Free Software Foundation is independent of Sun Microsystems, Inc.
+
+# Configure looks for the existence of this file to auto-config each language.
+# We define several parameters used by configure:
+#
+# language - name of language as it would appear in $(LANGUAGES)
+# compilers - value to add to $(COMPILERS)
+# stagestuff - files to add to $(STAGESTUFF)
+# diff_excludes - files to ignore when building diffs between two versions.
+
+language="java"
+
+compilers="jc1\$(exeext) jvgenmain\$(exeext)"
+
+stagestuff="jc1\$(exeext) gcj\$(exeext) jvgenmain\$(exeext) gcjh\$(exeext)"
+
+outputs=java/Makefile
--- /dev/null
+/* Handle the constant pool of the Java(TM) Virtual Machine.
+ Copyright (C) 1997 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+#include "config.h"
+#include "tree.h"
+#include "java-tree.h"
+#include "jcf.h"
+#include "system.h"
+
+extern struct obstack permanent_obstack;
+
+/* Set the INDEX'th constant in CPOOL to have the given TAG and VALUE. */
+
+void
+set_constant_entry (cpool, index, tag, value)
+ CPool *cpool;
+ int index;
+ int tag;
+ jword value;
+{
+ if (cpool->data == NULL)
+ {
+ cpool->capacity = 100;
+ cpool->tags = (uint8*) xmalloc (sizeof(uint8) * cpool->capacity);
+ cpool->data = (jword*) xmalloc (sizeof(jword) * cpool->capacity);
+ cpool->count = 1;
+ }
+ if (index >= cpool->capacity)
+ {
+ cpool->capacity *= 2;
+ if (index >= cpool->capacity)
+ cpool->capacity = index + 10;
+ cpool->tags = (uint8*) xrealloc (cpool->tags,
+ sizeof(uint8) * cpool->capacity);
+ cpool->data = (jword*) xrealloc (cpool->data,
+ sizeof(jword) * cpool->capacity);
+ }
+ if (index >= cpool->count)
+ cpool->count = index + 1;
+ cpool->tags[index] = tag;
+ cpool->data[index] = value;
+}
+
+/* Find (or create) a constant pool entry matching TAG and VALUE. */
+
+int
+find_constant1 (cpool, tag, value)
+ CPool *cpool;
+ int tag;
+ jword value;
+{
+ int i;
+ for (i = cpool->count; --i > 0; )
+ {
+ if (cpool->tags[i] == tag && cpool->data[i] == value)
+ return i;
+ }
+ i = cpool->count == 0 ? 1 : cpool->count;
+ set_constant_entry (cpool, i, tag, value);
+ return i;
+}
+
+/* Find a double-word constant pool entry matching TAG and WORD1/WORD2. */
+
+int
+find_constant2 (cpool, tag, word1, word2)
+ CPool *cpool;
+ int tag;
+ jword word1, word2;
+{
+ int i;
+ for (i = cpool->count - 1; --i > 0; )
+ {
+ if (cpool->tags[i] == tag
+ && cpool->data[i] == word1
+ && cpool->data[i+1] == word2)
+ return i;
+ }
+ i = cpool->count == 0 ? 1 : cpool->count;
+ set_constant_entry (cpool, i, tag, word1);
+ set_constant_entry (cpool, i+1, 0, word2);
+ return i;
+}
+
+int
+find_utf8_constant (cpool, name)
+ CPool *cpool;
+ tree name;
+{
+ if (name == NULL_TREE)
+ return 0;
+ return find_constant1 (cpool, CONSTANT_Utf8, (jword) name);
+}
+
+int
+find_class_or_string_constant (cpool, tag, name)
+ CPool *cpool;
+ int tag;
+ tree name;
+{
+ int j = find_utf8_constant (cpool, name);
+ int i;
+ for (i = cpool->count; --i > 0; )
+ {
+ if (cpool->tags[i] == tag && cpool->data[i] == j)
+ return i;
+ }
+ i = cpool->count;
+ set_constant_entry (cpool, i, tag, (jword) j);
+ return i;
+}
+
+int
+find_class_constant (cpool, type)
+ CPool *cpool;
+ tree type;
+{
+ return find_class_or_string_constant (cpool, CONSTANT_Class,
+ build_internal_class_name (type));
+}
+
+/* Find (or create) a CONSTANT_NameAndType matching NAME and TYPE.
+ Return its index in the constant pool CPOOL. */
+
+int
+find_name_and_type_constant (cpool, name, type)
+ CPool *cpool;
+ tree name;
+ tree type;
+{
+ int name_index = find_utf8_constant (cpool, name);
+ int type_index = find_utf8_constant (cpool, build_java_signature (type));
+ return find_constant1 (cpool, CONSTANT_NameAndType,
+ (name_index << 16) | type_index);
+}
+
+/* Find (or create) a CONSTANT_Fieldref for DECL (a FIELD_DECL or VAR_DECL).
+ Return its index in the constant pool CPOOL. */
+
+int
+find_fieldref_index (cpool, decl)
+ CPool *cpool;
+ tree decl;
+{
+ int class_index = find_class_constant (cpool, DECL_CONTEXT (decl));
+ int name_type_index
+ = find_name_and_type_constant (cpool, DECL_NAME (decl), TREE_TYPE (decl));
+ return find_constant1 (cpool, CONSTANT_Fieldref,
+ (class_index << 16) | name_type_index);
+}
+
+/* Find (or create) a CONSTANT_Methodref for DECL (a FUNCTION_DECL).
+ Return its index in the constant pool CPOOL. */
+
+int
+find_methodref_index (cpool, decl)
+ CPool *cpool;
+ tree decl;
+{
+ int class_index = find_class_constant (cpool, DECL_CONTEXT (decl));
+ tree name = DECL_CONSTRUCTOR_P (decl) ? init_identifier_node
+ : DECL_NAME (decl);
+ int name_type_index
+ = find_name_and_type_constant (cpool, name, TREE_TYPE (decl));
+ /* Methodref or INterfacemethodRef - FIXME */
+ return find_constant1 (cpool, CONSTANT_Methodref,
+ (class_index << 16) | name_type_index);
+}
+
+#define PUT1(X) (*ptr++ = (X))
+#define PUT2(X) (PUT1((X) >> 8), PUT1(X))
+#define PUT4(X) (PUT2((X) >> 16), PUT2(X))
+#define PUTN(P, N) (bcopy(P, ptr, N), ptr += (N))
+
+/* Give the number of bytes needed in a .class file for the CPOOL
+ constant pool. Includes the 2-byte constant_pool_count. */
+
+int
+count_constant_pool_bytes (cpool)
+ CPool *cpool;
+{
+ int size = 2;
+ int i = 1;
+ jword *datap = &cpool->data[1];;
+ for ( ; i < cpool->count; i++, datap++)
+ {
+ size++;
+ switch (cpool->tags[i])
+ {
+ case CONSTANT_NameAndType:
+ case CONSTANT_Fieldref:
+ case CONSTANT_Methodref:
+ case CONSTANT_InterfaceMethodref:
+ case CONSTANT_Float:
+ case CONSTANT_Integer:
+ size += 4;
+ break;
+ case CONSTANT_Class:
+ case CONSTANT_String:
+ size += 2;
+ break;
+ case CONSTANT_Long:
+ case CONSTANT_Double:
+ size += 4;
+ break;
+ case CONSTANT_Utf8:
+ {
+ tree t = (tree) *datap;
+ int len = IDENTIFIER_LENGTH (t);
+ size += len + 2;
+ }
+ break;
+ }
+ }
+ return size;
+}
+
+/* Write the constant pool CPOOL into BUFFER.
+ The length of BUFFER is LENGTH, which must match the needed length. */
+
+void
+write_constant_pool (cpool, buffer, length)
+ CPool *cpool;
+ unsigned char* buffer;
+ int length;
+{
+ unsigned char* ptr = buffer;
+ int i = 1;
+ jword *datap = &cpool->data[1];
+ PUT2 (cpool->count);
+ for ( ; i < cpool->count; i++, datap++)
+ {
+ int tag = cpool->tags[i];
+ PUT1 (tag);
+ switch (tag)
+ {
+ case CONSTANT_NameAndType:
+ case CONSTANT_Fieldref:
+ case CONSTANT_Methodref:
+ case CONSTANT_InterfaceMethodref:
+ case CONSTANT_Float:
+ case CONSTANT_Integer:
+ PUT4 (*datap);
+ break;
+ case CONSTANT_Class:
+ case CONSTANT_String:
+ PUT2 (*datap);
+ break;
+ break;
+ case CONSTANT_Long:
+ case CONSTANT_Double:
+ PUT4(*datap);
+ i++;
+ datap++;
+ PUT4 (*datap);
+ break;
+ case CONSTANT_Utf8:
+ {
+ tree t = (tree) *datap;
+ int len = IDENTIFIER_LENGTH (t);
+ PUT2 (len);
+ PUTN (IDENTIFIER_POINTER (t), len);
+ }
+ break;
+ }
+ }
+ if (ptr != buffer + length)
+ fatal("internal error - incorrect constant pool");
+}
+
+CPool *outgoing_cpool;
+
+/* If non-NULL, an ADDR_EXPR referencing a VAR_DECL containing
+ the constant data array for the current class. */
+tree current_constant_pool_data_ref;
+
+/* A Cache for build_int_2 (CONSTANT_XXX, 0). */
+static tree tag_nodes[13];
+
+tree
+get_tag_node (tag)
+ int tag;
+{
+ if (tag_nodes[tag] == NULL_TREE)
+ {
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ tag_nodes[tag] = build_int_2 (tag, 0);
+ pop_obstacks ();
+ }
+ return tag_nodes[tag];
+}
+
+/* Look for a constant pool entry that matches TAG and NAME.
+ Creates a new entry if not found.
+ TAG is one of CONSTANT_Utf8, CONSTANT_String or CONSTANT_Class.
+ NAME is an IDENTIFIER_NODE naming the Utf8 constant, string, or class.
+ Returns the index of the entry. */
+
+int
+alloc_name_constant (tag, name)
+ int tag;
+ tree name;
+{
+ return find_constant1 (outgoing_cpool, tag, (jword) name);
+}
+
+/* Build an identifier for the internal name of reference type TYPE. */
+
+tree
+build_internal_class_name (type)
+ tree type;
+{
+ tree name;
+ if (TYPE_ARRAY_P (type))
+ name = build_java_signature (type);
+ else
+ {
+ name = TYPE_NAME (type);
+ if (TREE_CODE (name) != IDENTIFIER_NODE)
+ name = DECL_NAME (name);
+ name = identifier_subst (name, "", '.', '/', "");
+ }
+ return name;
+}
+
+/* Look for a CONSTANT_Class entry for CLAS, creating a new one if needed. */
+
+int
+alloc_class_constant (clas)
+ tree clas;
+{
+
+ return alloc_name_constant (CONSTANT_Class,
+ build_internal_class_name (clas));
+}
+
+/* Return a reference to the data array of the current constant pool. */
+
+tree
+build_constant_data_ref ()
+{
+ if (current_constant_pool_data_ref == NULL_TREE)
+ {
+ tree decl;
+ tree decl_name = mangled_classname ("_CD_", current_class);
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ decl = build_decl (VAR_DECL, decl_name,
+ build_array_type (ptr_type_node,
+ one_elt_array_domain_type));
+ TREE_STATIC (decl) = 1;
+ make_decl_rtl (decl, NULL, 1);
+ pop_obstacks ();
+ current_constant_pool_data_ref
+ = build1 (ADDR_EXPR, ptr_type_node, decl);
+ }
+ return current_constant_pool_data_ref;
+}
+
+/* Get the pointer value at the INDEX'th element of the constant pool. */
+
+tree
+build_ref_from_constant_pool (index)
+ int index;
+{
+ tree t = build_constant_data_ref ();
+ index *= int_size_in_bytes (ptr_type_node);
+ t = fold (build (PLUS_EXPR, ptr_type_node,
+ t, build_int_2 (index, 0)));
+ return build1 (INDIRECT_REF, ptr_type_node, t);
+}
+
+/* Build an initializer for the constants field of the current constal pool.
+ Should only be called at top-level, since it may emit declarations. */
+
+tree
+build_constants_constructor ()
+{
+ tree tags_value, data_value;
+ tree cons;
+ tree tags_list = NULL_TREE;
+ tree data_list = NULL_TREE;
+ int i;
+ for (i = outgoing_cpool->count; --i > 0; )
+ {
+ tags_list
+ = tree_cons (NULL_TREE, get_tag_node (outgoing_cpool->tags[i]),
+ tags_list);
+ data_list
+ = tree_cons (NULL_TREE, build_utf8_ref ((tree)outgoing_cpool->data[i]),
+ data_list);
+ }
+ if (outgoing_cpool->count > 0)
+ {
+ tree index_type;
+ tree data_decl, tags_decl, tags_type;
+ tree max_index = build_int_2 (outgoing_cpool->count - 1, 0);
+ TREE_TYPE (max_index) = sizetype;
+ index_type = build_index_type (max_index);
+
+ /* Add dummy 0'th element of constant pool. */
+ tags_list = tree_cons (NULL_TREE, get_tag_node (0), tags_list);
+ data_list = tree_cons (NULL_TREE, null_pointer_node, data_list);
+
+ data_decl = TREE_OPERAND (build_constant_data_ref (), 0);
+ TREE_TYPE (data_decl) = build_array_type (ptr_type_node, index_type),
+ DECL_INITIAL (data_decl) = build (CONSTRUCTOR, TREE_TYPE (data_decl),
+ NULL_TREE, data_list);
+ DECL_SIZE (data_decl) = TYPE_SIZE (TREE_TYPE (data_decl));
+ rest_of_decl_compilation (data_decl, (char*) 0, 1, 0);
+ data_value = build_address_of (data_decl);
+
+ tags_type = build_array_type (unsigned_byte_type_node, index_type);
+ tags_decl = build_decl (VAR_DECL, mangled_classname ("_CT_",
+ current_class),
+ tags_type);
+ TREE_STATIC (tags_decl) = 1;
+ DECL_INITIAL (tags_decl) = build (CONSTRUCTOR, tags_type,
+ NULL_TREE, tags_list);
+ rest_of_decl_compilation (tags_decl, (char*) 0, 1, 0);
+ tags_value = build_address_of (tags_decl);
+ }
+ else
+ {
+ data_value = null_pointer_node;
+ tags_value = null_pointer_node;
+ }
+ START_RECORD_CONSTRUCTOR (cons, constants_type_node);
+ PUSH_FIELD_VALUE (cons, "size", build_int_2 (outgoing_cpool->count, 0));
+ PUSH_FIELD_VALUE (cons, "tags", tags_value);
+ PUSH_FIELD_VALUE (cons, "data", data_value);
+ FINISH_RECORD_CONSTRUCTOR (cons);
+ return cons;
+}
--- /dev/null
+/* Definition of conversion functions.
+ 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+/* Written by Jeffrey Hsu <hsu@cygnus.com> */
+
+extern tree convert_to_boolean PROTO ((tree, tree));
+extern tree convert_to_char PROTO ((tree, tree));
--- /dev/null
+/* Process declarations and variables for the GNU compiler for the
+ Java(TM) language.
+
+ Copyright (C) 1996, 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
+
+#include "config.h"
+#include "tree.h"
+#include "java-tree.h"
+#include "jcf.h"
+#include "system.h"
+
+/* The DECL_MAP is a mapping from (index, type) to a decl node.
+ If index < max_locals, it is the index of a local variable.
+ if index >= max_locals, then index-max_locals is a stack slot.
+ The DECL_MAP mapping is represented as a TREE_VEC whose elements
+ are a list of decls (VAR_DECL or PARM_DECL) chained by
+ DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
+ we search the chain for a decl with a matching TREE_TYPE. */
+
+tree decl_map;
+
+/* A list of local variables VAR_DECLs for this method that we have seen
+ debug information, but we have not reached their starting (byte) PC yet. */
+
+tree pending_local_decls = NULL_TREE;
+
+/* Push a local variable or stack slot into the decl_map,
+ and assign it an rtl. */
+
+tree
+push_jvm_slot (index, decl)
+ int index;
+ tree decl;
+{
+ struct rtx_def *rtl = NULL;
+ tree type = TREE_TYPE (decl);
+ tree tmp;
+
+ DECL_CONTEXT (decl) = current_function_decl;
+ layout_decl (decl, 0);
+
+ /* See if we have an appropriate rtl (i.e. same mode) at this index.
+ If so, we must use it. */
+ tmp = TREE_VEC_ELT (decl_map, index);
+ while (tmp != NULL_TREE)
+ {
+ if (TYPE_MODE (type) == TYPE_MODE (TREE_TYPE (tmp)))
+ rtl = DECL_RTL (tmp);
+ if (rtl != NULL)
+ break;
+ tmp = DECL_LOCAL_SLOT_CHAIN (tmp);
+ }
+ if (rtl != NULL)
+ DECL_RTL (decl) = rtl;
+ else
+ {
+ if (index >= DECL_MAX_LOCALS (current_function_decl))
+ DECL_REGISTER (decl) = 1;
+ expand_decl (decl);
+ }
+
+ /* Now link the decl into the decl_map. */
+ if (DECL_LANG_SPECIFIC (decl) == NULL)
+ {
+ DECL_LANG_SPECIFIC (decl)
+ = (struct lang_decl *) permalloc (sizeof (struct lang_decl_var));
+ DECL_LOCAL_START_PC (decl) = 0;
+ DECL_LOCAL_END_PC (decl) = DECL_CODE_LENGTH (current_function_decl);
+ DECL_LOCAL_SLOT_NUMBER (decl) = index;
+ }
+ DECL_LOCAL_SLOT_CHAIN (decl) = TREE_VEC_ELT (decl_map, index);
+ TREE_VEC_ELT (decl_map, index) = decl;
+ return decl;
+}
+
+/* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
+ that is valid at PC (or -1 if any pc).
+ If there is no existing matching decl, allocate one.
+ If we find a decl with matching modes but different types,
+ we re-use the rtl, but create a new decl. */
+
+tree
+find_local_variable (index, type, pc)
+ int index;
+ tree type;
+ int pc;
+{
+ struct rtx_def *rtl = NULL;
+ tree decl = TREE_VEC_ELT (decl_map, index);
+ tree best = NULL_TREE;
+ while (decl != NULL_TREE)
+ {
+ int in_range;
+ in_range = pc < 0
+ || (pc >= DECL_LOCAL_START_PC (decl)
+ && pc < DECL_LOCAL_END_PC (decl));
+
+ if ((TREE_TYPE (decl) == type
+ || (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
+ && type == ptr_type_node))
+ && in_range)
+ {
+ if (best == NULL_TREE
+ || (TREE_TYPE (decl) == type && TREE_TYPE (best) != type)
+ || DECL_LOCAL_START_PC (decl) > DECL_LOCAL_START_PC (best)
+ || DECL_LOCAL_END_PC (decl) < DECL_LOCAL_START_PC (decl))
+ best = decl;
+ }
+ decl = DECL_LOCAL_SLOT_CHAIN (decl);
+ }
+ if (best != NULL_TREE)
+ return best;
+ return push_jvm_slot (index, build_decl (VAR_DECL, NULL_TREE, type));
+}
+
+
+/* Same as find_local_index, except that INDEX is a stack index. */
+
+tree
+find_stack_slot (index, type)
+ int index;
+ tree type;
+{
+ return find_local_variable (index + DECL_MAX_LOCALS (current_function_decl),
+ type, -1);
+}
+
+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;
+
+ /* 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;
+
+ /* 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;
+
+ /* 1 means make a BLOCK for this level regardless of all else.
+ 2 for temporary binding contours created by the compiler. */
+ char keep;
+
+ /* Nonzero means make a BLOCK if this level has any subblocks. */
+ char keep_if_subblocks;
+
+ /* Nonzero if this level can safely have additional
+ cleanup-needing variables added to it. */
+ char more_cleanups_ok;
+ char have_cleanups;
+
+ /* The bytecode PC that marks the end of this level. */
+ int end_pc;
+ };
+
+#define NULL_BINDING_LEVEL (struct binding_level *) NULL
+
+/* The binding level currently in effect. */
+
+static struct 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
+ = {NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
+ NULL_BINDING_LEVEL, 0, 0, 0, 0, 1000000000};
+
+#if 0
+/* 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;
+#endif
+
+int flag_traditional;
+
+/* Nonzero means unconditionally make a BLOCK for the next level pushed. */
+
+static int keep_next_level_flag;
+
+/* Nonzero means make a BLOCK for the next level pushed
+ if it has subblocks. */
+
+static int keep_next_if_subblocks;
+
+/* The FUNCTION_DECL for the function currently being compiled,
+ or 0 if between functions. */
+tree current_function_decl;
+
+/* The type node for the ordinary character type. */
+tree char_type_node;
+
+tree object_type_node;
+tree object_ptr_type_node;
+tree string_type_node;
+tree throwable_type_node;
+
+tree boolean_type_node;
+
+tree float_type_node;
+tree double_type_node;
+
+/* a VOID_TYPE node. */
+
+tree void_type_node;
+tree ptr_type_node;
+tree return_address_type_node;
+
+tree integer_type_node;
+
+tree byte_type_node;
+tree short_type_node;
+tree int_type_node;
+tree long_type_node;
+
+tree promoted_byte_type_node;
+tree promoted_short_type_node;
+tree promoted_char_type_node;
+tree promoted_boolean_type_node;
+
+tree unsigned_byte_type_node;
+tree unsigned_short_type_node;
+tree unsigned_int_type_node;
+tree unsigned_long_type_node;
+
+/* The type for struct methodtable. */
+tree methodtable_type;
+tree methodtable_ptr_type;
+
+tree utf8const_type;
+tree utf8const_ptr_type;
+tree class_type_node;
+tree class_ptr_type;
+tree field_type_node;
+tree field_ptr_type_node;
+tree field_info_union_node;
+tree jexception_type;
+tree jexception_ptr_type;
+tree lineNumberEntry_type;
+tree lineNumbers_type;
+tree constants_type_node;
+tree dtable_type;
+tree dtable_ptr_type;
+tree method_type_node;
+tree method_ptr_type_node;
+tree nativecode_ptr_array_type_node;
+tree one_elt_array_domain_type;
+tree access_flags_type_node;
+tree class_dtable_decl;
+
+/* 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;
+
+/* 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;
+
+/* Nodes for boolean constants TRUE and FALSE. */
+tree boolean_true_node, boolean_false_node;
+
+tree TYPE_identifier_node;
+tree init_identifier_node;
+tree clinit_identifier_node;
+tree finalize_identifier_node;
+tree void_signature_node;
+tree length_identifier_node;
+tree this_identifier_node;
+tree super_identifier_node;
+
+/* References to internal libjava functions we use. */
+tree alloc_object_node;
+tree soft_instanceof_node;
+tree soft_checkcast_node;
+tree soft_initclass_node;
+tree soft_newarray_node;
+tree soft_anewarray_node;
+tree soft_multianewarray_node;
+tree soft_badarrayindex_node;
+tree throw_node;
+tree soft_checkarraystore_node;
+tree soft_monitorenter_node;
+tree soft_monitorexit_node;
+tree soft_lookupinterfacemethod_node;
+tree soft_fmod_node;
+
+/* Build (and pushdecl) a "promoted type" for all standard
+ types shorter than int. */
+
+static tree
+push_promoted_type (name, actual_type)
+ char *name;
+ tree actual_type;
+{
+ tree type = make_node (TREE_CODE (actual_type));
+#if 1
+ tree in_min = TYPE_MIN_VALUE (int_type_node);
+ tree in_max = TYPE_MAX_VALUE (int_type_node);
+#else
+ tree in_min = TYPE_MIN_VALUE (actual_type);
+ tree in_max = TYPE_MAX_VALUE (actual_type);
+#endif
+ TYPE_MIN_VALUE (type) = build_int_2 (TREE_INT_CST_LOW (in_min),
+ TREE_INT_CST_HIGH (in_min));
+ TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
+ TYPE_MAX_VALUE (type) = build_int_2 (TREE_INT_CST_LOW (in_max),
+ TREE_INT_CST_HIGH (in_max));
+ TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
+ TYPE_PRECISION (type) = TYPE_PRECISION (int_type_node);
+ layout_type (type);
+ pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
+ return type;
+}
+
+/* Nodes for integer constants. */
+tree integer_one_node, integer_two_node, integer_four_node;
+tree integer_negative_one_node;
+
+/* Return 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
+builtin_function (name, type, function_code, library_name)
+ char *name;
+ tree type;
+ enum built_in_function function_code;
+ char *library_name;
+{
+ tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
+ DECL_EXTERNAL (decl) = 1;
+ TREE_PUBLIC (decl) = 1;
+ if (library_name)
+ DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
+ make_decl_rtl (decl, NULL_PTR, 1);
+ pushdecl (decl);
+ if (function_code != NOT_BUILT_IN)
+ {
+ DECL_BUILT_IN (decl) = 1;
+ DECL_FUNCTION_CODE (decl) = function_code;
+ }
+ return decl;
+}
+
+void
+init_decl_processing ()
+{
+ tree field;
+ tree t;
+
+ current_function_decl = NULL;
+ current_binding_level = NULL_BINDING_LEVEL;
+ free_binding_level = NULL_BINDING_LEVEL;
+ pushlevel (0); /* make the binding_level structure for global names */
+ global_binding_level = current_binding_level;
+
+ error_mark_node = make_node (ERROR_MARK);
+ TREE_TYPE (error_mark_node) = error_mark_node;
+
+ /* Create sizetype first - needed for other types. */
+ sizetype = make_unsigned_type (POINTER_SIZE);
+ size_zero_node = build_int_2 (0, 0);
+ TREE_TYPE (size_zero_node) = sizetype;
+ size_one_node = build_int_2 (1, 0);
+ TREE_TYPE (size_one_node) = sizetype;
+
+ byte_type_node = make_signed_type (8);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("byte"), byte_type_node));
+ short_type_node = make_signed_type (16);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("short"), short_type_node));
+ int_type_node = make_signed_type (32);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("int"), int_type_node));
+ long_type_node = make_signed_type (64);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("long"), long_type_node));
+
+ unsigned_byte_type_node = make_unsigned_type (8);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned byte"),
+ unsigned_byte_type_node));
+ unsigned_short_type_node = make_unsigned_type (16);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned short"),
+ unsigned_short_type_node));
+ unsigned_int_type_node = make_unsigned_type (32);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
+ unsigned_int_type_node));
+ unsigned_long_type_node = make_unsigned_type (64);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned long"),
+ unsigned_long_type_node));
+
+ integer_type_node = int_type_node;
+
+ integer_zero_node = build_int_2 (0, 0);
+ integer_one_node = build_int_2 (1, 0);
+ integer_two_node = build_int_2 (2, 0);
+ integer_four_node = build_int_2 (4, 0);
+ integer_negative_one_node = build_int_2 (-1, 0);
+
+ void_type_node = make_node (VOID_TYPE);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("void"), void_type_node));
+ layout_type (void_type_node); /* Uses size_zero_node */
+ ptr_type_node = build_pointer_type (void_type_node);
+ t = make_node (VOID_TYPE);
+ layout_type (t); /* Uses size_zero_node */
+ return_address_type_node = build_pointer_type (t);
+
+ null_pointer_node = build_int_2 (0, 0);
+ TREE_TYPE (null_pointer_node) = ptr_type_node;
+
+#if 0
+ /* 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__. */
+ short_array_type_node = build_prim_array_type (short_type_node, 200);
+#endif
+ char_type_node = make_node (CHAR_TYPE);
+ TYPE_PRECISION (char_type_node) = 16;
+ fixup_unsigned_type (char_type_node);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("char"), char_type_node));
+
+ boolean_type_node = make_node (BOOLEAN_TYPE);
+ TYPE_PRECISION (boolean_type_node) = 1;
+ fixup_unsigned_type (boolean_type_node);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("boolean"),
+ boolean_type_node));
+ boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
+ boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
+
+ promoted_byte_type_node
+ = push_promoted_type ("promoted_byte", byte_type_node);
+ promoted_short_type_node
+ = push_promoted_type ("promoted_short", short_type_node);
+ promoted_char_type_node
+ = push_promoted_type ("promoted_char", char_type_node);
+ promoted_boolean_type_node
+ = push_promoted_type ("promoted_boolean", boolean_type_node);
+
+ float_type_node = make_node (REAL_TYPE);
+ TYPE_PRECISION (float_type_node) = 32;
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("float"),
+ float_type_node));
+ layout_type (float_type_node);
+
+ double_type_node = make_node (REAL_TYPE);
+ TYPE_PRECISION (double_type_node) = 64;
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("double"),
+ double_type_node));
+ layout_type (double_type_node);
+
+ object_type_node = lookup_class (get_identifier ("java.lang.Object"));
+ object_ptr_type_node = promote_type (object_type_node);
+ string_type_node = lookup_class (get_identifier ("java.lang.String"));
+ class_type_node = lookup_class (get_identifier ("java.lang.Class"));
+ throwable_type_node = lookup_class (get_identifier ("java.lang.Throwable"));
+
+ methodtable_type = make_node (RECORD_TYPE);
+ layout_type (methodtable_type);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("methodtable"),
+ methodtable_type));
+ methodtable_ptr_type = build_pointer_type (methodtable_type);
+
+ TYPE_identifier_node = get_identifier ("TYPE");
+ init_identifier_node = get_identifier ("<init>");
+ clinit_identifier_node = get_identifier ("<clinit>");
+ finalize_identifier_node = get_identifier ("finalize");
+ void_signature_node = get_identifier ("()V");
+ length_identifier_node = get_identifier ("length");
+ this_identifier_node = get_identifier ("this");
+ super_identifier_node = get_identifier ("super");
+
+ /* for lack of a better place to put this stub call */
+ init_expr_processing();
+
+ utf8const_type = make_node (RECORD_TYPE);
+ PUSH_FIELD (utf8const_type, field, "hash", unsigned_short_type_node);
+ PUSH_FIELD (utf8const_type, field, "length", unsigned_short_type_node);
+ FINISH_RECORD (utf8const_type);
+ utf8const_ptr_type = build_pointer_type (utf8const_type);
+
+ constants_type_node = make_node (RECORD_TYPE);
+ PUSH_FIELD (constants_type_node, field, "size", unsigned_int_type_node);
+ PUSH_FIELD (constants_type_node, field, "tags", ptr_type_node);
+ PUSH_FIELD (constants_type_node, field, "data", ptr_type_node);
+ FINISH_RECORD (constants_type_node);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("constants"),
+ constants_type_node));
+
+ access_flags_type_node = unsigned_short_type_node;
+
+ dtable_type = make_node (RECORD_TYPE);
+ dtable_ptr_type = build_pointer_type (dtable_type);
+
+ PUSH_FIELD (object_type_node, field, "dtable", dtable_ptr_type);
+ PUSH_FIELD (object_type_node, field, "sync_info", ptr_type_node);
+ for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
+ FIELD_PRIVATE (t) = 1;
+ FINISH_RECORD (object_type_node);
+
+ class_dtable_decl = build_dtable_decl (class_type_node);
+ TREE_STATIC (class_dtable_decl) = 1;
+ DECL_ARTIFICIAL (class_dtable_decl) = 1;
+ DECL_IGNORED_P (class_dtable_decl) = 1;
+ rest_of_decl_compilation (class_dtable_decl, (char*) 0, 1, 0);
+
+ field_type_node = make_node (RECORD_TYPE);
+ field_ptr_type_node = build_pointer_type (field_type_node);
+ method_type_node = make_node (RECORD_TYPE);
+ method_ptr_type_node = build_pointer_type (method_type_node);
+
+ set_super_info (0, class_type_node, object_type_node, 0);
+ set_super_info (0, string_type_node, object_type_node, 0);
+ class_ptr_type = build_pointer_type (class_type_node);
+
+ PUSH_FIELD (class_type_node, field, "next", class_ptr_type);
+ PUSH_FIELD (class_type_node, field, "name", utf8const_ptr_type);
+ PUSH_FIELD (class_type_node, field, "accflags", access_flags_type_node);
+ PUSH_FIELD (class_type_node, field, "superclass", class_ptr_type);
+ PUSH_FIELD (class_type_node, field, "subclass_head", class_ptr_type);
+ PUSH_FIELD (class_type_node, field, "subclass_next", class_ptr_type);
+ PUSH_FIELD (class_type_node, field, "constants", constants_type_node);
+ PUSH_FIELD (class_type_node, field, "methods", method_ptr_type_node);
+ PUSH_FIELD (class_type_node, field, "nmethods", short_type_node);
+ PUSH_FIELD (class_type_node, field, "msize", short_type_node);
+ PUSH_FIELD (class_type_node, field, "fields", field_ptr_type_node);
+ PUSH_FIELD (class_type_node, field, "bfsize", int_type_node);
+ PUSH_FIELD (class_type_node, field, "nfields", short_type_node);
+ PUSH_FIELD (class_type_node, field, "nsfields", short_type_node);
+ PUSH_FIELD (class_type_node, field, "dtable", dtable_ptr_type);
+ PUSH_FIELD (class_type_node, field, "interfaces",
+ build_pointer_type (class_ptr_type));
+ PUSH_FIELD (class_type_node, field, "loader", ptr_type_node);
+ PUSH_FIELD (class_type_node, field, "interface_len", short_type_node);
+ PUSH_FIELD (class_type_node, field, "state", byte_type_node);
+ PUSH_FIELD (class_type_node, field, "final", byte_type_node);
+ for (t = TYPE_FIELDS (class_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
+ FIELD_PRIVATE (t) = 1;
+ push_super_field (class_type_node, object_type_node);
+ FINISH_RECORD (class_type_node);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("Class"), class_type_node));
+
+ field_info_union_node = make_node (UNION_TYPE);
+ PUSH_FIELD (field_info_union_node, field, "boffset", int_type_node);
+ PUSH_FIELD (field_info_union_node, field, "addr", ptr_type_node);
+#if 0
+ PUSH_FIELD (field_info_union_node, field, "idx", unsigned_short_type_node);
+#endif
+ layout_type (field_info_union_node);
+
+ PUSH_FIELD (field_type_node, field, "name", utf8const_ptr_type);
+ PUSH_FIELD (field_type_node, field, "type", class_ptr_type);
+ PUSH_FIELD (field_type_node, field, "accflags", access_flags_type_node);
+ PUSH_FIELD (field_type_node, field, "bsize", unsigned_short_type_node);
+ PUSH_FIELD (field_type_node, field, "info", field_info_union_node);
+ FINISH_RECORD (field_type_node);
+ CLASS_LOADED_P (field_type_node) = 1;
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("Field"), field_type_node));
+
+ one_elt_array_domain_type = build_index_type (integer_one_node);
+ nativecode_ptr_array_type_node
+ = build_array_type (nativecode_ptr_type_node, one_elt_array_domain_type);
+
+ PUSH_FIELD (dtable_type, field, "class", class_ptr_type);
+ PUSH_FIELD (dtable_type, field, "methods", nativecode_ptr_array_type_node);
+ FINISH_RECORD (dtable_type);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("dispatchTable"), dtable_type));
+
+#define jint_type int_type_node
+#define jint_ptr_type ptr_type_node
+
+ jexception_type = make_node (RECORD_TYPE);
+ PUSH_FIELD (jexception_type, field, "start_pc", ptr_type_node);
+ PUSH_FIELD (jexception_type, field, "end_pc", ptr_type_node);
+ PUSH_FIELD (jexception_type, field, "handler_pc", ptr_type_node);
+ PUSH_FIELD (jexception_type, field, "catch_type", class_ptr_type);
+ FINISH_RECORD (jexception_type);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("jexception"), field_type_node));
+ jexception_ptr_type = build_pointer_type (jexception_type);
+
+ lineNumberEntry_type = make_node (RECORD_TYPE);
+ PUSH_FIELD (lineNumberEntry_type, field, "line_nr", unsigned_short_type_node);
+ PUSH_FIELD (lineNumberEntry_type, field, "start_pc", ptr_type_node);
+ FINISH_RECORD (lineNumberEntry_type);
+
+ lineNumbers_type = make_node (RECORD_TYPE);
+ PUSH_FIELD (lineNumbers_type, field, "length", unsigned_int_type_node);
+ FINISH_RECORD (lineNumbers_type);
+
+#define instn_ptr_type_node ptr_type_node /* XXX JH */
+
+#define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
+
+ PUSH_FIELD (method_type_node, field, "name", utf8const_ptr_type);
+ PUSH_FIELD (method_type_node, field, "signature", utf8const_ptr_type);
+ PUSH_FIELD (method_type_node, field, "accflags", access_flags_type_node);
+ PUSH_FIELD (method_type_node, field, "ncode", nativecode_ptr_type_node);
+ FINISH_RECORD (method_type_node);
+ CLASS_LOADED_P (method_type_node) = 1;
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("Method"), method_type_node));
+
+ t = tree_cons (NULL_TREE, class_ptr_type,
+ build_tree_list (NULL_TREE, int_type_node));
+ alloc_object_node = builtin_function ("_Jv_AllocObject",
+ build_function_type (ptr_type_node, t),
+ NOT_BUILT_IN, NULL_PTR);
+ soft_initclass_node = builtin_function ("_Jv_InitClass",
+ build_function_type (void_type_node,
+ t),
+ NOT_BUILT_IN, NULL_PTR);
+ t = build_tree_list (NULL_TREE, void_type_node);
+ throw_node = builtin_function ("_Jv_Throw",
+ build_function_type (ptr_type_node, t),
+ NOT_BUILT_IN, NULL_PTR);
+ soft_monitorenter_node
+ = builtin_function ("_Jv_MonitorEnter",
+ build_function_type (int_type_node, t),
+ NOT_BUILT_IN, NULL_PTR);
+ soft_monitorexit_node
+ = builtin_function ("_Jv_MonitorExit",
+ build_function_type (int_type_node, t),
+ NOT_BUILT_IN, NULL_PTR);
+
+ t = tree_cons (NULL_TREE, int_type_node,
+ build_tree_list (NULL_TREE, int_type_node));
+ soft_newarray_node
+ = builtin_function ("_Jv_NewArray",
+ build_function_type(ptr_type_node, t),
+ NOT_BUILT_IN, NULL_PTR );
+
+ t = tree_cons (NULL_TREE, int_type_node,
+ tree_cons (NULL_TREE, class_ptr_type,
+ build_tree_list (NULL_TREE, object_ptr_type_node)));
+ soft_anewarray_node
+ = builtin_function ("_Jv_NewObjectArray",
+ build_function_type (ptr_type_node, t),
+ NOT_BUILT_IN, NULL_PTR );
+
+ t = tree_cons (NULL_TREE, ptr_type_node,
+ build_tree_list (NULL_TREE, int_type_node));
+ soft_multianewarray_node
+ = builtin_function ("_Jv_NewMultiArray",
+ build_function_type (ptr_type_node, t),
+ NOT_BUILT_IN, NULL_PTR );
+
+ t = build_function_type (void_type_node, NULL_TREE);
+ soft_badarrayindex_node
+ = builtin_function ("_Jv_ThrowBadArrayIndex", t, NOT_BUILT_IN, NULL_PTR );
+ TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1;
+ TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1;
+
+ t = tree_cons (NULL_TREE, class_ptr_type,
+ build_tree_list (NULL_TREE, object_ptr_type_node));
+ soft_checkcast_node
+ = builtin_function ("_Jv_CheckCast",
+ build_function_type (ptr_type_node, t),
+ NOT_BUILT_IN, NULL_PTR);
+ t = tree_cons (NULL_TREE, object_ptr_type_node,
+ build_tree_list (NULL_TREE, class_ptr_type));
+ soft_instanceof_node
+ = builtin_function ("_Jv_IsInstanceOf",
+ build_function_type (promoted_boolean_type_node, t),
+ NOT_BUILT_IN, NULL_PTR);
+ t = tree_cons (NULL_TREE, object_ptr_type_node,
+ build_tree_list (NULL_TREE, object_ptr_type_node));
+ soft_checkarraystore_node
+ = builtin_function ("_Jv_CheckArrayStore",
+ build_function_type (void_type_node, t),
+ NOT_BUILT_IN, NULL_PTR);
+ t = tree_cons (NULL_TREE, ptr_type_node,
+ tree_cons (NULL_TREE, ptr_type_node,
+ build_tree_list (NULL_TREE, ptr_type_node)));
+ soft_lookupinterfacemethod_node
+ = builtin_function ("_Jv_LookupInterfaceMethod",
+ build_function_type(ptr_type_node, t),
+ NOT_BUILT_IN, NULL_PTR);
+ t = tree_cons (NULL_TREE, double_type_node,
+ build_tree_list (NULL_TREE, double_type_node));
+ soft_fmod_node
+ = builtin_function ("__builtin_fmod",
+ build_function_type (double_type_node, t),
+ BUILT_IN_FMOD, "fmod");
+#if 0
+ t = tree_cons (NULL_TREE, float_type_node,
+ build_tree_list (NULL_TREE, float_type_node));
+ soft_fmodf_node
+ = builtin_function ("__builtin_fmodf",
+ build_function_type (float_type_node, t),
+ BUILT_IN_FMOD, "fmodf");
+#endif
+
+ init_class_processing ();
+}
+
+
+/* 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,
+ or return 0 if it is undefined. */
+
+tree
+lookup_name (name)
+ tree name;
+{
+ register tree val;
+ if (current_binding_level != global_binding_level
+ && IDENTIFIER_LOCAL_VALUE (name))
+ val = IDENTIFIER_LOCAL_VALUE (name);
+ else
+ val = IDENTIFIER_GLOBAL_VALUE (name);
+ return val;
+}
+
+/* Similar to `lookup_name' but look only at current binding level and
+ the previous one if its the parameter level. */
+
+tree
+lookup_name_current_level (name)
+ tree name;
+{
+ register tree t;
+
+ if (current_binding_level == global_binding_level)
+ return IDENTIFIER_GLOBAL_VALUE (name);
+
+ if (IDENTIFIER_LOCAL_VALUE (name) == 0)
+ return 0;
+
+ for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
+ if (DECL_NAME (t) == name)
+ break;
+
+ return t;
+}
+
+/* Use a binding level to record a labeled block declaration */
+
+void
+push_labeled_block (lb)
+ tree lb;
+{
+ register tree name = DECL_NAME (LABELED_BLOCK_LABEL (lb));
+ register struct binding_level *b = current_binding_level;
+ tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
+ if (oldlocal != 0)
+ b->shadowed = tree_cons (name, oldlocal, b->shadowed);
+ TREE_CHAIN (lb) = b->names;
+ b->names = lb;
+ IDENTIFIER_LOCAL_VALUE (name) = lb;
+}
+
+/* Pop the current binding level, reinstalling values for the previous
+ labeled block */
+
+void
+pop_labeled_block ()
+{
+ struct binding_level *b = current_binding_level;
+ tree label = b->names;
+ IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label))) =
+ NULL_TREE;
+ if (b->shadowed)
+ IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b->shadowed)) =
+ TREE_VALUE (b->shadowed);
+
+ /* Pop the current level, and free the structure for reuse. */
+ current_binding_level = current_binding_level->level_chain;
+ b->level_chain = free_binding_level;
+ free_binding_level = b;
+}
+
+/* Record a decl-node X as belonging to the current lexical scope.
+ Check for errors (such as an incompatible declaration for the same
+ name already seen in the same scope).
+
+ Returns either X or an old decl for the same name.
+ If an old decl is returned, it may have been smashed
+ to agree with what X says. */
+
+tree
+pushdecl (x)
+ tree x;
+{
+ register tree t;
+ register tree name = DECL_NAME (x);
+ register struct binding_level *b = current_binding_level;
+
+ DECL_CONTEXT (x) = current_function_decl;
+ if (name)
+ {
+ char *file;
+ int line;
+ int different_binding_level = 0;
+
+ t = lookup_name_current_level (name);
+ if (t != 0 && t == error_mark_node)
+ /* error_mark_node is 0 for a while during initialization! */
+ {
+ t = 0;
+ error_with_decl (x, "`%s' used prior to declaration");
+ }
+
+ if (t != 0)
+ {
+ file = DECL_SOURCE_FILE (t);
+ line = DECL_SOURCE_LINE (t);
+ }
+
+ /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
+ to point to the TYPE_DECL.
+ Since Java does not have typedefs, a type can only have
+ one (true) name, given by a class, interface, or builtin. */
+ if (TREE_CODE (x) == TYPE_DECL
+ && TYPE_NAME (TREE_TYPE (x)) == 0
+ && TREE_TYPE (x) != error_mark_node)
+ {
+ TYPE_NAME (TREE_TYPE (x)) = x;
+ TYPE_STUB_DECL (TREE_TYPE (x)) = x;
+ }
+
+ /* This name is new in its binding level.
+ Install the new declaration and return it. */
+ if (b == global_binding_level)
+ {
+ /* Install a global value. */
+
+ IDENTIFIER_GLOBAL_VALUE (name) = x;
+ }
+ else
+ {
+ /* Here to install a non-global value. */
+ tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
+ tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
+ IDENTIFIER_LOCAL_VALUE (name) = x;
+
+#if 0
+ /* Warn if shadowing an argument at the top level of the body. */
+ if (oldlocal != 0 && !DECL_EXTERNAL (x)
+ /* This warning doesn't apply to the parms of a nested fcn. */
+ && ! current_binding_level->parm_flag
+ /* Check that this is one level down from the parms. */
+ && current_binding_level->level_chain->parm_flag
+ /* Check that the decl being shadowed
+ comes from the parm level, one level up. */
+ && chain_member (oldlocal, current_binding_level->level_chain->names))
+ {
+ if (TREE_CODE (oldlocal) == PARM_DECL)
+ pedwarn ("declaration of `%s' shadows a parameter",
+ IDENTIFIER_POINTER (name));
+ else
+ pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
+ IDENTIFIER_POINTER (name));
+ }
+
+ /* Maybe warn if shadowing something else. */
+ else if (warn_shadow && !DECL_EXTERNAL (x)
+ /* No shadow warnings for internally generated vars. */
+ && DECL_SOURCE_LINE (x) != 0
+ /* No shadow warnings for vars made for inlining. */
+ && ! DECL_FROM_INLINE (x))
+ {
+ char *warnstring = 0;
+
+ if (TREE_CODE (x) == PARM_DECL
+ && current_binding_level->level_chain->parm_flag)
+ /* Don't warn about the parm names in function declarator
+ within a function declarator.
+ It would be nice to avoid warning in any function
+ declarator in a declaration, as opposed to a definition,
+ but there is no way to tell it's not a definition. */
+ ;
+ else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
+ warnstring = "declaration of `%s' shadows a parameter";
+ else if (oldlocal != 0)
+ warnstring = "declaration of `%s' shadows previous local";
+ else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
+ && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
+ warnstring = "declaration of `%s' shadows global declaration";
+
+ if (warnstring)
+ warning (warnstring, IDENTIFIER_POINTER (name));
+ }
+#endif
+
+ /* If storing a local value, there may already be one (inherited).
+ If so, record it for restoration when this binding level ends. */
+ if (oldlocal != 0)
+ b->shadowed = tree_cons (name, oldlocal, b->shadowed);
+ }
+ }
+
+ /* Put decls on list in reverse order.
+ We will reverse them later if necessary. */
+ TREE_CHAIN (x) = b->names;
+ b->names = x;
+
+ return x;
+}
+void
+pushdecl_force_head (x)
+ tree x;
+{
+ current_binding_level->names = x;
+}
+
+/* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
+
+tree
+pushdecl_top_level (x)
+ tree x;
+{
+ register tree t;
+ register struct binding_level *b = current_binding_level;
+
+ current_binding_level = global_binding_level;
+ t = pushdecl (x);
+ current_binding_level = b;
+ return t;
+}
+
+/* Nonzero if we are currently in the global binding level. */
+
+int
+global_bindings_p ()
+{
+ return current_binding_level == global_binding_level;
+}
+
+/* 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;
+}
+
+/* Create a new `struct binding_level'. */
+
+static
+struct binding_level *
+make_binding_level ()
+{
+ /* NOSTRICT */
+ return (struct binding_level *) xmalloc (sizeof (struct binding_level));
+}
+
+void
+pushlevel (unused)
+ int unused;
+{
+ register struct binding_level *newlevel = NULL_BINDING_LEVEL;
+
+#if 0
+ /* If this is the top level of a function,
+ just make sure that NAMED_LABELS is 0. */
+
+ if (current_binding_level == global_binding_level)
+ named_labels = 0;
+#endif
+
+ /* Reuse or create a struct for this binding level. */
+
+ if (free_binding_level)
+ {
+ newlevel = free_binding_level;
+ free_binding_level = free_binding_level->level_chain;
+ }
+ else
+ {
+ newlevel = make_binding_level ();
+ }
+
+ /* Add this level to the front of the chain (stack) of levels that
+ are active. */
+
+ *newlevel = clear_binding_level;
+ newlevel->level_chain = current_binding_level;
+ current_binding_level = newlevel;
+ newlevel->keep = keep_next_level_flag;
+ keep_next_level_flag = 0;
+ newlevel->keep_if_subblocks = keep_next_if_subblocks;
+ keep_next_if_subblocks = 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 is nonzero, this level had explicit declarations, so
+ and create a "block" (a BLOCK node) for the level
+ to record its declarations and subblocks for symbol table output.
+
+ If FUNCTIONBODY is nonzero, this level is the body of a function,
+ so create a block as if KEEP were set and also clear out all
+ label names.
+
+ If REVERSE is nonzero, reverse the order of decls before putting
+ them into the BLOCK. */
+
+tree
+poplevel (keep, reverse, functionbody)
+ int keep;
+ int reverse;
+ int functionbody;
+{
+ register tree link;
+ /* The chain of decls was accumulated in reverse order.
+ Put it into forward order, just for cleanliness. */
+ tree decls;
+ tree subblocks = current_binding_level->blocks;
+ tree block = 0;
+ tree decl;
+ int block_previously_created;
+
+ keep |= current_binding_level->keep;
+
+ /* 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) != 0
+ && 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.
+
+ DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
+ true, since then the decl goes through save_for_inline_copying. */
+ if (DECL_ABSTRACT_ORIGIN (decl) != 0
+ && DECL_ABSTRACT_ORIGIN (decl) != decl)
+ TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
+ else
+ {
+ push_function_context ();
+ output_inline_function (decl);
+ pop_function_context ();
+ }
+ }
+
+ /* If there were any declarations in that level,
+ or if this level is a function body,
+ create a BLOCK to record them for the life of this function. */
+
+ block = 0;
+ block_previously_created = (current_binding_level->this_block != 0);
+ if (block_previously_created)
+ block = current_binding_level->this_block;
+ else if (keep || functionbody
+ || (current_binding_level->keep_if_subblocks && subblocks != 0))
+ block = make_node (BLOCK);
+ if (block != 0)
+ {
+ BLOCK_VARS (block) = decls;
+ BLOCK_TYPE_TAGS (block) = NULL_TREE;
+ BLOCK_SUBBLOCKS (block) = subblocks;
+ remember_end_note (block);
+ }
+
+ /* In each subblock, record that this is its superior. */
+
+ 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))
+ {
+ tree name = DECL_NAME (link);
+ if (name != 0 && IDENTIFIER_LOCAL_VALUE (name) == link)
+ {
+ /* 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 (name) = 1;
+ if (TREE_ADDRESSABLE (link))
+ TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
+ }
+ IDENTIFIER_LOCAL_VALUE (name) = 0;
+ }
+ }
+
+ /* 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);
+
+ /* If the level being exited is the top level of a function,
+ check over all the labels, and clear out the current
+ (function local) meanings of their names. */
+
+ 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,
+ and add them to BLOCK_VARS. */
+
+#if 0
+ for (link = named_labels; link; link = TREE_CHAIN (link))
+ {
+ register tree label = TREE_VALUE (link);
+
+ if (DECL_INITIAL (label) == 0)
+ {
+ error_with_decl (label, "label `%s' used but not defined");
+ /* Avoid crashing later. */
+ define_label (input_filename, lineno,
+ DECL_NAME (label));
+ }
+ else if (warn_unused && !TREE_USED (label))
+ warning_with_decl (label, "label `%s' defined but not used");
+ IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
+
+ /* Put the labels into the "variables" of the
+ top-level block, so debugger can see them. */
+ TREE_CHAIN (label) = BLOCK_VARS (block);
+ BLOCK_VARS (block) = label;
+ }
+#endif
+ }
+
+ /* Pop the current level, and free the structure for reuse. */
+
+ {
+ register struct binding_level *level = current_binding_level;
+ current_binding_level = current_binding_level->level_chain;
+
+ level->level_chain = free_binding_level;
+ free_binding_level = level;
+ }
+
+ /* Dispose of the block that we just made inside some higher 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)
+ current_binding_level->blocks
+ = chainon (current_binding_level->blocks, subblocks);
+
+ /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
+ binding contour so that they point to the appropriate construct, i.e.
+ either to the current FUNCTION_DECL node, or else to the BLOCK node
+ we just constructed.
+
+ Note that for tagged types whose scope is just the formal parameter
+ list for some function type specification, we can't properly set
+ their TYPE_CONTEXTs here, because we don't have a pointer to the
+ appropriate FUNCTION_TYPE node readily available to us. For those
+ cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
+ in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
+ node which will represent the "scope" for these "parameter list local"
+ tagged types.
+ */
+
+ if (block)
+ TREE_USED (block) = 1;
+ return block;
+}
+
+void
+maybe_pushlevels (pc)
+ int pc;
+{
+ while (pending_local_decls != NULL_TREE &&
+ DECL_LOCAL_START_PC (pending_local_decls) <= pc)
+ {
+ tree *ptr = &pending_local_decls;
+ tree decl = *ptr;
+ int end_pc = DECL_LOCAL_END_PC (decl);
+
+ while (*ptr != NULL_TREE
+ && DECL_LOCAL_START_PC (*ptr) <= pc
+ && DECL_LOCAL_END_PC (*ptr) == end_pc)
+ ptr = &TREE_CHAIN (*ptr);
+ pending_local_decls = *ptr;
+ *ptr = NULL_TREE;
+
+ /* Force non-nested range to be nested in current range. */
+ if (end_pc > current_binding_level->end_pc)
+ end_pc = current_binding_level->end_pc;
+
+ pushlevel (1);
+ expand_start_bindings (0);
+ current_binding_level->end_pc = end_pc;
+
+ current_binding_level->names = decl;
+ for ( ; decl != NULL_TREE; decl = TREE_CHAIN (decl))
+ {
+ push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl), decl);
+ }
+ }
+}
+
+void
+maybe_poplevels (pc)
+ int pc;
+{
+ while (current_binding_level->end_pc <= pc)
+ {
+ expand_end_bindings (getdecls (), 1, 0);
+ poplevel (1, 0, 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;
+ abort ();
+ 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;
+}
+
+/* integrate_decl_tree calls this function. */
+
+void
+copy_lang_decl (node)
+ tree node;
+{
+ int lang_decl_size
+ = TREE_CODE (node) == VAR_DECL ? sizeof (struct lang_decl_var)
+ : sizeof (struct lang_decl);
+ struct lang_decl *x = (struct lang_decl *) oballoc (lang_decl_size);
+ bcopy (DECL_LANG_SPECIFIC (node), x, lang_decl_size);
+ DECL_LANG_SPECIFIC (node) = x;
+}
+
+/* If DECL has a cleanup, build and return that cleanup here.
+ This is a callback called by expand_expr. */
+
+tree
+maybe_build_cleanup (decl)
+ tree decl;
+{
+ /* There are no cleanups in Java (I think). */
+ return NULL_TREE;
+}
+
+void
+give_name_to_locals (jcf)
+ JCF *jcf;
+{
+ int i, n = DECL_LOCALVARIABLES_OFFSET (current_function_decl);
+ tree parm;
+ pending_local_decls = NULL_TREE;
+ if (n == 0)
+ return;
+ JCF_SEEK (jcf, n);
+ n = JCF_readu2 (jcf);
+ for (i = 0; i < n; i++)
+ {
+ int start_pc = JCF_readu2 (jcf);
+ int length = JCF_readu2 (jcf);
+ int name_index = JCF_readu2 (jcf);
+ int signature_index = JCF_readu2 (jcf);
+ int slot = JCF_readu2 (jcf);
+ tree name = get_name_constant (jcf, name_index);
+ tree type = promote_type (parse_signature (jcf, signature_index));
+ if (slot < DECL_ARG_SLOT_COUNT (current_function_decl)
+ && start_pc == 0
+ && length == DECL_CODE_LENGTH (current_function_decl))
+ {
+ tree decl = TREE_VEC_ELT (decl_map, slot);
+ DECL_NAME (decl) = name;
+ DECL_ASSEMBLER_NAME (decl) = name;
+ if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
+ warning ("bad type in parameter debug info");
+ }
+ else
+ {
+ tree *ptr;
+ int end_pc = start_pc + length;
+ tree decl = build_decl (VAR_DECL, name, type);
+ if (end_pc > DECL_CODE_LENGTH (current_function_decl))
+ {
+ warning_with_decl (decl,
+ "bad PC range for debug info for local `%s'");
+ end_pc = DECL_CODE_LENGTH (current_function_decl);
+ }
+ DECL_LANG_SPECIFIC (decl)
+ = (struct lang_decl *) permalloc (sizeof (struct lang_decl_var));
+ DECL_LOCAL_SLOT_NUMBER (decl) = slot;
+ DECL_LOCAL_START_PC (decl) = start_pc;
+ DECL_LOCAL_END_PC (decl) = end_pc;
+
+ /* Now insert the new decl in the proper place in
+ pending_local_decls. We are essentially doing an insertion sort,
+ which works fine, since the list input will normally already
+ be sorted. */
+ ptr = &pending_local_decls;
+ while (*ptr != NULL_TREE
+ && (DECL_LOCAL_START_PC (*ptr) > start_pc
+ || (DECL_LOCAL_START_PC (*ptr) == start_pc
+ && DECL_LOCAL_END_PC (*ptr) < end_pc)))
+ ptr = &TREE_CHAIN (*ptr);
+ TREE_CHAIN (decl) = *ptr;
+ *ptr = decl;
+ }
+ }
+
+ pending_local_decls = nreverse (pending_local_decls);
+
+ /* Fill in default names for the parameters. */
+ for (parm = DECL_ARGUMENTS (current_function_decl), i = 0;
+ parm != NULL_TREE; parm = TREE_CHAIN (parm), i++)
+ {
+ if (DECL_NAME (parm) == NULL_TREE)
+ {
+ int arg_i = METHOD_STATIC (current_function_decl) ? i+1 : i;
+ if (arg_i == 0)
+ DECL_NAME (parm) = get_identifier ("this");
+ else
+ {
+ char buffer[12];
+ sprintf (buffer, "ARG_%d", arg_i);
+ DECL_NAME (parm) = get_identifier (buffer);
+ }
+ DECL_ASSEMBLER_NAME (parm) = DECL_NAME (parm);
+ }
+ }
+}
+
+void
+complete_start_java_method (fndecl)
+ tree fndecl;
+{
+
+ DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE,
+ TREE_TYPE (TREE_TYPE (fndecl)));
+
+ if (! flag_emit_class_files)
+ {
+ /* Initialize the RTL code for the function. */
+ init_function_start (fndecl, input_filename, lineno);
+
+ /* Set up parameters and prepare for return, for the function. */
+ expand_function_start (fndecl, 0);
+ }
+
+ /* Allocate further tree nodes temporarily during compilation
+ of this function only. */
+ temporary_allocation ();
+
+#if 0
+ /* 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 (current_function_decl)))
+ TREE_ADDRESSABLE (current_function_decl) = 1;
+
+#endif
+
+ if (METHOD_SYNCHRONIZED (fndecl))
+ {
+ /* FIXME: surround the function body by a try/finally set. */
+ }
+
+ /* Push local variables. Function compiled from source code are
+ using a different local variables management, and for them,
+ pushlevel shouldn't be called from here. */
+ if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl)))
+
+ {
+ pushlevel (2);
+ if (! flag_emit_class_files)
+ expand_start_bindings (1);
+ }
+}
+
+void
+start_java_method (fndecl)
+ tree fndecl;
+{
+ tree tem, *ptr;
+ int i;
+
+ current_function_decl = fndecl;
+ announce_function (fndecl);
+
+ i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl);
+ decl_map = make_tree_vec (i);
+ type_map = (tree *) oballoc (i * sizeof (tree));
+
+ pushlevel (1); /* Push parameters. */
+
+ ptr = &DECL_ARGUMENTS (fndecl);
+ for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
+ tem != NULL_TREE; tem = TREE_CHAIN (tem), i++)
+ {
+ tree parm_name = NULL_TREE, parm_decl;
+ if (i >= DECL_MAX_LOCALS(fndecl))
+ fatal ("function has more parameters than local slots");
+
+ parm_decl = build_decl (PARM_DECL, parm_name, TREE_VALUE (tem));
+ DECL_CONTEXT (parm_decl) = fndecl;
+ DECL_ARG_TYPE (parm_decl) = TREE_TYPE (parm_decl);
+
+ *ptr = parm_decl;
+ ptr = &TREE_CHAIN (parm_decl);
+
+ /* Add parm_decl to the decl_map. */
+ push_jvm_slot (i, parm_decl);
+
+ type_map[i] = TREE_TYPE (parm_decl);
+ if (TYPE_IS_WIDE (TREE_TYPE (parm_decl)))
+ {
+ i++;
+ type_map[i] = void_type_node;
+ }
+ }
+ *ptr = NULL_TREE;
+ DECL_ARG_SLOT_COUNT (current_function_decl) = i;
+
+ while (i < DECL_MAX_LOCALS(fndecl))
+ type_map[i++] = NULL_TREE;
+
+ complete_start_java_method (fndecl);
+}
+
+void
+end_java_method ()
+{
+ tree fndecl = current_function_decl;
+
+ expand_end_bindings (getdecls (), 1, 0);
+ /* pop out of function */
+ poplevel (1, 1, 0);
+
+ /* pop out of its parameters */
+ poplevel (1, 0, 1);
+
+ BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
+
+ emit_handlers ();
+
+ /* Generate rtl for function exit. */
+ expand_function_end (input_filename, lineno, 0);
+
+ /* Run the optimizers and output assembler code for this function. */
+ rest_of_compilation (fndecl);
+
+ current_function_decl = NULL_TREE;
+ permanent_allocation (1);
+}
+
+tree
+build_decl_no_layout (code, name, type)
+ enum tree_code code;
+ tree name, type;
+{
+ tree decl = build_decl (TYPE_DECL, name, type);
+ TREE_SET_CODE (decl, code);
+ return decl;
+}
--- /dev/null
+/* Handle exceptions for GNU compiler for the Java(TM) language.
+ Copyright (C) 1997 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+#include <stdio.h>
+#include "config.h"
+#include "tree.h"
+#include "real.h"
+#include "rtl.h"
+#include "java-tree.h"
+#include "javaop.h"
+#include "java-opcodes.h"
+#include "jcf.h"
+#include "except.h"
+#include "java-except.h"
+#include "eh-common.h"
+
+extern struct obstack permanent_obstack;
+
+struct eh_range *current_method_handlers;
+
+struct eh_range *current_try_block = NULL;
+
+struct eh_range *eh_range_freelist = NULL;
+
+/* These variables are used to speed up find_handler. */
+
+static int cache_range_start, cache_range_end;
+static struct eh_range *cache_range;
+static struct eh_range *cache_next_child;
+
+/* A dummy range that represents the entire method. */
+
+struct eh_range whole_range;
+
+/* Search for the most specific eh_range containing PC.
+ Assume PC is within RANGE.
+ CHILD is a list of children of RANGE such that any
+ previous children have end_pc values that are too low. */
+
+static struct eh_range *
+find_handler_in_range (pc, range, child)
+ int pc;
+ struct eh_range *range;
+ register struct eh_range *child;
+{
+ for (; child != NULL; child = child->next_sibling)
+ {
+ if (pc < child->start_pc)
+ break;
+ if (pc <= child->end_pc)
+ return find_handler_in_range (pc, child, child->first_child);
+ }
+ cache_range = range;
+ cache_range_start = pc;
+ cache_next_child = child;
+ cache_range_end = child == NULL ? range->end_pc : child->start_pc;
+ return range;
+}
+
+/* Find the inner-most handler that contains PC. */
+
+struct eh_range *
+find_handler (pc)
+ int pc;
+{
+ struct eh_range *h;
+ if (pc >= cache_range_start)
+ {
+ h = cache_range;
+ if (pc < cache_range_end)
+ return h;
+ while (pc >= h->end_pc)
+ {
+ cache_next_child = h->next_sibling;
+ h = h->outer;
+ }
+ }
+ else
+ {
+ h = &whole_range;
+ cache_next_child = h->first_child;
+ }
+ return find_handler_in_range (pc, h, cache_next_child);
+}
+
+#if 0
+first_child;
+next_sibling;
+outer;
+#endif
+
+/* Recursive helper routine for add_handler. */
+
+static int
+link_handler (start_pc, end_pc, handler, type, outer)
+ int start_pc, end_pc;
+ tree handler;
+ tree type;
+ struct eh_range *outer;
+{
+ struct eh_range **ptr;
+ if (start_pc < outer->start_pc || end_pc > outer->end_pc)
+ return 0; /* invalid or non-nested exception range */
+ if (start_pc == outer->start_pc && end_pc == outer->end_pc)
+ {
+ outer->handlers = tree_cons (type, handler, outer->handlers);
+ return 1;
+ }
+ ptr = &outer->first_child;
+ for (;; ptr = &(*ptr)->next_sibling)
+ {
+ if (*ptr == NULL || end_pc <= (*ptr)->start_pc)
+ {
+ struct eh_range *h = (struct eh_range *)
+ oballoc (sizeof (struct eh_range));
+ h->start_pc = start_pc;
+ h->end_pc = end_pc;
+ h->next_sibling = *ptr;
+ h->first_child = NULL;
+ h->outer = outer;
+ h->handlers = build_tree_list (type, handler);
+ *ptr = h;
+ return 1;
+ }
+ else if (start_pc < (*ptr)->end_pc)
+ return link_handler (start_pc, end_pc, handler, type, *ptr);
+ /* end_pc > (*ptr)->start_pc && start_pc >= (*ptr)->end_pc. */
+ }
+}
+
+/* Called to re-initialize the exception machinery for a new method. */
+
+void
+method_init_exceptions ()
+{
+ whole_range.start_pc = 0;
+ whole_range.end_pc = DECL_CODE_LENGTH (current_function_decl) + 1;
+ whole_range.outer = NULL;
+ whole_range.first_child = NULL;
+ whole_range.next_sibling = NULL;
+ cache_range_start = 0xFFFFFF;
+ set_exception_lang_code (EH_LANG_Java);
+ set_exception_version_code (1);
+}
+
+int
+add_handler (start_pc, end_pc, handler, type)
+ int start_pc, end_pc;
+ tree handler;
+ tree type;
+{
+ return link_handler (start_pc, end_pc, handler, type, &whole_range);
+}
+
+
+/* if there are any handlers for this range, issue start of region */
+void
+expand_start_java_handler (range)
+ struct eh_range *range;
+{
+ expand_eh_region_start ();
+}
+
+/* if there are any handlers for this range, isssue end of range,
+ and then all handler blocks */
+void
+expand_end_java_handler (range)
+ struct eh_range *range;
+{
+ tree handler = range->handlers;
+ expand_start_all_catch ();
+ for ( ; handler != NULL_TREE; handler = TREE_CHAIN (handler))
+ {
+ tree type = TREE_PURPOSE (handler);
+ tree exp;
+ /* The "type" (metch_info) in a (Java) exception table is one:
+ * a) NULL - meaning match any type in a try-finally.
+ * b) a pointer to a (ccmpiled) class (low-order bit 0).
+ * c) a pointer to the Utf8Const name of the class, plus one
+ * (which yields a value with low-order bit 1). */
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ if (type == NULL_TREE)
+ exp = null_pointer_node;
+ else if (is_compiled_class (type))
+ exp = build_class_ref (type);
+ else
+ exp = fold (build (PLUS_EXPR, ptr_type_node,
+ build_utf8_ref (build_internal_class_name (type)),
+ size_one_node));
+ pop_obstacks ();
+ start_catch_handler (exp);
+ expand_goto (TREE_VALUE (handler));
+ }
+ expand_end_all_catch ();
+}
+
+/* Recursive helper routine for maybe_start_handlers. */
+
+static void
+check_start_handlers (range, pc)
+ struct eh_range *range;
+ int pc;
+{
+ if (range != NULL_EH_RANGE && range->start_pc == pc)
+ {
+ check_start_handlers (range->outer, pc);
+ expand_start_java_handler (range);
+ }
+}
+
+struct eh_range *current_range;
+
+/* Emit any start-of-try-range start at PC. */
+
+void
+maybe_start_try (pc)
+ int pc;
+{
+ if (! doing_eh (1))
+ return;
+
+ current_range = find_handler (pc);
+ check_start_handlers (current_range, pc);
+}
+
+/* Emit any end-of-try-range end at PC. */
+
+void
+maybe_end_try (pc)
+ int pc;
+{
+ if (! doing_eh (1))
+ return;
+
+ while (current_range != NULL_EH_RANGE && current_range->end_pc <= pc)
+ {
+ expand_end_java_handler (current_range);
+ current_range = current_range->outer;
+ }
+}
+
+/* Emit the handler labels and their code */
+
+void
+emit_handlers ()
+{
+ if (catch_clauses)
+ {
+ rtx funcend = gen_label_rtx ();
+ emit_jump (funcend);
+
+ emit_insns (catch_clauses);
+ expand_leftover_cleanups ();
+
+ emit_label (funcend);
+ }
+}
--- /dev/null
+/* Process expressions for the GNU compiler for the Java(TM) language.
+ Copyright (C) 1996, 1997, 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
+
+#include <stdio.h>
+#include "config.h"
+#include "tree.h"
+#include "real.h"
+#include "rtl.h"
+#include "expr.h"
+#include "java-tree.h"
+#include "javaop.h"
+#include "java-opcodes.h"
+#include "jcf.h"
+#include "java-except.h"
+#include "parse.h"
+
+static tree operand_type[59];
+extern struct obstack permanent_obstack;
+
+void
+init_expr_processing()
+{
+ operand_type[21] = operand_type[54] = int_type_node;
+ operand_type[22] = operand_type[55] = long_type_node;
+ operand_type[23] = operand_type[56] = float_type_node;
+ operand_type[24] = operand_type[57] = double_type_node;
+ operand_type[25] = operand_type[58] = ptr_type_node;
+}
+
+/* We store the stack state in two places:
+ Within a basic block, we use the quick_stack, which is a
+ pushdown list (TREE_LISTs) of expression nodes.
+ This is the top part of the stack; below that we use find_stack_slot.
+ At the end of a basic block, the quick_stack must be flushed
+ to the stack slot array (as handled by find_stack_slot).
+ Using quick_stack generates better code (especially when
+ compiled without optimization), because we do not have to
+ explicitly store and load trees to temporary variables.
+
+ If a variable is on the quick stack, it means the value of variable
+ when the quick stack was last flushed. Conceptually, flush_quick_stack
+ saves all the the quick_stack elements in parellel. However, that is
+ complicated, so it actually saves them (i.e. copies each stack value
+ to is home virtual register) from low indexes. This allows a quick_stack
+ element at index i (counting from the bottom of stack the) to references
+ slot virtuals for register that are >= i, but not those that are deeper.
+ This convention makes most operations easier. For example iadd works
+ even when the stack contains (reg[0], reg[1]): It results in the
+ stack containing (reg[0]+reg[1]), which is OK. However, some stack
+ operations are more complicated. For example dup given a stack
+ containing (reg[0]) would yield (reg[0], reg[0]), which would violate
+ the convention, since stack value 1 would refer to a register with
+ lower index (reg[0]), which flush_quick_stack does not safely handle.
+ So dup cannot just add an extra element to the quick_stack, but iadd can.
+*/
+
+tree quick_stack = NULL_TREE;
+
+/* A free-list of unused permamnet TREE_LIST nodes. */
+tree tree_list_free_list = NULL_TREE;
+
+/* The stack pointer of the Java virtual machine.
+ This does include the size of the quick_stack. */
+
+int stack_pointer;
+
+unsigned char *linenumber_table;
+int linenumber_count;
+
+tree
+truthvalue_conversion (expr)
+ tree expr;
+{
+ /* It is simpler and generates better code to have only TRUTH_*_EXPR
+ or comparison expressions as truth values at this level.
+
+ This function should normally be identity for Java. */
+
+ switch (TREE_CODE (expr))
+ {
+ case EQ_EXPR:
+ case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
+ case TRUTH_ANDIF_EXPR:
+ case TRUTH_ORIF_EXPR:
+ case TRUTH_AND_EXPR:
+ case TRUTH_OR_EXPR:
+ case ERROR_MARK:
+ return expr;
+
+ case INTEGER_CST:
+ return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
+
+ case REAL_CST:
+ return real_zerop (expr) ? boolean_false_node : boolean_true_node;
+
+ /* are these legal? XXX JH */
+ case NEGATE_EXPR:
+ case ABS_EXPR:
+ case FLOAT_EXPR:
+ case FFS_EXPR:
+ /* These don't change whether an object is non-zero or zero. */
+ return truthvalue_conversion (TREE_OPERAND (expr, 0));
+
+ case COND_EXPR:
+ /* Distribute the conversion into the arms of a COND_EXPR. */
+ return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
+ truthvalue_conversion (TREE_OPERAND (expr, 1)),
+ truthvalue_conversion (TREE_OPERAND (expr, 2))));
+
+ case NOP_EXPR:
+ /* If this is widening the argument, we can ignore it. */
+ if (TYPE_PRECISION (TREE_TYPE (expr))
+ >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
+ return truthvalue_conversion (TREE_OPERAND (expr, 0));
+ /* fall through to default */
+
+ default:
+ return fold (build (NE_EXPR, boolean_type_node, expr, boolean_false_node));
+ }
+}
+
+#ifdef JAVA_USE_HANDLES
+/* Given a pointer to a handle, get a pointer to an object. */
+
+tree
+unhand_expr (expr)
+ tree expr;
+{
+ tree field, handle_type;
+ expr = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (expr)), expr);
+ handle_type = TREE_TYPE (expr);
+ field = TYPE_FIELDS (handle_type);
+ expr = build (COMPONENT_REF, TREE_TYPE (field), expr, field);
+ return expr;
+}
+#endif
+
+/* Save any stack slots that happen to be in the quick_stack into their
+ home virtual register slots.
+
+ The copy order is from low stack index to high, to support the invariant
+ that the expression for a slot may contain decls for stack slots with
+ higher (or the same) index, but not lower. */
+
+void
+flush_quick_stack ()
+{
+ int stack_index = stack_pointer;
+ register tree prev, cur, next;
+
+ /* First reverse the quick_stack, and count the number of slots it has. */
+ for (cur = quick_stack, prev = NULL_TREE; cur != NULL_TREE; cur = next)
+ {
+ next = TREE_CHAIN (cur);
+ TREE_CHAIN (cur) = prev;
+ prev = cur;
+ stack_index -= 1 + TYPE_IS_WIDE (TREE_TYPE (TREE_VALUE (cur)));
+ }
+ quick_stack = prev;
+
+ while (quick_stack != NULL_TREE)
+ {
+ tree decl;
+ tree node = quick_stack, type;
+ quick_stack = TREE_CHAIN (node);
+ TREE_CHAIN (node) = tree_list_free_list;
+ tree_list_free_list = node;
+ node = TREE_VALUE (node);
+ type = TREE_TYPE (node);
+
+ decl = find_stack_slot (stack_index, type);
+ if (decl != node)
+ expand_assignment (decl, node, 0, 0);
+ stack_index += 1 + TYPE_IS_WIDE (type);
+ }
+}
+
+void
+push_type (type)
+ tree type;
+{
+ int n_words;
+ type = promote_type (type);
+ n_words = 1 + TYPE_IS_WIDE (type);
+ if (stack_pointer + n_words > DECL_MAX_STACK (current_function_decl))
+ fatal ("stack overflow");
+ stack_type_map[stack_pointer++] = type;
+ n_words--;
+ while (--n_words >= 0)
+ stack_type_map[stack_pointer++] = TYPE_SECOND;
+}
+
+void
+push_value (value)
+ tree value;
+{
+ tree type = TREE_TYPE (value);
+ if (TYPE_PRECISION (type) < 32 && INTEGRAL_TYPE_P (type))
+ {
+ type = promote_type (type);
+ value = convert (type, value);
+ }
+ push_type (type);
+ if (tree_list_free_list == NULL_TREE)
+ quick_stack = perm_tree_cons (NULL_TREE, value, quick_stack);
+ else
+ {
+ tree node = tree_list_free_list;
+ tree_list_free_list = TREE_CHAIN (tree_list_free_list);
+ TREE_VALUE (node) = value;
+ TREE_CHAIN (node) = quick_stack;
+ quick_stack = node;
+ }
+}
+
+tree
+pop_type (type)
+ tree type;
+{
+ int n_words;
+ int i;
+ tree t;
+ if (TREE_CODE (type) == RECORD_TYPE)
+ type = promote_type (type);
+ n_words = 1 + TYPE_IS_WIDE (type);
+ if (stack_pointer < n_words)
+ fatal ("stack underflow");
+ while (--n_words > 0)
+ {
+ if (stack_type_map[--stack_pointer] != void_type_node)
+ fatal ("Invalid multi-word value on type stack");
+ }
+ t = stack_type_map[--stack_pointer];
+ if (type == NULL_TREE || t == type)
+ return t;
+ if (INTEGRAL_TYPE_P (type) && INTEGRAL_TYPE_P (t)
+ && TYPE_PRECISION (type) <= 32 && TYPE_PRECISION (t) <= 32)
+ return t;
+ if (TREE_CODE (type) == POINTER_TYPE && TREE_CODE (t) == POINTER_TYPE)
+ {
+ if (type == ptr_type_node || type == object_ptr_type_node)
+ return t;
+ else if (t == ptr_type_node) /* Special case for null reference. */
+ return type;
+ else if (can_widen_reference_to (t, type))
+ return t;
+ }
+ error ("unexpected type on stack");
+ return t;
+}
+
+/* Return 1f if SOURCE_TYPE can be safely widened to TARGET_TYPE.
+ Handles array types and interfaces. */
+
+int
+can_widen_reference_to (source_type, target_type)
+ tree source_type, target_type;
+{
+ if (source_type == ptr_type_node || target_type == object_ptr_type_node)
+ return 1;
+
+ /* Get rid of pointers */
+ if (TREE_CODE (source_type) == POINTER_TYPE)
+ source_type = TREE_TYPE (source_type);
+ if (TREE_CODE (target_type) == POINTER_TYPE)
+ target_type = TREE_TYPE (target_type);
+
+ if (source_type == target_type)
+ return 1;
+ else
+ {
+ source_type = HANDLE_TO_CLASS_TYPE (source_type);
+ target_type = HANDLE_TO_CLASS_TYPE (target_type);
+ if (TYPE_ARRAY_P (source_type) || TYPE_ARRAY_P (target_type))
+ {
+ HOST_WIDE_INT source_length, target_length;
+ if (TYPE_ARRAY_P (source_type) != TYPE_ARRAY_P (target_type))
+ return 0;
+ target_length = java_array_type_length (target_type);
+ if (target_length >= 0)
+ {
+ source_length = java_array_type_length (source_type);
+ if (source_length != target_length)
+ return 0;
+ }
+ source_type = TYPE_ARRAY_ELEMENT (source_type);
+ target_type = TYPE_ARRAY_ELEMENT (target_type);
+ if (source_type == target_type)
+ return 1;
+ if (TREE_CODE (source_type) != POINTER_TYPE
+ || TREE_CODE (target_type) != POINTER_TYPE)
+ return 0;
+ return can_widen_reference_to (source_type, target_type);
+ }
+ else
+ {
+ int source_depth = class_depth (source_type);
+ int target_depth = class_depth (target_type);
+
+ if (CLASS_INTERFACE (TYPE_NAME (target_type)))
+ {
+ /* target_type is OK if source_type or source_type ancestors
+ implement target_type. We handle multiple sub-interfaces */
+
+ tree basetype_vec = TYPE_BINFO_BASETYPES (source_type);
+ int n = TREE_VEC_LENGTH (basetype_vec), i;
+ for (i=0 ; i < n; i++)
+ if (can_widen_reference_to
+ (TREE_TYPE (TREE_VEC_ELT (basetype_vec, i)),
+ target_type))
+ return 1;
+ if (n == 0)
+ return 0;
+ }
+
+ for ( ; source_depth > target_depth; source_depth--)
+ {
+ source_type = TYPE_BINFO_BASETYPE (source_type, 0);
+ }
+ return source_type == target_type;
+ }
+ }
+}
+
+tree
+pop_value (type)
+ tree type;
+{
+ int n_words = 1 + TYPE_IS_WIDE (type);
+ int i;
+ type = pop_type (type);
+ if (quick_stack)
+ {
+ tree node = quick_stack;
+ quick_stack = TREE_CHAIN (quick_stack);
+ TREE_CHAIN (node) = tree_list_free_list;
+ tree_list_free_list = node;
+ node = TREE_VALUE (node);
+ return node;
+ }
+ else
+ return find_stack_slot (stack_pointer, promote_type (type));
+}
+
+
+/* Pop and discrad the top COUNT stack slots. */
+
+void
+java_stack_pop (count)
+ int count;
+{
+ while (count > 0)
+ {
+ tree type, val;
+ if (stack_pointer == 0)
+ fatal ("stack underflow");
+ type = stack_type_map[stack_pointer - 1];
+ if (type == TYPE_SECOND)
+ {
+ count--;
+ if (stack_pointer == 1 || count <= 0)
+ fatal ("stack underflow");
+ type = stack_type_map[stack_pointer - 2];
+ }
+ val = pop_value (type);
+ count--;
+ }
+}
+
+/* Implement the 'swap' operator (to swap two top stack slots). */
+
+void
+java_stack_swap ()
+{
+ tree type1, type2;
+ rtx temp;
+ tree decl1, decl2;
+
+ if (stack_pointer < 2
+ || (type1 = stack_type_map[stack_pointer - 1]) == TYPE_UNKNOWN
+ || (type2 = stack_type_map[stack_pointer - 2]) == TYPE_UNKNOWN
+ || type1 == TYPE_SECOND || type2 == TYPE_SECOND
+ || TYPE_IS_WIDE (type1) || TYPE_IS_WIDE (type2))
+ fatal ("bad stack swap");
+
+ flush_quick_stack ();
+ decl1 = find_stack_slot (stack_pointer - 1, type1);
+ decl2 = find_stack_slot (stack_pointer - 2, type2);
+ temp = copy_to_reg (DECL_RTL (decl1));
+ emit_move_insn (DECL_RTL (decl1), DECL_RTL (decl2));
+ emit_move_insn (DECL_RTL (decl2), temp);
+ stack_type_map[stack_pointer - 1] = type2;
+ stack_type_map[stack_pointer - 2] = type1;
+}
+
+void
+java_stack_dup (size, offset)
+ int size, offset;
+{
+ int low_index = stack_pointer - size - offset;
+ int dst_index;
+ if (low_index < 0)
+ error ("stack underflow - dup* operation");
+
+ flush_quick_stack ();
+
+ stack_pointer += size;
+ dst_index = stack_pointer;
+
+ for (dst_index = stack_pointer; --dst_index >= low_index; )
+ {
+ tree type;
+ int src_index = dst_index - size;
+ if (src_index < low_index)
+ src_index = dst_index + size + offset;
+ type = stack_type_map [src_index];
+ if (type == TYPE_SECOND)
+ {
+ if (src_index <= low_index)
+ fatal ("dup operation splits 64-bit number");
+ stack_type_map[dst_index] = type;
+ src_index--; dst_index--;
+ type = stack_type_map[src_index];
+ if (! TYPE_IS_WIDE (type))
+ fatal ("internal error - dup operation");
+ }
+ else if (TYPE_IS_WIDE (type))
+ fatal ("internal error - dup operation");
+ if (src_index != dst_index)
+ {
+ tree src_decl = find_stack_slot (src_index, type);
+ tree dst_decl = find_stack_slot (dst_index, type);
+ emit_move_insn (DECL_RTL (dst_decl), DECL_RTL (src_decl));
+ stack_type_map[dst_index] = type;
+ }
+ }
+}
+
+/* Calls soft_athrow. Discard the contents of the value stack. */
+
+tree
+build_java_athrow (node)
+ tree node;
+{
+ tree call;
+
+ call = build (CALL_EXPR,
+ void_type_node,
+ build_address_of (throw_node),
+ build_tree_list (NULL_TREE, node),
+ NULL_TREE);
+ TREE_SIDE_EFFECTS (call) = 1;
+ expand_expr_stmt (call);
+ java_stack_pop (stack_pointer);
+}
+
+/* Implementation for jsr/ret */
+
+void
+build_java_jsr (where, ret)
+ tree where;
+ tree ret;
+{
+ tree ret_label = fold (build1 (ADDR_EXPR, return_address_type_node, ret));
+ push_value (ret_label);
+ flush_quick_stack ();
+ expand_goto (where);
+ expand_label (ret);
+}
+
+void
+build_java_ret (location)
+ tree location;
+{
+ expand_computed_goto (location);
+}
+
+/* Implementation of operations on array: new, load, store, length */
+
+/* Array core info access macros */
+
+#define JAVA_ARRAY_LENGTH_OFFSET(A) \
+ size_binop (CEIL_DIV_EXPR, \
+ (DECL_FIELD_BITPOS \
+ (TREE_CHAIN (TYPE_FIELDS (TREE_TYPE (TREE_TYPE (A)))))), \
+ size_int (BITS_PER_UNIT))
+
+tree
+decode_newarray_type (int atype)
+{
+ switch (atype)
+ {
+ case 4: return boolean_type_node;
+ case 5: return char_type_node;
+ case 6: return float_type_node;
+ case 7: return double_type_node;
+ case 8: return byte_type_node;
+ case 9: return short_type_node;
+ case 10: return int_type_node;
+ case 11: return long_type_node;
+ default: return NULL_TREE;
+ }
+}
+
+/* Build a call to soft_badarrayindex(), the ArrayIndexOfBoundsException
+ exception handler. */
+
+static tree
+build_java_throw_out_of_bounds_exception ()
+{
+ tree node = build (CALL_EXPR, int_type_node,
+ build_address_of (soft_badarrayindex_node),
+ NULL_TREE, NULL_TREE );
+ TREE_SIDE_EFFECTS (node) = 1; /* Allows expansion within ANDIF */
+ return (node);
+}
+
+/* Return the length of an array. Doesn't perform any checking on the nature
+ or value of the array NODE. May be used to implement some bytecodes. */
+
+tree
+build_java_array_length_access (node)
+ tree node;
+{
+ tree type = TREE_TYPE (node);
+ HOST_WIDE_INT length;
+ if (!is_array_type_p (type))
+ fatal ("array length on a non-array reference");
+ length = java_array_type_length (type);
+ if (length >= 0)
+ return build_int_2 (length, 0);
+ return fold (build1 (INDIRECT_REF,
+ int_type_node,
+ fold (build (PLUS_EXPR, ptr_type_node,
+ node,
+ JAVA_ARRAY_LENGTH_OFFSET(node)))));
+}
+
+/* Optionally checks an array against the NULL pointer, eventually throwing a
+ NullPointerException. It could replace signal handling, but tied to NULL.
+ ARG1: the pointer to check, ARG2: the expression to use if
+ the pointer is non-null and ARG3 the type that should be returned. */
+
+tree
+build_java_arraynull_check (node, expr, type)
+ tree node;
+ tree expr;
+ tree type;
+{
+#if 0
+ static int java_array_access_throws_null_exception = 0;
+ node = ???;
+ if (java_array_access_throws_null_exception)
+ return (build (COND_EXPR,
+ type,
+ build (EQ_EXPR, int_type_node, node, null_pointer_node),
+ build_java_athrow (node), expr ));
+ else
+#endif
+ return (expr);
+}
+
+static tree
+java_array_data_offset (array)
+ tree array;
+{
+ tree array_type = TREE_TYPE (TREE_TYPE (array));
+ tree data_fld = TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (array_type)));
+ if (data_fld == NULL_TREE)
+ return size_in_bytes (array_type);
+ else
+ return build_int_2 (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (data_fld))
+ / BITS_PER_UNIT, 0);
+}
+
+/* Implement array indexing (either as l-value or r-value).
+ Returns a tree for ARRAY[INDEX], assume TYPE is the element type.
+ Optionally performs bounds checking and/or test to NULL.
+ At this point, ARRAY should have been verified as an array. */
+
+tree
+build_java_arrayaccess (array, type, index)
+ tree array, type, index;
+{
+ tree arith, node, throw = NULL_TREE;
+
+ arith = fold (build (PLUS_EXPR, int_type_node,
+ java_array_data_offset (array),
+ fold (build (MULT_EXPR, int_type_node,
+ index, size_in_bytes(type)))));
+
+ if (flag_bounds_check)
+ {
+ /* Generate:
+ * (unsigned jint) INDEX >= (unsigned jint) LEN
+ * && throw ArrayIndexOutOfBoundsException.
+ * Note this is equivalent to and more efficient than:
+ * INDEX < 0 || INDEX >= LEN && throw ... */
+ tree test;
+ tree len = build_java_array_length_access (array);
+ TREE_TYPE (len) = unsigned_int_type_node;
+ test = fold (build (GE_EXPR, boolean_type_node,
+ convert (unsigned_int_type_node, index),
+ len));
+ if (! integer_zerop (test))
+ {
+ throw = build (TRUTH_ANDIF_EXPR, int_type_node, test,
+ build_java_throw_out_of_bounds_exception ());
+ /* allows expansion within COMPOUND */
+ TREE_SIDE_EFFECTS( throw ) = 1;
+ }
+ }
+
+ node = build1 (INDIRECT_REF, type,
+ fold (build (PLUS_EXPR, ptr_type_node,
+ array,
+ (throw ? build (COMPOUND_EXPR, int_type_node,
+ throw, arith )
+ : arith))));
+
+ return (fold (build_java_arraynull_check (array, node, type)));
+}
+
+/* Makes sure that INDEXED_TYPE is appropriate. If not, make it from
+ ARRAY_NODE. This function is used to retrieve something less vague than
+ a pointer type when indexing the first dimension of something like [[<t>.
+ May return a corrected type, if necessary, otherwise INDEXED_TYPE is
+ return unchanged.
+ As a side effect, it also makes sure that ARRAY_NODE is an array. */
+
+static tree
+build_java_check_indexed_type (array_node, indexed_type)
+ tree array_node;
+ tree indexed_type;
+{
+ tree elt_type;
+
+ if (!is_array_type_p (TREE_TYPE (array_node)))
+ fatal ("array indexing on a non-array reference");
+
+ elt_type = (TYPE_ARRAY_ELEMENT (TREE_TYPE (TREE_TYPE (array_node))));
+
+ if (indexed_type == ptr_type_node )
+ return promote_type (elt_type);
+
+ /* BYTE/BOOLEAN store and load are used for both type */
+ if (indexed_type == byte_type_node && elt_type == boolean_type_node )
+ return boolean_type_node;
+
+ if (indexed_type != elt_type )
+ fatal ("type array element mismatch");
+ else
+ return indexed_type;
+}
+
+/* newarray triggers a call to soft_newarray. This function should be called
+ with an integer code (the type of array to create) and get from the stack
+ the size of the dimmension. */
+
+tree
+build_newarray (atype_value, length)
+ int atype_value;
+ tree length;
+{
+ tree type = build_java_array_type (decode_newarray_type (atype_value),
+ TREE_CODE (length) == INTEGER_CST
+ ? TREE_INT_CST_LOW (length)
+ : -1);
+ return build (CALL_EXPR, promote_type (type),
+ build_address_of (soft_newarray_node),
+ tree_cons (NULL_TREE,
+ build_int_2 (atype_value, 0),
+ build_tree_list (NULL_TREE, length)),
+ NULL_TREE);
+}
+
+/* Generates anewarray from a given CLASS_TYPE. Gets from the stack the size
+ of the dimension. */
+/* Merge with build_newarray. FIXME. */
+tree
+build_anewarray (class_type, length)
+ tree class_type;
+ tree length;
+{
+ tree type = build_java_array_type (promote_type (class_type),
+ TREE_CODE (length) == INTEGER_CST
+ ? TREE_INT_CST_LOW (length)
+ : -1);
+ return build (CALL_EXPR, promote_type (type),
+ build_address_of (soft_anewarray_node),
+ tree_cons (NULL_TREE, length,
+ tree_cons (NULL_TREE, build_class_ref (class_type),
+ build_tree_list (NULL_TREE,
+ null_pointer_node))),
+ NULL_TREE);
+}
+
+/* Generates a call to multianewarray. multianewarray expects a class pointer,
+ a number of dimensions and the matching number of dimensions. The argument
+ list is NULL terminated. */
+
+void
+expand_java_multianewarray (class_type, ndim)
+ tree class_type;
+ int ndim;
+{
+ int i;
+ tree args = build_tree_list( NULL_TREE, null_pointer_node );
+
+ for( i = 0; i < ndim; i++ )
+ args = tree_cons (NULL_TREE, pop_value (int_type_node), args);
+
+ push_value (build (CALL_EXPR,
+ promote_type (class_type),
+ build_address_of (soft_multianewarray_node),
+ tree_cons (NULL_TREE, build_class_ref (class_type),
+ tree_cons (NULL_TREE,
+ build_int_2 (ndim, 0), args )),
+ NULL_TREE));
+}
+
+/* ARRAY[INDEX] <- RHS. build_java_check_indexed_type makes sure that
+ ARRAY is an array type. May expand some bound checking and NULL
+ pointer checking. RHS_TYPE_NODE we are going to store. In the case
+ of the CHAR/BYTE/BOOLEAN SHORT, the type popped of the stack is an
+ INT. In those cases, we make the convertion.
+
+ if ARRAy is a reference type, the assignment is checked at run-time
+ to make sure that the RHS can be assigned to the array element
+ type. It is not necessary to generate this code if ARRAY is final. */
+
+void
+expand_java_arraystore (rhs_type_node)
+ tree rhs_type_node;
+{
+ tree rhs_node = pop_value ((INTEGRAL_TYPE_P (rhs_type_node)
+ && TYPE_PRECISION (rhs_type_node) <= 32) ?
+ int_type_node : rhs_type_node);
+ tree index = pop_value (int_type_node);
+ tree array = pop_value (ptr_type_node);
+
+ rhs_type_node = build_java_check_indexed_type (array, rhs_type_node);
+
+ flush_quick_stack ();
+
+ index = save_expr (index);
+ array = save_expr (array);
+
+ if (TREE_CODE (rhs_type_node) == POINTER_TYPE
+ && !CLASS_FINAL (TYPE_NAME (TREE_TYPE (rhs_type_node))))
+ {
+ tree check = build (CALL_EXPR, void_type_node,
+ build_address_of (soft_checkarraystore_node),
+ tree_cons (NULL_TREE, array,
+ build_tree_list (NULL_TREE, rhs_node)),
+ NULL_TREE);
+ TREE_SIDE_EFFECTS (check) = 1;
+ expand_expr_stmt (check);
+ }
+
+ expand_assignment (build_java_arrayaccess (array,
+ rhs_type_node,
+ index),
+ rhs_node, 0, 0);
+}
+
+/* Expand the evaluation of ARRAY[INDEX]. build_java_check_indexed_type makes
+ sure that LHS is an array type. May expand some bound checking and NULL
+ pointer checking.
+ LHS_TYPE_NODE is the type of ARRAY[INDEX]. But in the case of CHAR/BYTE/
+ BOOLEAN/SHORT, we push a promoted type back to the stack.
+*/
+
+void
+expand_java_arrayload (lhs_type_node )
+ tree lhs_type_node;
+{
+ tree load_node;
+ int convert;
+ tree index_node = pop_value (int_type_node);
+ tree array_node = pop_value (ptr_type_node);
+
+ index_node = save_expr (index_node);
+ array_node = save_expr (array_node);
+ lhs_type_node = build_java_check_indexed_type (array_node, lhs_type_node);
+
+ load_node = build_java_arrayaccess (array_node,
+ lhs_type_node,
+ index_node);
+
+ if (INTEGRAL_TYPE_P (lhs_type_node) && TYPE_PRECISION (lhs_type_node) <= 32)
+ load_node = fold (build1 (NOP_EXPR, int_type_node, load_node));
+ push_value (load_node);
+}
+
+/* Expands .length. Makes sure that we deal with and array and may expand
+ a NULL check on the array object. */
+
+void
+expand_java_array_length ()
+{
+ tree array = pop_value (ptr_type_node);
+ tree length = build_java_array_length_access (array);
+
+ push_value (build_java_arraynull_check (array, length, int_type_node));
+}
+
+/* Emit code for the call to soft_monitor{enter,exit}. CALL can be either
+ soft_monitorenter_node or soft_monitorexit_node. */
+
+tree
+build_java_monitor (call, object)
+ tree call;
+ tree object;
+{
+ return (build (CALL_EXPR,
+ void_type_node,
+ build_address_of (call),
+ build_tree_list (NULL_TREE, object),
+ NULL_TREE));
+}
+
+/* Emit code for one of the PUSHC instructions. */
+
+void
+expand_java_pushc (ival, type)
+ int ival;
+ tree type;
+{
+ tree value;
+ if (type == ptr_type_node && ival == 0)
+ value = null_pointer_node;
+ else if (type == int_type_node || type == long_type_node)
+ {
+ value = build_int_2 (ival, ival < 0 ? -1 : 0);
+ TREE_TYPE (value) = type;
+ }
+ else if (type == float_type_node || type == double_type_node)
+ {
+ REAL_VALUE_TYPE x;
+#ifdef REAL_ARITHMETIC
+ REAL_VALUE_FROM_INT (x, ival, 0, TYPE_MODE (type));
+#else
+ x = ival;
+#endif
+ value = build_real (type, x);
+ }
+ else
+ fatal ("internal error in expand_java_pushc");
+ push_value (value);
+}
+
+void
+expand_java_return (type)
+ tree type;
+{
+ if (type == void_type_node)
+ expand_null_return ();
+ else
+ {
+ tree retval = pop_value (type);
+ tree res = DECL_RESULT (current_function_decl);
+ retval = build (MODIFY_EXPR, TREE_TYPE (res), res, retval);
+ TREE_SIDE_EFFECTS (retval) = 1;
+ expand_return (retval);
+ }
+}
+
+tree
+build_address_of (value)
+ tree value;
+{
+ return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (value)), value);
+}
+
+void
+expand_java_NEW (type)
+ tree type;
+{
+ if (! CLASS_LOADED_P (type))
+ load_class (type, 1);
+ push_value (build (CALL_EXPR, promote_type (type),
+ build_address_of (alloc_object_node),
+ tree_cons (NULL_TREE, build_class_ref (type),
+ build_tree_list (NULL_TREE,
+ size_in_bytes (type))),
+ NULL_TREE));
+}
+
+void
+expand_java_INSTANCEOF (type)
+ tree type;
+{
+ tree value = pop_value (object_ptr_type_node);
+ value = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (soft_instanceof_node)),
+ build_address_of (soft_instanceof_node),
+ tree_cons (NULL_TREE, value,
+ build_tree_list (NULL_TREE,
+ build_class_ref (type))),
+ NULL_TREE);
+ push_value (value);
+}
+
+void
+expand_java_CHECKCAST (type)
+ tree type;
+{
+ tree value = pop_value (ptr_type_node);
+ value = build (CALL_EXPR, promote_type (type),
+ build_address_of (soft_checkcast_node),
+ tree_cons (NULL_TREE, build_class_ref (type),
+ build_tree_list (NULL_TREE, value)),
+ NULL_TREE);
+ push_value (value);
+}
+
+void
+expand_iinc (unsigned int local_var_index, int ival, int pc)
+{
+ tree local_var, res;
+ tree constant_value;
+
+ flush_quick_stack ();
+ local_var = find_local_variable (local_var_index, int_type_node, pc);
+ constant_value = build_int_2 (ival, ival < 0 ? -1 : 0);
+ res = fold (build (PLUS_EXPR, int_type_node, local_var, constant_value));
+ expand_assignment (local_var, res, 0, 0);
+}
+
+tree
+build_java_binop (op, type, arg1, arg2)
+ enum tree_code op;
+ tree type, arg1, arg2;
+{
+ tree mask;
+ switch (op)
+ {
+ case URSHIFT_EXPR:
+ {
+ tree u_type = unsigned_type (type);
+ arg1 = convert (u_type, arg1);
+ arg1 = build_java_binop (RSHIFT_EXPR, u_type, arg1, arg2);
+ return convert (type, arg1);
+ }
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ mask = build_int_2 (TYPE_PRECISION (TREE_TYPE (arg1)) - 1, 0);
+ arg2 = fold (build (BIT_AND_EXPR, int_type_node, arg2, mask));
+ break;
+
+ case COMPARE_L_EXPR: /* arg1 > arg2 ? 1 : arg1 == arg2 ? 0 : -1 */
+ case COMPARE_G_EXPR: /* arg1 < arg2 ? -1 : arg1 == arg2 ? 0 : 1 */
+ arg1 = save_expr (arg1); arg2 = save_expr (arg2);
+ {
+ tree ifexp1 = fold ( build (op == COMPARE_L_EXPR ? GT_EXPR : LT_EXPR,
+ boolean_type_node, arg1, arg2));
+ tree ifexp2 = fold ( build (EQ_EXPR, boolean_type_node, arg1, arg2));
+ tree second_compare = fold (build (COND_EXPR, int_type_node,
+ ifexp2, integer_zero_node,
+ op == COMPARE_L_EXPR
+ ? integer_negative_one_node
+ : integer_one_node));
+ return fold (build (COND_EXPR, int_type_node, ifexp1,
+ op == COMPARE_L_EXPR ? integer_one_node
+ : integer_negative_one_node,
+ second_compare));
+ }
+ case COMPARE_EXPR:
+ arg1 = save_expr (arg1); arg2 = save_expr (arg2);
+ {
+ tree ifexp1 = fold ( build (LT_EXPR, boolean_type_node, arg1, arg2));
+ tree ifexp2 = fold ( build (GT_EXPR, boolean_type_node, arg1, arg2));
+ tree second_compare = fold ( build (COND_EXPR, int_type_node,
+ ifexp2, integer_one_node,
+ integer_zero_node));
+ return fold (build (COND_EXPR, int_type_node,
+ ifexp1, integer_negative_one_node, second_compare));
+ }
+
+ case TRUNC_MOD_EXPR:
+ if (TREE_CODE (type) == REAL_TYPE)
+ {
+ tree call;
+ if (type != double_type_node)
+ {
+ arg1 = convert (double_type_node, arg1);
+ arg2 = convert (double_type_node, arg2);
+ }
+ call = build (CALL_EXPR, double_type_node,
+ build_address_of (soft_fmod_node),
+ tree_cons (NULL_TREE, arg1,
+ build_tree_list (NULL_TREE, arg2)),
+ NULL_TREE);
+ if (type != double_type_node)
+ call = convert (type, call);
+ return call;
+ }
+ break;
+
+#if 0 /* not required */
+ case PLUS_EXPR:
+ case MULT_EXPR:
+ case MINUS_EXPR:
+ case TRUNC_DIV_EXPR:
+ case RDIV_EXPR:
+/* case REM_EXPR: */
+ case BIT_AND_EXPR:
+ case BIT_IOR_EXPR:
+ case BIT_XOR_EXPR:
+ break;
+ default:
+ error ("unknown opcode");
+ return error_mark_node;
+#endif
+
+ }
+ return fold (build (op, type, arg1, arg2));
+}
+
+void
+expand_java_binop (type, op)
+ tree type; enum tree_code op;
+{
+ tree larg, rarg;
+ tree ltype = type;
+ tree rtype = type;
+ switch (op)
+ {
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ case URSHIFT_EXPR:
+ rtype = int_type_node;
+ rarg = pop_value (rtype);
+ break;
+ default:
+ rarg = pop_value (rtype);
+ }
+ larg = pop_value (ltype);
+ push_value (build_java_binop (op, type, larg, rarg));
+}
+
+/* Lookup the field named NAME in *TYPEP or its super classes.
+ If not found, return NULL_TREE.
+ (If the *TYPEP is not found, return error_mark_node.)
+ If found, return the FIELD_DECL, and set *TYPEP to the
+ class containing the field. */
+
+tree
+lookup_field (typep, name)
+ tree *typep;
+ tree name;
+{
+ if (CLASS_P (*typep) && !CLASS_LOADED_P (*typep))
+ {
+ load_class (*typep, 1);
+ if (TREE_CODE (TYPE_SIZE (*typep)) == ERROR_MARK)
+ return error_mark_node;
+ }
+ do
+ {
+ tree field;
+ for (field = TYPE_FIELDS (*typep); field; field = TREE_CHAIN (field))
+ {
+ if (DECL_NAME (field) == name)
+ return field;
+ }
+ *typep = CLASSTYPE_SUPER (*typep);
+ } while (*typep);
+ return NULL_TREE;
+}
+
+/* Look up the field named NAME in object SELF_VALUE,
+ which has class SELF_CLASS (a non-handle RECORD_TYPE).
+ SELF_VALUE is NULL_TREE if looking for a static field. */
+
+tree
+build_field_ref (self_value, self_class, name)
+ tree self_value, self_class, name;
+{
+ tree base_class = self_class;
+ tree field_decl = lookup_field (&base_class, name);
+ if (field_decl == NULL_TREE)
+ {
+ error ("field `%s' not found", IDENTIFIER_POINTER (name));
+ return error_mark_node;
+ }
+ if (self_value == NULL_TREE)
+ {
+ return build_static_field_ref (field_decl);
+ }
+ else
+ {
+ tree base_handle_type = promote_type (base_class);
+ if (base_handle_type != TREE_TYPE (self_value))
+ self_value = fold (build1 (NOP_EXPR, base_handle_type, self_value));
+#ifdef JAVA_USE_HANDLES
+ self_value = unhand_expr (self_value);
+#endif
+ self_value = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (self_value)),
+ self_value);
+ return fold (build (COMPONENT_REF, TREE_TYPE (field_decl),
+ self_value, field_decl));
+ }
+}
+
+tree
+lookup_label (pc)
+ int pc;
+{
+ tree name;
+ char buf[20];
+ sprintf (buf, "LJpc=%d", pc);
+ name = get_identifier (buf);
+ if (IDENTIFIER_LOCAL_VALUE (name))
+ return IDENTIFIER_LOCAL_VALUE (name);
+ else
+ {
+ /* The type of the address of a label is return_address_type_node. */
+ tree decl = create_label_decl (name);
+ LABEL_PC (decl) = pc;
+ label_rtx (decl);
+ return pushdecl (decl);
+ }
+}
+
+tree
+create_label_decl (name)
+ tree name;
+{
+ tree decl;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ decl = build_decl (LABEL_DECL, name,
+ TREE_TYPE (return_address_type_node));
+ pop_obstacks ();
+ DECL_CONTEXT (decl) = current_function_decl;
+ DECL_IGNORED_P (decl) = 1;
+ return decl;
+}
+
+/* This maps a bytecode offset (PC) to various flags. */
+char *instruction_bits;
+
+void
+note_label (current_pc, target_pc)
+ int current_pc, target_pc;
+{
+ lookup_label (target_pc);
+ instruction_bits [target_pc] |= BCODE_JUMP_TARGET;
+}
+
+/* Emit code to jump to TARGET_PC if VALUE1 CONDITION VALUE2,
+ where CONDITION is one of one the compare operators. */
+
+
+void
+expand_compare (condition, value1, value2, target_pc)
+ enum tree_code condition;
+ tree value1, value2;
+ int target_pc;
+{
+ tree target = lookup_label (target_pc);
+ tree cond = fold (build (condition, boolean_type_node, value1, value2));
+ expand_start_cond (truthvalue_conversion (cond), 0);
+ expand_goto (target);
+ expand_end_cond ();
+}
+
+/* Emit code for a TEST-type opcode. */
+
+void
+expand_test (condition, type, target_pc)
+ enum tree_code condition;
+ tree type;
+ int target_pc;
+{
+ tree value1, value2;
+ flush_quick_stack ();
+ value1 = pop_value (type);
+ value2 = (type == ptr_type_node) ? null_pointer_node : integer_zero_node;
+ expand_compare (condition, value1, value2, target_pc);
+}
+
+/* Emit code for a COND-type opcode. */
+
+void
+expand_cond (condition, type, target_pc)
+ enum tree_code condition;
+ tree type;
+ int target_pc;
+{
+ tree value1, value2;
+ flush_quick_stack ();
+ /* note: pop values in opposite order */
+ value2 = pop_value (type);
+ value1 = pop_value (type);
+ /* Maybe should check value1 and value2 for type compatibility ??? */
+ expand_compare (condition, value1, value2, target_pc);
+}
+
+void
+expand_java_goto (target_pc)
+ int target_pc;
+{
+ tree target_label = lookup_label (target_pc);
+ flush_quick_stack ();
+ expand_goto (target_label);
+}
+
+void
+expand_java_call (target_pc, return_address)
+ int target_pc, return_address;
+{
+ tree target_label = lookup_label (target_pc);
+ tree value = build_int_2 (return_address, return_address < 0 ? -1 : 0);
+ push_value (value);
+ flush_quick_stack ();
+ expand_goto (target_label);
+}
+
+void
+expand_java_ret (return_address)
+ tree return_address;
+{
+ warning ("ret instruction not implemented");
+#if 0
+ tree target_label = lookup_label (target_pc);
+ flush_quick_stack ();
+ expand_goto (target_label);
+#endif
+}
+
+/* Recursive helper function to pop argument types during verifiation. */
+
+void
+pop_argument_types (arg_types)
+ tree arg_types;
+{
+ if (arg_types == NULL_TREE)
+ return;
+ if (TREE_CODE (arg_types) == TREE_LIST)
+ {
+ pop_argument_types (TREE_CHAIN (arg_types));
+ pop_type (TREE_VALUE (arg_types));
+ return;
+ }
+ abort ();
+}
+
+tree
+pop_arguments (arg_types)
+ tree arg_types;
+{
+ if (arg_types == NULL_TREE)
+ return NULL_TREE;
+ if (TREE_CODE (arg_types) == TREE_LIST)
+ {
+ tree tail = pop_arguments (TREE_CHAIN (arg_types));
+ return tree_cons (NULL_TREE, pop_value (TREE_VALUE (arg_types)), tail);
+ }
+ abort ();
+}
+
+/* Build an expression to initialize the class CLAS.
+ if EXPR is non-NULL, returns an expression to first call the initializer
+ (if it is needed) and then calls EXPR. */
+
+tree
+build_class_init (clas, expr)
+ tree clas, expr;
+{
+ tree init;
+ if (inherits_from_p (current_class, clas))
+ return expr;
+ init = build (CALL_EXPR, void_type_node,
+ build_address_of (soft_initclass_node),
+ build_tree_list (NULL_TREE, build_class_ref (clas)),
+ NULL_TREE);
+ TREE_SIDE_EFFECTS (init) = 1;
+ if (expr != NULL_TREE)
+ {
+ expr = build (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
+ TREE_SIDE_EFFECTS (expr) = 1;
+ return expr;
+ }
+ return init;
+}
+
+static tree methods_ident = NULL_TREE;
+static tree ncode_ident = NULL_TREE;
+tree dtable_ident = NULL_TREE;
+
+tree
+build_known_method_ref (method, method_type, self_type, method_signature, arg_list)
+ tree method, method_type, self_type, method_signature, arg_list;
+{
+ tree func;
+ if (flag_emit_class_files)
+ return method;
+ else if (is_compiled_class (self_type))
+ {
+ make_decl_rtl (method, NULL, 1);
+ func = build1 (ADDR_EXPR, method_ptr_type_node, method);
+ }
+ else
+ {
+ /* We don't know whether the method has been (statically) compiled.
+ Compile this code to get a reference to the method's code:
+
+ SELF_TYPE->methods[METHOD_INDEX].ncode
+
+ This is guaranteed to work (assuming SELF_TYPE has
+ been initialized), since if the method is not compiled yet,
+ its ncode points to a trampoline that forces compilation. */
+
+ int method_index = 0;
+ tree meth;
+ tree ref = build_class_ref (self_type);
+ ref = build1 (INDIRECT_REF, class_type_node, ref);
+ if (ncode_ident == NULL_TREE)
+ ncode_ident = get_identifier ("ncode");
+ if (methods_ident == NULL_TREE)
+ methods_ident = get_identifier ("methods");
+ ref = build (COMPONENT_REF, method_ptr_type_node, ref,
+ lookup_field (&class_type_node, methods_ident));
+ for (meth = TYPE_METHODS (CLASS_TO_HANDLE_TYPE (self_type));
+ ; meth = TREE_CHAIN (meth))
+ {
+ if (method == meth)
+ break;
+ if (meth == NULL_TREE)
+ fatal ("method '%s' not found in class",
+ IDENTIFIER_POINTER (DECL_NAME (method)));
+ method_index++;
+ }
+ method_index *= int_size_in_bytes (method_type_node);
+ ref = fold (build (PLUS_EXPR, method_ptr_type_node,
+ ref, build_int_2 (method_index, 0)));
+ ref = build1 (INDIRECT_REF, method_type_node, ref);
+ func = build (COMPONENT_REF, nativecode_ptr_type_node,
+ ref,
+ lookup_field (&method_type_node, ncode_ident));
+ }
+ return func;
+}
+
+tree
+invoke_build_dtable (is_invoke_interface, arg_list)
+ int is_invoke_interface;
+ tree arg_list;
+{
+ tree dtable, objectref;
+
+ TREE_VALUE (arg_list) = save_expr (TREE_VALUE (arg_list));
+
+ /* If we're dealing with interfaces and if the objectref
+ argument is an array then get the dispatch table of the class
+ Object rather than the one from the objectref. */
+ objectref = (is_invoke_interface
+ && is_array_type_p (TREE_TYPE (TREE_VALUE (arg_list))) ?
+ object_type_node : TREE_VALUE (arg_list));
+
+ if (dtable_ident == NULL_TREE)
+ dtable_ident = get_identifier ("dtable");
+ dtable = build1 (INDIRECT_REF, object_type_node, objectref );
+ dtable = build (COMPONENT_REF, dtable_ptr_type, dtable,
+ lookup_field (&object_type_node, dtable_ident));
+
+ return dtable;
+}
+
+tree
+build_invokevirtual (dtable, method)
+ tree dtable, method;
+{
+ tree func;
+ tree nativecode_ptr_ptr_type_node
+ = build_pointer_type (nativecode_ptr_type_node);
+ int method_index = TREE_INT_CST_LOW (DECL_VINDEX (method));
+ /* Add one to skip "class" field of dtable, and one to skip unused
+ vtable entry (for C++ compatibility). */
+ method_index += 2;
+ method_index
+ *= int_size_in_bytes (nativecode_ptr_ptr_type_node);
+ func = fold (build (PLUS_EXPR, nativecode_ptr_ptr_type_node,
+ dtable, build_int_2 (method_index, 0)));
+ func = build1 (INDIRECT_REF, nativecode_ptr_type_node, func);
+
+ return func;
+}
+
+/* Expand one of the invoke_* opcodes.
+ OCPODE is the specific opcode.
+ METHOD_REF_INDEX is an index into the constant pool.
+ NARGS is the number of arguments, or -1 if not specified. */
+
+void
+expand_invoke (opcode, method_ref_index, nargs)
+ int opcode;
+ int method_ref_index;
+ int nargs;
+{
+ tree method_signature = COMPONENT_REF_SIGNATURE(¤t_jcf->cpool, method_ref_index);
+ tree method_name = COMPONENT_REF_NAME (¤t_jcf->cpool, method_ref_index);
+ tree self_type = get_class_constant
+ (current_jcf, COMPONENT_REF_CLASS_INDEX(¤t_jcf->cpool, method_ref_index));
+ char *self_name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
+ tree call, func, method, arg_list, method_type;
+
+ static tree class_ident = NULL_TREE;
+
+ if (! CLASS_LOADED_P (self_type))
+ {
+ load_class (self_type, 1);
+ if (TREE_CODE (TYPE_SIZE (self_type)) == ERROR_MARK)
+ fatal ("failed to find class '%s'", self_name);
+ }
+
+ if (method_name == init_identifier_node)
+ method = lookup_java_constructor (CLASS_TO_HANDLE_TYPE (self_type),
+ method_signature);
+ else
+ method = lookup_java_method (CLASS_TO_HANDLE_TYPE (self_type),
+ method_name, method_signature);
+ if (method == NULL_TREE)
+ {
+ error ("Class '%s' has no method named '%s' matching signature '%s'",
+ self_name,
+ IDENTIFIER_POINTER (method_name),
+ IDENTIFIER_POINTER (method_signature));
+ }
+ /* Invoke static can't invoke static/abstract method */
+ else if (opcode == OPCODE_invokestatic)
+ {
+ if (!METHOD_STATIC (method))
+ {
+ error ("invokestatic on non static method");
+ method = NULL_TREE;
+ }
+ else if (METHOD_ABSTRACT (method))
+ {
+ error ("invokestatic on abstract method");
+ method = NULL_TREE;
+ }
+ }
+ else
+ {
+ if (METHOD_STATIC (method))
+ {
+ error ("invoke[non-static] on static method");
+ method = NULL_TREE;
+ }
+ }
+
+ if (method == NULL_TREE)
+ {
+ method_type = get_type_from_signature (method_signature);
+ pop_arguments (TYPE_ARG_TYPES (method_type));
+ if (opcode != OPCODE_invokestatic)
+ pop_type (self_type);
+ method_type = promote_type (TREE_TYPE (method_type));
+ push_value (convert (method_type, integer_zero_node));
+ return;
+ }
+
+ method_type = TREE_TYPE (method);
+ arg_list = pop_arguments (TYPE_ARG_TYPES (method_type));
+ flush_quick_stack ();
+
+ if (opcode == OPCODE_invokestatic || opcode == OPCODE_invokespecial
+ && ! inherits_from_p (current_class, self_type))
+ { /* FIXME probably not needed for invokespecial if done by NEW. */
+ /* Ensure self_type is initialized. */
+ func = build (CALL_EXPR, void_type_node, soft_initclass_node,
+ build_tree_list (NULL_TREE,
+ build_class_ref (self_type)),
+ NULL_TREE);
+ expand_expr_stmt (func);
+ }
+
+ func = NULL_TREE;
+ if (opcode == OPCODE_invokestatic || opcode == OPCODE_invokespecial
+ || (opcode == OPCODE_invokevirtual
+ && (METHOD_FINAL (method) || CLASS_FINAL (TYPE_NAME (self_type)))))
+ func = build_known_method_ref (method, method_type, self_type,
+ method_signature, arg_list);
+ else
+ {
+ tree dtable = invoke_build_dtable (opcode == OPCODE_invokeinterface,
+ arg_list);
+ if (opcode == OPCODE_invokevirtual)
+ func = build_invokevirtual (dtable, method);
+ else
+ {
+ /* We expand invokeinterface here. soft_lookupinterfacemethod () will
+ ensure that the selected method exists, is public and not abstract
+ nor static. */
+
+ tree lookup_arg;
+
+ if (class_ident == NULL_TREE)
+ class_ident = get_identifier ("class");
+
+ dtable = build1 (INDIRECT_REF, dtable_type, dtable);
+ dtable = build (COMPONENT_REF, class_ptr_type, dtable,
+ lookup_field (&dtable_type, class_ident));
+ lookup_arg = build_tree_list (NULL_TREE,
+ build_utf8_ref (method_signature));
+ lookup_arg = tree_cons (NULL_TREE, dtable,
+ tree_cons (NULL_TREE,
+ build_utf8_ref (method_name),
+ lookup_arg));
+ func = build (CALL_EXPR,
+ ptr_type_node,
+ build_address_of (soft_lookupinterfacemethod_node),
+ lookup_arg, NULL_TREE);
+ }
+ }
+ func = build1 (NOP_EXPR, build_pointer_type (method_type), func);
+ call = build (CALL_EXPR, TREE_TYPE (method_type), func, arg_list, NULL_TREE);
+ TREE_SIDE_EFFECTS (call) = 1;
+
+ if (opcode == OPCODE_invokestatic || opcode == OPCODE_invokespecial)
+ { /* FIXME probably not needed for invokespecial if done by NEW. */
+ /* Ensure self_type is initialized. */
+ call = build_class_init (self_type, call);
+ }
+
+ if (TREE_CODE (TREE_TYPE (method_type)) == VOID_TYPE)
+ expand_expr_stmt (call);
+ else
+ {
+ push_value (call);
+ flush_quick_stack ();
+ }
+}
+
+
+/* Expand an operation to extract from or store into a field.
+ IS_STATIC is 1 iff the field is static.
+ IS_PUTTING is 1 for putting into a field; 0 for getting from the field.
+ FIELD_REF_INDEX is an index into the constant pool. */
+
+void
+expand_java_field_op (is_static, is_putting, field_ref_index)
+ int is_static;
+ int is_putting;
+ int field_ref_index;
+{
+ tree self_type = get_class_constant
+ (current_jcf, COMPONENT_REF_CLASS_INDEX (¤t_jcf->cpool, field_ref_index));
+ char *self_name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (self_type)));
+ tree field_name = COMPONENT_REF_NAME (¤t_jcf->cpool, field_ref_index);
+ tree field_signature = COMPONENT_REF_SIGNATURE (¤t_jcf->cpool, field_ref_index);
+ tree field_type = get_type_from_signature (field_signature);
+ tree new_value = is_putting ? pop_value (field_type) : NULL_TREE;
+ tree field_ref;
+ int is_error = 0;
+ tree field_decl = lookup_field (&self_type, field_name);
+ if (field_decl == error_mark_node)
+ {
+ is_error = 1;
+ }
+ else if (field_decl == NULL_TREE)
+ {
+ error ("Missing field '%s' in '%s'",
+ IDENTIFIER_POINTER (field_name), self_name);
+ is_error = 1;
+ }
+ else if (build_java_signature (TREE_TYPE (field_decl)) != field_signature)
+ {
+ error ("Mismatching signature for field '%s' in '%s'",
+ IDENTIFIER_POINTER (field_name), self_name);
+ is_error = 1;
+ }
+ field_ref = is_static ? NULL_TREE : pop_value (self_type);
+ if (is_error)
+ {
+ if (! is_putting)
+ push_value (convert (promote_type (field_type), integer_zero_node));
+ flush_quick_stack ();
+ return;
+ }
+
+ /* Inline references to java.lang.PRIMTYPE.TYPE.
+ In addition to being a useful (minor) optimization,
+ this is also needed to avoid circularities in the implementation
+ of these fields in libjava. */
+ if (field_name == TYPE_identifier_node && ! is_putting
+ && field_type == class_type_node
+ && strncmp (self_name, "java.lang.", 10) == 0)
+ {
+ char *class_name = self_name+10;
+ tree typ;
+ if (strcmp(class_name, "Byte") == 0)
+ typ = byte_type_node;
+ else if (strcmp(class_name, "Short") == 0)
+ typ = short_type_node;
+ else if (strcmp(class_name, "Integer") == 0)
+ typ = int_type_node;
+ else if (strcmp(class_name, "Long") == 0)
+ typ = long_type_node;
+ else if (strcmp(class_name, "Float") == 0)
+ typ = float_type_node;
+ else if (strcmp(class_name, "Boolean") == 0)
+ typ = boolean_type_node;
+ else if (strcmp(class_name, "Char") == 0)
+ typ = char_type_node;
+ else if (strcmp(class_name, "Void") == 0)
+ typ = void_type_node;
+ else
+ typ = NULL_TREE;
+ if (typ != NULL_TREE)
+ {
+ push_value (build_class_ref (typ));
+ return;
+ }
+ }
+
+ field_ref = build_field_ref (field_ref, self_type, field_name);
+ if (is_static)
+ field_ref = build_class_init (self_type, field_ref);
+ if (is_putting)
+ {
+ flush_quick_stack ();
+ if (FIELD_FINAL (field_decl))
+ {
+ if (DECL_CONTEXT (field_decl) != current_class)
+ error_with_decl (field_decl,
+ "assignment to final field `%s' not in field's class");
+ else if (FIELD_STATIC (field_decl))
+ {
+ if (DECL_NAME (current_function_decl) != clinit_identifier_node)
+ error_with_decl (field_decl,
+ "assignment to final static field `%s' not in class initializer");
+ }
+ else
+ {
+ if (! DECL_CONSTRUCTOR_P (current_function_decl))
+ error_with_decl (field_decl,
+ "assignment to final field `%s' not in constructor");
+ }
+ }
+ expand_assignment (field_ref, new_value, 0, 0);
+ }
+ else
+ push_value (field_ref);
+}
+
+void
+load_type_state (label)
+ tree label;
+{
+ int i;
+ tree vec = LABEL_TYPE_STATE (label);
+ int cur_length = TREE_VEC_LENGTH (vec);
+ stack_pointer = cur_length - DECL_MAX_LOCALS(current_function_decl);
+ for (i = 0; i < cur_length; i++)
+ type_map [i] = TREE_VEC_ELT (vec, i);
+}
+
+struct rtx_def *
+java_lang_expand_expr (exp, target, tmode, modifier)
+ register tree exp;
+ rtx target;
+ enum machine_mode tmode;
+ enum expand_modifier modifier;
+{
+ register rtx op0;
+ tree type = TREE_TYPE (exp);
+ register enum machine_mode mode = TYPE_MODE (type);
+ int unsignedp = TREE_UNSIGNED (type);
+
+ switch (TREE_CODE (exp))
+ {
+ case BLOCK:
+ if (BLOCK_EXPR_BODY (exp))
+ {
+ tree local;
+ struct rtx_def *to_return;
+ pushlevel (2); /* 2 and above */
+ expand_start_bindings (0);
+ local = BLOCK_EXPR_DECLS (exp);
+ while (local)
+ {
+ tree next = TREE_CHAIN (local);
+ layout_decl (local, 0);
+ expand_decl (pushdecl (local));
+ local = next;
+ }
+ to_return =
+ expand_expr (BLOCK_EXPR_BODY (exp), target, tmode, modifier);
+ poplevel (1, 1, 0);
+ expand_end_bindings (getdecls (), 1, 0);
+ return to_return;
+ }
+ break;
+
+ default:
+ fatal ("Can't expand '%s' tree - java_lang_expand_expr",
+ tree_code_name [TREE_CODE (exp)]);
+ }
+}
+
+void
+expand_byte_code (jcf, method)
+ JCF *jcf;
+ tree method;
+{
+ int PC;
+ int i;
+ int saw_index;
+ unsigned char *linenumber_pointer;
+ struct eh_range *prev_eh_ranges = NULL_EH_RANGE;
+ struct eh_range *eh_ranges;
+
+#undef RET /* Defined by config/i386/i386.h */
+#undef AND /* Causes problems with opcodes for iand and land. */
+#undef PTR
+#define BCODE byte_ops
+#define BYTE_type_node byte_type_node
+#define SHORT_type_node short_type_node
+#define INT_type_node int_type_node
+#define LONG_type_node long_type_node
+#define CHAR_type_node char_type_node
+#define PTR_type_node ptr_type_node
+#define FLOAT_type_node float_type_node
+#define DOUBLE_type_node double_type_node
+#define VOID_type_node void_type_node
+ jint INT_temp;
+ unsigned char* byte_ops;
+ long length = DECL_CODE_LENGTH (method);
+
+ stack_pointer = 0;
+ JCF_SEEK (jcf, DECL_CODE_OFFSET (method));
+ byte_ops = jcf->read_ptr;
+
+#define CONST_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
+#define CONST_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
+#define VAR_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
+#define VAR_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
+
+#define CHECK_PC_IN_RANGE(PC) 1 /* Already handled by verifier. */
+
+ instruction_bits = oballoc (length + 1);
+ bzero (instruction_bits, length + 1);
+
+ /* We make an initial pass of the line number table, to note
+ which instructions have associated line number entries. */
+ linenumber_pointer = linenumber_table;
+ for (i = 0; i < linenumber_count; i++)
+ {
+ int pc = GET_u2 (linenumber_pointer);
+ linenumber_pointer += 4;
+ if (pc >= length)
+ warning ("invalid PC in line number table");
+ else
+ {
+ if ((instruction_bits[pc] & BCODE_HAS_LINENUMBER) != 0)
+ instruction_bits[pc] |= BCODE_HAS_MULTI_LINENUMBERS;
+ instruction_bits[pc] |= BCODE_HAS_LINENUMBER;
+ }
+ }
+
+ /* Do a preliminary pass.
+ * This figures out which PC can be the targets of jumps. */
+ for (PC = 0; PC < length;)
+ {
+ int oldpc = PC; /* PC at instruction start. */
+ instruction_bits [PC] |= BCODE_INSTRUCTION_START;
+ switch (byte_ops[PC++])
+ {
+#define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
+ case OPCODE: \
+ PRE_##OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
+ break;
+
+#define NOTE_LABEL(PC) note_label(oldpc, PC)
+
+#define PRE_PUSHC(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
+#define PRE_LOAD(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
+#define PRE_STORE(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE);
+#define PRE_STACK(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+#define PRE_UNOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+#define PRE_BINOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+#define PRE_CONVERT(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+#define PRE_CONVERT2(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+
+#define PRE_SPECIAL(OPERAND_TYPE, INSTRUCTION) \
+ PRE_SPECIAL_##INSTRUCTION(OPERAND_TYPE)
+#define PRE_SPECIAL_IINC(OPERAND_TYPE) \
+ ((void) IMMEDIATE_u1, (void) IMMEDIATE_s1)
+#define PRE_SPECIAL_ENTER(IGNORE) /* nothing */
+#define PRE_SPECIAL_EXIT(IGNORE) /* nothing */
+#define PRE_SPECIAL_THROW(IGNORE) /* nothing */
+#define PRE_SPECIAL_BREAK(IGNORE) /* nothing */
+
+/* two forms of wide instructions */
+#define PRE_SPECIAL_WIDE(IGNORE) \
+ { \
+ int modified_opcode = IMMEDIATE_u1; \
+ if (modified_opcode == OPCODE_iinc) \
+ { \
+ (void) IMMEDIATE_u2; /* indexbyte1 and indexbyte2 */ \
+ (void) IMMEDIATE_s2; /* constbyte1 and constbyte2 */ \
+ } \
+ else \
+ { \
+ (void) IMMEDIATE_u2; /* indexbyte1 and indexbyte2 */ \
+ } \
+ }
+
+/* nothing */ /* XXX JH */
+
+#define PRE_IMPL(IGNORE1, IGNORE2) /* nothing */
+
+#define PRE_MONITOR(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+
+#define PRE_RETURN(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+#define PRE_ARRAY(OPERAND_TYPE, SUBOP) \
+ PRE_ARRAY_##SUBOP(OPERAND_TYPE)
+#define PRE_ARRAY_LOAD(TYPE) /* nothing */
+#define PRE_ARRAY_STORE(TYPE) /* nothing */
+#define PRE_ARRAY_LENGTH(TYPE) /* nothing */
+#define PRE_ARRAY_NEW(TYPE) PRE_ARRAY_NEW_##TYPE
+#define PRE_ARRAY_NEW_NUM ((void) IMMEDIATE_u1)
+#define PRE_ARRAY_NEW_PTR ((void) IMMEDIATE_u2)
+#define PRE_ARRAY_NEW_MULTI ((void) IMMEDIATE_u2, (void) IMMEDIATE_u1)
+
+#define PRE_TEST(OPERAND_TYPE, OPERAND_VALUE) NOTE_LABEL (oldpc+IMMEDIATE_s2)
+#define PRE_COND(OPERAND_TYPE, OPERAND_VALUE) NOTE_LABEL (oldpc+IMMEDIATE_s2)
+#define PRE_BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
+ saw_index = 0; INT_temp = (OPERAND_VALUE); \
+ if (!saw_index) NOTE_LABEL(oldpc + INT_temp);
+#define PRE_JSR(OPERAND_TYPE, OPERAND_VALUE) \
+ saw_index = 0; INT_temp = (OPERAND_VALUE); \
+ if (!saw_index) NOTE_LABEL(oldpc + INT_temp);
+
+#define PRE_RET(OPERAND_TYPE, OPERAND_VALUE) (void)(OPERAND_VALUE)
+
+#define PRE_SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
+ PC = (PC + 3) / 4 * 4; PRE_##TABLE_OR_LOOKUP##_SWITCH
+
+#define PRE_LOOKUP_SWITCH \
+ { jint default_offset = IMMEDIATE_s4; jint npairs = IMMEDIATE_s4; \
+ NOTE_LABEL (default_offset+oldpc); \
+ if (npairs >= 0) \
+ while (--npairs >= 0) { \
+ jint match = IMMEDIATE_s4; jint offset = IMMEDIATE_s4; \
+ NOTE_LABEL (offset+oldpc); } \
+ }
+
+#define PRE_TABLE_SWITCH \
+ { jint default_offset = IMMEDIATE_s4; \
+ jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4; \
+ NOTE_LABEL (default_offset+oldpc); \
+ if (low <= high) \
+ while (low++ <= high) { \
+ jint offset = IMMEDIATE_s4; \
+ NOTE_LABEL (offset+oldpc); } \
+ }
+
+#define PRE_FIELD(MAYBE_STATIC, PUT_OR_GET) (void)(IMMEDIATE_u2);
+#define PRE_OBJECT(MAYBE_STATIC, PUT_OR_GET) (void)(IMMEDIATE_u2);
+#define PRE_INVOKE(MAYBE_STATIC, IS_INTERFACE) \
+ (void)(IMMEDIATE_u2); \
+ PC += 2 * IS_INTERFACE /* for invokeinterface */;
+
+#include "javaop.def"
+#undef JAVAOP
+ }
+ } /* for */
+
+ if (! verify_jvm_instructions (jcf, byte_ops, length))
+ return;
+
+ /* Translate bytecodes to rtl instructions. */
+ linenumber_pointer = linenumber_table;
+ for (PC = 0; PC < length;)
+ {
+ if ((instruction_bits [PC] & BCODE_TARGET) != 0 || PC == 0)
+ {
+ tree label = lookup_label (PC);
+ flush_quick_stack ();
+ if ((instruction_bits [PC] & BCODE_TARGET) != 0)
+ expand_label (label);
+ if (LABEL_VERIFIED (label) || PC == 0)
+ load_type_state (label);
+ }
+
+ if (! (instruction_bits [PC] & BCODE_VERIFIED))
+ {
+ /* never executed - skip */
+ warning ("Some bytecode operations (starting at pc %d) can never be executed", PC);
+ while (PC < length
+ && ! (instruction_bits [PC] & BCODE_VERIFIED))
+ PC++;
+ continue;
+ }
+
+
+ /* Handle possible line number entry for this PC.
+
+ This code handles out-of-order and multiple linenumbers per PC,
+ but is optimized for the case of line numbers increasing
+ monotonically with PC. */
+ if ((instruction_bits[PC] & BCODE_HAS_LINENUMBER) != 0)
+ {
+ if ((instruction_bits[PC] & BCODE_HAS_MULTI_LINENUMBERS) != 0
+ || GET_u2 (linenumber_pointer) != PC)
+ linenumber_pointer = linenumber_table;
+ while (linenumber_pointer < linenumber_table + linenumber_count * 4)
+ {
+ int pc = GET_u2 (linenumber_pointer);
+ linenumber_pointer += 4;
+ if (pc == PC)
+ {
+ lineno = GET_u2 (linenumber_pointer - 2);
+ emit_line_note (input_filename, lineno);
+ if (!(instruction_bits[PC] & BCODE_HAS_MULTI_LINENUMBERS))
+ break;
+ }
+ }
+ }
+ maybe_start_try (PC);
+ maybe_pushlevels (PC);
+
+ PC = process_jvm_instruction (PC, byte_ops, length);
+
+ maybe_poplevels (PC);
+ maybe_end_try (PC);
+ } /* for */
+}
+
+void
+java_push_constant_from_pool (jcf, index)
+ JCF *jcf;
+ int index;
+{
+ tree c;
+ if (JPOOL_TAG (jcf, index) == CONSTANT_String)
+ {
+ tree name;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index));
+ index = alloc_name_constant (CONSTANT_String, name);
+ c = build_ref_from_constant_pool (index);
+ TREE_TYPE (c) = promote_type (string_type_node);
+ pop_obstacks ();
+ }
+ else
+ c = get_constant (jcf, index);
+ push_value (c);
+}
+
+int
+process_jvm_instruction (PC, byte_ops, length)
+ int PC;
+ unsigned char* byte_ops;
+ long length;
+{
+ char *opname; /* Temporary ??? */
+ int oldpc = PC; /* PC at instruction start. */
+ switch (byte_ops[PC++])
+ {
+#define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
+ case OPCODE: \
+ opname = #OPNAME; \
+ OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
+ break;
+
+#define RET(OPERAND_TYPE, OPERAND_VALUE) \
+ { \
+ int saw_index = 0; \
+ int index = OPERAND_VALUE; \
+ build_java_ret (find_local_variable (index, ptr_type_node, oldpc)); \
+ }
+
+#define JSR(OPERAND_TYPE, OPERAND_VALUE) \
+ { \
+ tree where = lookup_label (oldpc+OPERAND_VALUE); \
+ tree ret = lookup_label (PC); \
+ build_java_jsr (where, ret); \
+ }
+
+/* Push a constant onto the stack. */
+#define PUSHC(OPERAND_TYPE, OPERAND_VALUE) \
+ { int saw_index = 0; int ival = (OPERAND_VALUE); \
+ if (saw_index) java_push_constant_from_pool (current_jcf, ival); \
+ else expand_java_pushc (ival, OPERAND_TYPE##_type_node); }
+
+/* internal macro added for use by the WIDE case */
+#define LOAD_INTERNAL(OPTYPE, OPVALUE) \
+ push_value (find_local_variable (OPVALUE, type_map[OPVALUE], oldpc));
+
+/* Push local variable onto the opcode stack. */
+#define LOAD(OPERAND_TYPE, OPERAND_VALUE) \
+ { \
+ /* have to do this since OPERAND_VALUE may have side-effects */ \
+ int opvalue = OPERAND_VALUE; \
+ LOAD_INTERNAL(OPERAND_TYPE##_type_node, opvalue); \
+ }
+
+#define RETURN(OPERAND_TYPE, OPERAND_VALUE) \
+ expand_java_return (OPERAND_TYPE##_type_node)
+
+#define REM_EXPR TRUNC_MOD_EXPR
+#define BINOP(OPERAND_TYPE, OPERAND_VALUE) \
+ expand_java_binop (OPERAND_TYPE##_type_node, OPERAND_VALUE##_EXPR)
+
+#define FIELD(IS_STATIC, IS_PUT) \
+ expand_java_field_op (IS_STATIC, IS_PUT, IMMEDIATE_u2)
+
+#define TEST(OPERAND_TYPE, CONDITION) \
+ expand_test (CONDITION##_EXPR, OPERAND_TYPE##_type_node, oldpc+IMMEDIATE_s2)
+
+#define COND(OPERAND_TYPE, CONDITION) \
+ expand_cond (CONDITION##_EXPR, OPERAND_TYPE##_type_node, oldpc+IMMEDIATE_s2)
+
+#define BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
+ BRANCH_##OPERAND_TYPE (OPERAND_VALUE)
+
+#define BRANCH_GOTO(OPERAND_VALUE) \
+ expand_java_goto (oldpc + OPERAND_VALUE)
+
+#define BRANCH_CALL(OPERAND_VALUE) \
+ expand_java_call (oldpc + OPERAND_VALUE, oldpc)
+
+#if 0
+#define BRANCH_RETURN(OPERAND_VALUE) \
+ { \
+ tree type = OPERAND_TYPE##_type_node; \
+ tree value = find_local_variable (OPERAND_VALUE, type, oldpc); \
+ expand_java_ret (value); \
+ }
+#endif
+
+#define NOT_IMPL(OPERAND_TYPE, OPERAND_VALUE) \
+ fprintf (stderr, "%3d: %s ", oldpc, opname); \
+ fprintf (stderr, "(not implemented)\n")
+#define NOT_IMPL1(OPERAND_VALUE) \
+ fprintf (stderr, "%3d: %s ", oldpc, opname); \
+ fprintf (stderr, "(not implemented)\n")
+
+#define BRANCH_RETURN(OPERAND_VALUE) NOT_IMPL1(OPERAND_VALUE)
+
+#define STACK(SUBOP, COUNT) STACK_##SUBOP (COUNT)
+
+#define STACK_POP(COUNT) java_stack_pop (COUNT)
+
+#define STACK_SWAP(COUNT) java_stack_swap()
+
+#define STACK_DUP(COUNT) java_stack_dup (COUNT, 0)
+#define STACK_DUPx1(COUNT) java_stack_dup (COUNT, 1)
+#define STACK_DUPx2(COUNT) java_stack_dup (COUNT, 2)
+
+#define SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
+ PC = (PC + 3) / 4 * 4; TABLE_OR_LOOKUP##_SWITCH
+
+#define LOOKUP_SWITCH \
+ { jint default_offset = IMMEDIATE_s4; jint npairs = IMMEDIATE_s4; \
+ tree selector = pop_value (INT_type_node); \
+ tree duplicate, label; \
+ tree type = TREE_TYPE (selector); \
+ flush_quick_stack (); \
+ expand_start_case (0, selector, type, "switch statement");\
+ push_momentary (); \
+ while (--npairs >= 0) \
+ { \
+ jint match = IMMEDIATE_s4; jint offset = IMMEDIATE_s4; \
+ tree value = build_int_2 (match, match < 0 ? -1 : 0); \
+ TREE_TYPE (value) = type; \
+ label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
+ pushcase (value, convert, label, &duplicate); \
+ expand_java_goto (oldpc + offset); \
+ } \
+ label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
+ pushcase (NULL_TREE, 0, label, &duplicate); \
+ expand_java_goto (oldpc + default_offset); \
+ pop_momentary (); \
+ expand_end_case (selector); \
+ }
+
+#define TABLE_SWITCH \
+ { jint default_offset = IMMEDIATE_s4; \
+ jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4; \
+ tree selector = pop_value (INT_type_node); \
+ tree duplicate, label; \
+ tree type = TREE_TYPE (selector); \
+ flush_quick_stack (); \
+ expand_start_case (0, selector, type, "switch statement");\
+ push_momentary (); \
+ for (; low <= high; low++) \
+ { \
+ jint offset = IMMEDIATE_s4; \
+ tree value = build_int_2 (low, low < 0 ? -1 : 0); \
+ TREE_TYPE (value) = type; \
+ label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
+ pushcase (value, convert, label, &duplicate); \
+ expand_java_goto (oldpc + offset); \
+ } \
+ label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); \
+ pushcase (NULL_TREE, 0, label, &duplicate); \
+ expand_java_goto (oldpc + default_offset); \
+ pop_momentary (); \
+ expand_end_case (selector); \
+ }
+
+#define INVOKE(MAYBE_STATIC, IS_INTERFACE) \
+ { int opcode = byte_ops[PC-1]; \
+ int method_ref_index = IMMEDIATE_u2; \
+ int nargs; \
+ if (IS_INTERFACE) { nargs = IMMEDIATE_u1; (void) IMMEDIATE_u1; } \
+ else nargs = -1; \
+ expand_invoke (opcode, method_ref_index, nargs); \
+ }
+
+/* Handle new, checkcast, instanceof */
+#define OBJECT(TYPE, OP) \
+ expand_java_##OP (get_class_constant (current_jcf, IMMEDIATE_u2))
+
+#define ARRAY(OPERAND_TYPE, SUBOP) ARRAY_##SUBOP(OPERAND_TYPE)
+
+#define ARRAY_LOAD(OPERAND_TYPE) \
+ { \
+ expand_java_arrayload( OPERAND_TYPE##_type_node ); \
+ }
+
+#define ARRAY_STORE(OPERAND_TYPE) \
+ { \
+ expand_java_arraystore( OPERAND_TYPE##_type_node ); \
+ }
+
+#define ARRAY_LENGTH(OPERAND_TYPE) expand_java_array_length();
+#define ARRAY_NEW(OPERAND_TYPE) ARRAY_NEW_##OPERAND_TYPE()
+#define ARRAY_NEW_PTR() \
+ push_value (build_anewarray (get_class_constant (current_jcf, \
+ IMMEDIATE_u2), \
+ pop_value (int_type_node)));
+#define ARRAY_NEW_NUM() \
+ { \
+ int atype = IMMEDIATE_u1; \
+ push_value (build_newarray (atype, pop_value (int_type_node)));\
+ }
+#define ARRAY_NEW_MULTI() \
+ { \
+ tree class = get_class_constant (current_jcf, IMMEDIATE_u2 ); \
+ int ndims = IMMEDIATE_u1; \
+ expand_java_multianewarray( class, ndims ); \
+ }
+
+#define UNOP(OPERAND_TYPE, OPERAND_VALUE) \
+ push_value (fold (build1 (NEGATE_EXPR, OPERAND_TYPE##_type_node, \
+ pop_value (OPERAND_TYPE##_type_node))));
+
+#define CONVERT2(FROM_TYPE, TO_TYPE) \
+ { \
+ push_value (build1 (NOP_EXPR, int_type_node, \
+ (convert (TO_TYPE##_type_node, \
+ pop_value (FROM_TYPE##_type_node))))); \
+ }
+
+#define CONVERT(FROM_TYPE, TO_TYPE) \
+ { \
+ push_value (convert (TO_TYPE##_type_node, \
+ pop_value (FROM_TYPE##_type_node))); \
+ }
+
+/* internal macro added for use by the WIDE case
+ Added TREE_TYPE (decl) assignment, apbianco */
+#define STORE_INTERNAL(OPTYPE, OPVALUE) \
+ { \
+ tree decl, value; \
+ int var = OPVALUE; \
+ tree type = OPTYPE; \
+ value = pop_value (type); \
+ type = TREE_TYPE (value); \
+ decl = find_local_variable (var, type, oldpc); \
+ set_local_type (var, type ); \
+ expand_assignment (decl, value, 0, 0); \
+ }
+
+#define STORE(OPERAND_TYPE, OPERAND_VALUE) \
+ { \
+ /* have to do this since OPERAND_VALUE may have side-effects */ \
+ int opvalue = OPERAND_VALUE; \
+ STORE_INTERNAL(OPERAND_TYPE##_type_node, opvalue); \
+ }
+
+#define SPECIAL(OPERAND_TYPE, INSTRUCTION) \
+ SPECIAL_##INSTRUCTION(OPERAND_TYPE)
+
+#define SPECIAL_ENTER(IGNORED) MONITOR_OPERATION (soft_monitorenter_node)
+#define SPECIAL_EXIT(IGNORED) MONITOR_OPERATION (soft_monitorexit_node)
+
+#define MONITOR_OPERATION(call) \
+ { \
+ tree o = pop_value (ptr_type_node); \
+ tree c; \
+ flush_quick_stack (); \
+ c = build_java_monitor (call, o); \
+ TREE_SIDE_EFFECTS (c) = 1; \
+ expand_expr_stmt (c); \
+ }
+
+#define SPECIAL_IINC(IGNORED) \
+ { \
+ unsigned int local_var_index = IMMEDIATE_u1; \
+ int ival = IMMEDIATE_s1; \
+ expand_iinc(local_var_index, ival, oldpc); \
+ }
+
+#define SPECIAL_WIDE(IGNORED) \
+ { \
+ int modified_opcode = IMMEDIATE_u1; \
+ unsigned int local_var_index = IMMEDIATE_u2; \
+ switch (modified_opcode) \
+ { \
+ case OPCODE_iinc: \
+ { \
+ int ival = IMMEDIATE_s2; \
+ expand_iinc (local_var_index, ival, oldpc); \
+ break; \
+ } \
+ case OPCODE_iload: \
+ case OPCODE_lload: \
+ case OPCODE_fload: \
+ case OPCODE_dload: \
+ case OPCODE_aload: \
+ { \
+ /* duplicate code from LOAD macro */ \
+ LOAD_INTERNAL(operand_type[modified_opcode], local_var_index); \
+ break; \
+ } \
+ case OPCODE_istore: \
+ case OPCODE_lstore: \
+ case OPCODE_fstore: \
+ case OPCODE_dstore: \
+ case OPCODE_astore: \
+ { \
+ STORE_INTERNAL(operand_type[modified_opcode], local_var_index); \
+ break; \
+ } \
+ default: \
+ error ("unrecogized wide sub-instruction"); \
+ } \
+ }
+
+#define SPECIAL_THROW(IGNORED) \
+ build_java_athrow (pop_value (throwable_type_node))
+
+#define SPECIAL_BREAK NOT_IMPL1
+#define IMPL NOT_IMPL
+
+#include "javaop.def"
+#undef JAVAOP
+ default:
+ fprintf (stderr, "%3d: unknown(%3d)\n", oldpc, byte_ops[PC]);
+ }
+ return PC;
+}
--- /dev/null
+/* Program to write C++-suitable header files from a Java(TM) .class
+ file. This is similar to SUN's javah.
+
+Copyright (C) 1996, 1998 Free Software Foundation, Inc.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
+
+#include <stdio.h>
+#include "jcf.h"
+#ifdef __STDC__
+#include <stdlib.h>
+#endif
+#include <math.h>
+
+/* The output file. */
+FILE *out = NULL;
+
+/* Nonzero on failure. */
+static int found_error = 0;
+
+/* Directory to place resulting files in. Set by -d option. */
+char *output_directory = "";
+
+char *output_file = NULL;
+
+/* Directory to place temporary file. Set by -td option. Currently unused. */
+char *temp_directory = "/tmp";
+
+/* Number of friend functions we have to declare. */
+static int friend_count;
+
+/* A class can optionally have a `friend' function declared. If
+ non-NULL, this is that function. */
+static char **friend_specs = NULL;
+
+/* Number of lines we are prepending before the class. */
+static int prepend_count;
+
+/* We can prepend extra lines before the class's start. */
+static char **prepend_specs = NULL;
+
+/* Number of lines we are appending at the end of the class. */
+static int add_count;
+
+/* We can append extra lines just before the class's end. */
+static char **add_specs = NULL;
+
+/* Number of lines we are appending after the class. */
+static int append_count;
+
+/* We can append extra lines after the class's end. */
+static char **append_specs = NULL;
+
+int verbose = 0;
+
+int stubs = 0;
+
+struct JCF *current_jcf;
+struct JCF *main_jcf;
+
+/* This holds access information for the last field we examined. They
+ let us generate "private:", "public:", and "protected:" properly.
+ If 0 then we haven't previously examined any field. */
+static JCF_u2 last_access;
+
+#define ACC_VISIBILITY (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED)
+
+int seen_fields = 0;
+
+static void print_field_info PROTO ((FILE *, JCF*, int, int, JCF_u2));
+static void print_method_info PROTO ((FILE *, JCF*, int, int, JCF_u2));
+static void print_c_decl PROTO ((FILE*, JCF*, int, int, JCF_u2, int));
+
+JCF_u2 current_field_name;
+JCF_u2 current_field_value;
+JCF_u2 current_field_signature;
+JCF_u2 current_field_flags;
+
+#define HANDLE_START_FIELD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
+( current_field_name = (NAME), current_field_signature = (SIGNATURE), \
+ current_field_flags = (ACCESS_FLAGS), current_field_value = 0)
+
+#define HANDLE_END_FIELD() \
+ print_field_info (out, jcf, current_field_name, current_field_signature, \
+ current_field_flags);
+
+#define HANDLE_CONSTANTVALUE(VALUEINDEX) current_field_value = (VALUEINDEX)
+
+#define HANDLE_METHOD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
+ print_method_info (out, jcf, NAME, SIGNATURE, ACCESS_FLAGS)
+
+#include "jcf-reader.c"
+
+/* Some useful constants. */
+#define F_NAN_MASK 0x7f800000
+#define D_NAN_MASK 0x7ff0000000000000LL
+
+/* Return 1 if F is not Inf or NaN. */
+static int
+java_float_finite (f)
+ jfloat f;
+{
+ int32 *ip = (int32 *) &f;
+
+ /* We happen to know that F_NAN_MASK will match all NaN values, and
+ also positive and negative infinity. That's why we only need one
+ test here. See The Java Language Specification, section 20.9. */
+ return (*ip & F_NAN_MASK) != F_NAN_MASK;
+}
+
+/* Return 1 if D is not Inf or NaN. */
+static int
+java_double_finite (d)
+ jdouble d;
+{
+ int64 *ip = (int64 *) &d;
+
+ /* Now check for all NaNs. */
+ return (*ip & D_NAN_MASK) != D_NAN_MASK;
+}
+
+void
+DEFUN(print_name, (stream, jcf, name_index),
+ FILE* stream AND JCF* jcf AND int name_index)
+{
+ if (JPOOL_TAG (jcf, name_index) != CONSTANT_Utf8)
+ fprintf (stream, "<not a UTF8 constant>");
+ else
+ jcf_print_utf8 (stream, JPOOL_UTF_DATA (jcf, name_index),
+ JPOOL_UTF_LENGTH (jcf, name_index));
+}
+
+/* Print base name of class. The base name is everything after the
+ final separator. */
+
+static void
+print_base_classname (stream, jcf, index)
+ FILE *stream;
+ JCF *jcf;
+ int index;
+{
+ int name_index = JPOOL_USHORT1 (jcf, index);
+ int i, len;
+ unsigned char *s, *p, *limit;
+
+ s = JPOOL_UTF_DATA (jcf, name_index);
+ len = JPOOL_UTF_LENGTH (jcf, name_index);
+ limit = s + len;
+ p = s;
+ while (s < limit)
+ {
+ int c = UTF8_GET (s, limit);
+ if (c == '/')
+ p = s;
+ }
+
+ while (p < limit)
+ {
+ int ch = UTF8_GET (p, limit);
+ if (ch == '/')
+ fputs ("::", stream);
+ else
+ jcf_print_char (stream, ch);
+ }
+}
+
+/* Return 0 if NAME is equal to STR, nonzero otherwise. */
+
+static int
+utf8_cmp (str, length, name)
+ unsigned char *str;
+ int length;
+ char *name;
+{
+ unsigned char *limit = str + length;
+ int i;
+
+ for (i = 0; name[i]; ++i)
+ {
+ int ch = UTF8_GET (str, limit);
+ if (ch != name[i])
+ return 1;
+ }
+
+ return str != limit;
+}
+
+/* Generate an access control keyword based on FLAGS. Returns 0 if
+ FLAGS matches the saved access information, nonzero otherwise. */
+
+static void
+generate_access (stream, flags)
+ FILE *stream;
+ JCF_u2 flags;
+{
+ /* FIXME: Java's "protected" and "no access specifier" modes don't
+ actually map to C++ "protected". That's how we map them for now,
+ though. */
+
+ if (! (flags & ACC_VISIBILITY))
+ flags = ACC_PROTECTED;
+
+ if ((flags & ACC_VISIBILITY) == last_access)
+ return;
+ last_access = (flags & ACC_VISIBILITY);
+
+ switch (last_access)
+ {
+ case ACC_PUBLIC:
+ fputs ("public:\n", stream);
+ break;
+ case ACC_PRIVATE:
+ fputs ("private:\n", stream);
+ break;
+ case ACC_PROTECTED:
+ fputs ("protected:\n", stream);
+ break;
+ default:
+ found_error = 1;
+ fprintf (stream, "#error unrecognized visibility %d\n",
+ (flags & ACC_VISIBILITY));
+ break;
+ }
+}
+
+static void
+DEFUN(print_field_info, (stream, jcf, name_index, sig_index, flags),
+ FILE *stream AND JCF* jcf
+ AND int name_index AND int sig_index AND JCF_u2 flags)
+{
+ if (flags & ACC_FINAL)
+ {
+ if (current_field_value > 0)
+ {
+ jlong num;
+ char buffer[25];
+
+ generate_access (stream, flags);
+ switch (JPOOL_TAG (jcf, current_field_value))
+ {
+ case CONSTANT_Integer:
+ fputs (" static const jint ", out);
+ print_name (out, jcf, name_index);
+ fputs (" = ", out);
+ num = JPOOL_INT (jcf, current_field_value);
+ format_int (buffer, num, 10);
+ fprintf (out, "%sL;\n", buffer);
+ break;
+ case CONSTANT_Long:
+ fputs (" static const jlong ", out);
+ print_name (out, jcf, name_index);
+ fputs (" = ", out);
+ num = JPOOL_LONG (jcf, current_field_value);
+ format_int (buffer, num, 10);
+ fprintf (out, "%sLL;\n", buffer);
+ break;
+ case CONSTANT_Float:
+ {
+ jfloat fnum = JPOOL_FLOAT (jcf, current_field_value);
+ fputs (" static const jfloat ", out);
+ print_name (out, jcf, name_index);
+ if (! java_float_finite (fnum))
+ fputs (";\n", out);
+ else
+ fprintf (out, " = %.10g;\n", fnum);
+ }
+ break;
+ case CONSTANT_Double:
+ {
+ jdouble dnum = JPOOL_DOUBLE (jcf, current_field_value);
+ fputs (" static const jdouble ", out);
+ print_name (out, jcf, name_index);
+ if (! java_double_finite (dnum))
+ fputs (";\n", out);
+ else
+ fprintf (out, " = %.17g;\n", dnum);
+ }
+ break;
+ default:
+ fprintf(out, " <<inappropriate constant type>>\n");
+ }
+
+ return;
+ }
+ }
+
+ generate_access (stream, flags);
+ fputs (" ", out);
+ if (flags & ACC_STATIC)
+ fputs ("static ", out);
+ print_c_decl (out, jcf, name_index, sig_index, flags, 0);
+ fputs (";\n", out);
+ if (! (flags & ACC_STATIC))
+ seen_fields++;
+}
+
+static void
+DEFUN(print_method_info, (stream, jcf, name_index, sig_index, flags),
+ FILE *stream AND JCF* jcf
+ AND int name_index AND int sig_index AND JCF_u2 flags)
+{
+ unsigned char *str;
+ int length, is_init = 0;
+
+ if (JPOOL_TAG (jcf, name_index) != CONSTANT_Utf8)
+ fprintf (stream, "<not a UTF8 constant>");
+ str = JPOOL_UTF_DATA (jcf, name_index);
+ length = JPOOL_UTF_LENGTH (jcf, name_index);
+ if (str[0] == '<')
+ {
+ /* Ignore internally generated methods like <clinit>. However,
+ treat <init> as a constructor. */
+ if (! utf8_cmp (str, length, "<init>"))
+ is_init = 1;
+ else
+ return;
+ }
+
+ /* We can't generate a method whose name is a C++ reserved word.
+ For now the only problem has been `delete'; add more here as
+ required. FIXME: we need a better solution than just ignoring
+ the method. */
+ if (! utf8_cmp (str, length, "delete"))
+ return;
+
+ generate_access (stream, flags);
+
+ fputs (" ", out);
+ if ((flags & ACC_STATIC))
+ fputs ("static ", out);
+ else if (! (flags & ACC_FINAL) && ! (jcf->access_flags & ACC_FINAL))
+ {
+ /* Don't print `virtual' if we have a constructor. */
+ if (! is_init)
+ fputs ("virtual ", out);
+ }
+ print_c_decl (out, jcf, name_index, sig_index, flags, is_init);
+
+ /* FIXME: it would be nice to decompile small methods here. That
+ would allow for inlining. */
+
+ fprintf(out, ";\n");
+}
+
+static void
+DEFUN(print_c_decl, (stream, jcf, name_index, signature_index, flags, is_init),
+ FILE* stream AND JCF* jcf
+ AND int name_index AND int signature_index AND JCF_u2 flags
+ AND int is_init)
+{
+ if (JPOOL_TAG (jcf, signature_index) != CONSTANT_Utf8)
+ fprintf (stream, "<not a UTF8 constant>");
+ else
+ {
+ int length = JPOOL_UTF_LENGTH (jcf, signature_index);
+ unsigned char *str0 = JPOOL_UTF_DATA (jcf, signature_index);
+ register unsigned char *str = str0;
+ unsigned char *limit = str + length;
+ int j;
+ char *ctype;
+ int need_space = 0;
+ int is_method = str[0] == '(';
+
+ if (is_method)
+ {
+ /* Skip to the return signature, and print that first.
+ However, don't do this is we are printing a construtcor.
+ */
+ if (is_init)
+ {
+ str = str0 + 1;
+ /* FIXME: Most programmers love Celtic knots because
+ they see their own code in the interconnected loops.
+ That is, this is spaghetti. */
+ goto have_constructor;
+ }
+ else
+ {
+ while (str < limit)
+ {
+ int ch = *str++;
+ if (ch == ')')
+ break;
+ }
+ }
+ }
+
+ again:
+ while (str < limit)
+ {
+ switch (str[0])
+ {
+ case '[':
+ for (str++; str < limit && *str >= '0' && *str <= '9'; str++)
+ ;
+ switch (*str)
+ {
+ case 'B': ctype = "jbyteArray"; goto printit;
+ case 'C': ctype = "jcharArray"; goto printit;
+ case 'D': ctype = "jdoubleArray"; goto printit;
+ case 'F': ctype = "jfloatArray"; goto printit;
+ case 'I': ctype = "jintArray"; goto printit;
+ case 'S': ctype = "jshortArray"; goto printit;
+ case 'J': ctype = "jlongArray"; goto printit;
+ case 'Z': ctype = "jbooleanArray"; goto printit;
+ case '[': ctype = "jobjectArray"; goto printit;
+ case 'L':
+ /* We have to generate a reference to JArray here,
+ so that our output matches what the compiler
+ does. */
+ ++str;
+ fputs ("JArray<", out);
+ while (str < limit && *str != ';')
+ {
+ int ch = UTF8_GET (str, limit);
+ if (ch == '/')
+ fputs ("::", stream);
+ else
+ jcf_print_char (stream, ch);
+ }
+ fputs (" *> *", out);
+ need_space = 0;
+ ++str;
+ break;
+ default:
+ fprintf (stderr, "unparseable signature `%s'\n", str0);
+ found_error = 1;
+ ctype = "???"; goto printit;
+ }
+ break;
+ case '(':
+ fputc (*str++, stream);
+ continue;
+ case ')':
+ fputc (*str++, stream);
+ /* the return signature was printed in the first pass. */
+ return;
+ case 'B': ctype = "jbyte"; goto printit;
+ case 'C': ctype = "jchar"; goto printit;
+ case 'D': ctype = "jdouble"; goto printit;
+ case 'F': ctype = "jfloat"; goto printit;
+ case 'I': ctype = "jint"; goto printit;
+ case 'J': ctype = "jlong"; goto printit;
+ case 'S': ctype = "jshort"; goto printit;
+ case 'Z': ctype = "jboolean"; goto printit;
+ case 'V': ctype = "void"; goto printit;
+ case 'L':
+ ++str;
+ while (*str && *str != ';')
+ {
+ int ch = UTF8_GET (str, limit);
+ if (ch == '/')
+ fputs ("::", stream);
+ else
+ jcf_print_char (stream, ch);
+ }
+ fputs (" *", stream);
+ if (*str == ';')
+ str++;
+ need_space = 0;
+ break;
+ default:
+ need_space = 1;
+ jcf_print_char (stream, *str++);
+ break;
+ printit:
+ str++;
+ need_space = 1;
+ fputs (ctype, stream);
+ break;
+ }
+
+ if (is_method && str < limit && *str != ')')
+ fputs (", ", stream);
+ }
+ have_constructor:
+ if (name_index)
+ {
+ if (need_space)
+ fprintf (stream, " ");
+ /* Declare constructors specially. */
+ if (is_init)
+ print_base_classname (stream, jcf, jcf->this_class);
+ else
+ print_name (stream, jcf, name_index);
+ }
+ if (is_method)
+ {
+ fputs (" (", stream);
+ /* Go to beginning, skipping '('. */
+ str = str0 + 1;
+ goto again; /* To handle argument signatures. */
+ }
+ }
+}
+
+int
+DEFUN(print_mangled_classname, (stream, jcf, prefix, index),
+ FILE *stream AND JCF *jcf AND char *prefix AND int index)
+{
+ int name_index = JPOOL_USHORT1 (jcf, index);
+ fputs (prefix, stream);
+ jcf_print_utf8_replace (out,
+ JPOOL_UTF_DATA (jcf, name_index),
+ JPOOL_UTF_LENGTH (jcf, name_index),
+ '/', '_');
+}
+
+/* Print PREFIX, then a class name in C++ format. If the name refers
+ to an array, ignore it and don't print PREFIX. Returns 1 if
+ something was printed, 0 otherwise. */
+static int
+print_cxx_classname (stream, prefix, jcf, index)
+ FILE *stream;
+ char *prefix;
+ JCF *jcf;
+ int index;
+{
+ int name_index = JPOOL_USHORT1 (jcf, index);
+ int i, len, c;
+ unsigned char *s, *p, *limit;
+
+ s = JPOOL_UTF_DATA (jcf, name_index);
+ len = JPOOL_UTF_LENGTH (jcf, name_index);
+ limit = s + len;
+
+ /* Explicitly omit arrays here. */
+ p = s;
+ c = UTF8_GET (p, limit);
+ if (c == '[')
+ return 0;
+
+ fputs (prefix, stream);
+ while (s < limit)
+ {
+ c = UTF8_GET (s, limit);
+ if (c == '/')
+ fputs ("::", stream);
+ else
+ jcf_print_char (stream, c);
+ }
+
+ return 1;
+}
+
+int written_class_count = 0;
+
+/* Return name of superclass. If LEN is not NULL, fill it with length
+ of name. */
+static unsigned char *
+super_class_name (derived_jcf, len)
+ JCF *derived_jcf;
+ int *len;
+{
+ int supername_index = JPOOL_USHORT1 (derived_jcf, derived_jcf->super_class);
+ int supername_length = JPOOL_UTF_LENGTH (derived_jcf, supername_index);
+ unsigned char *supername = JPOOL_UTF_DATA (derived_jcf, supername_index);
+
+ if (len)
+ *len = supername_length;
+
+ return supername;
+}
+
+/* Print declarations for all classes required by this class. FIXME:
+ the current implementation just prints every class name from the
+ constant pool. This is too much. We really only need to print a
+ declaration for each class which is the type of a return value, a
+ field, or an argument. */
+static void
+print_class_decls (out, jcf)
+ FILE *out;
+ JCF *jcf;
+{
+ int i, seen_one = 0;
+
+ for (i = 1; i < JPOOL_SIZE (jcf); ++i)
+ {
+ int kind = JPOOL_TAG (jcf, i);
+ if (kind == CONSTANT_Class)
+ {
+ if (print_cxx_classname (out, "class ", jcf, i))
+ fputs (";\n", out);
+ seen_one = 1;
+ }
+ }
+
+ if (seen_one)
+ fputs ("\n", out);
+}
+
+static void
+DEFUN(process_file, (file, out),
+ JCF *jcf AND FILE *out)
+{
+ int code, i;
+
+ current_jcf = main_jcf = jcf;
+
+ last_access = 0;
+
+ if (jcf_parse_preamble (jcf) != 0)
+ {
+ fprintf (stderr, "Not a valid Java .class file.\n");
+ found_error = 1;
+ return;
+ }
+
+ /* Parse and possibly print constant pool */
+ code = jcf_parse_constant_pool (jcf);
+ if (code != 0)
+ {
+ fprintf (stderr, "error while parsing constant pool\n");
+ found_error = 1;
+ return;
+ }
+ code = verify_constant_pool (jcf);
+ if (code > 0)
+ {
+ fprintf (stderr, "error in constant pool entry #%d\n", code);
+ found_error = 1;
+ return;
+ }
+
+ jcf_parse_class (jcf);
+
+ if (written_class_count++ == 0)
+ fputs ("// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-\n\n",
+ out);
+
+ print_mangled_classname (out, jcf, "#ifndef __", jcf->this_class);
+ fprintf (out, "__\n");
+
+ print_mangled_classname (out, jcf, "#define __", jcf->this_class);
+ fprintf (out, "__\n\n");
+
+ if (jcf->super_class)
+ {
+ int super_length;
+ unsigned char *supername = super_class_name (jcf, &super_length);
+
+ fputs ("#include <", out);
+ jcf_print_utf8 (out, supername, super_length);
+ fputs (".h>\n", out);
+
+ /* FIXME: If our superclass is Object, then we include
+ java-array.h. The right thing to do here is look at all the
+ methods and fields and see if an array is in use. Only then
+ would we need to include java-array.h. */
+ if (! utf8_cmp (supername, super_length, "java/lang/Object"))
+ fputs ("#include <java-array.h>\n", out);
+
+ fputs ("\n", out);
+ }
+
+ print_class_decls (out, jcf);
+
+ for (i = 0; i < prepend_count; ++i)
+ fprintf (out, "%s\n", prepend_specs[i]);
+ if (prepend_count > 0)
+ fputc ('\n', out);
+
+ if (! print_cxx_classname (out, "class ", jcf, jcf->this_class))
+ {
+ fprintf (stderr, "class is of array type\n");
+ found_error = 1;
+ return;
+ }
+ if (jcf->super_class)
+ {
+ if (! print_cxx_classname (out, " : public ", jcf, jcf->super_class))
+ {
+ fprintf (stderr, "base class is of array type\n");
+ found_error = 1;
+ return;
+ }
+ }
+ fputs ("\n{\n", out);
+
+ /* We make a single pass over the file, printing methods and fields
+ as we see them. We have to list the methods in the same order
+ that they appear in the class file, so that the Java and C++
+ vtables have the same layout. */
+ jcf_parse_fields (jcf);
+ jcf_parse_methods (jcf);
+ jcf_parse_final_attributes (jcf);
+
+ /* Generate friend decl if we still must. */
+ for (i = 0; i < friend_count; ++i)
+ fprintf (out, " friend %s\n", friend_specs[i]);
+
+ /* Generate extra declarations. */
+ if (add_count > 0)
+ fputc ('\n', out);
+ for (i = 0; i < add_count; ++i)
+ fprintf (out, " %s\n", add_specs[i]);
+
+ fputs ("};\n", out);
+
+ if (append_count > 0)
+ fputc ('\n', out);
+ for (i = 0; i < append_count; ++i)
+ fprintf (out, "%s\n", append_specs[i]);
+
+ print_mangled_classname (out, jcf, "\n#endif /* __", jcf->this_class);
+ fprintf (out, "__ */\n");
+}
+
+static void
+usage ()
+{
+ fprintf (stderr, "gjavah: no classes specified\n");
+ exit (1);
+}
+
+static void
+help ()
+{
+ printf ("Usage: gjavah [OPTION]... CLASS...\n\n");
+ printf ("Generate C++ header files from .class files\n\n");
+ printf (" --classpath PATH Set path to find .class files\n");
+ printf (" -d DIRECTORY Set output directory name\n");
+ printf (" --help Print this help, then exit\n");
+ printf (" -o FILE Set output file name\n");
+ printf (" -td DIRECTORY Set temporary directory name\n");
+ printf (" -v, --verbose Print extra information while running\n");
+ printf (" --version Print version number, then exit\n");
+ /* FIXME: print bug-report information. */
+ exit (0);
+}
+
+static void
+no_argument (opt)
+ char *opt;
+{
+ fprintf (stderr, "gjavah: no argument given for option `%s'\n", opt);
+ exit (1);
+}
+
+static void
+version ()
+{
+ /* FIXME: use version.c? */
+ printf ("gjavah (GNU gcc) 0.0\n\n");
+ printf ("Copyright (C) 1998 Free Software Foundation, Inc.\n");
+ printf ("This is free software; see the source for copying conditions. There is NO\n");
+ printf ("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
+ exit (0);
+}
+
+int
+DEFUN(main, (argc, argv),
+ int argc AND char** argv)
+{
+ JCF jcf;
+ int argi;
+
+ if (argc <= 1)
+ usage ();
+
+ for (argi = 1; argi < argc; argi++)
+ {
+ char *arg = argv[argi];
+
+ if (arg[0] != '-' || ! strcmp (arg, "--"))
+ break;
+
+ /* Just let all arguments be given in either "-" or "--" form. */
+ if (arg[1] == '-')
+ ++arg;
+
+ if (strcmp (arg, "-o") == 0)
+ {
+ if (argi + 1 < argc)
+ output_file = argv[++argi];
+ else
+ no_argument (argv[argi]);
+ }
+ else if (strcmp (arg, "-d") == 0)
+ {
+ if (argi + 1 < argc)
+ output_directory = argv[++argi];
+ else
+ no_argument (argv[argi]);
+ }
+ else if (strcmp (arg, "-td") == 0)
+ {
+ if (argi + 1 < argc)
+ temp_directory = argv[++argi];
+ else
+ no_argument (argv[argi]);
+ }
+ else if (strcmp (arg, "-prepend") == 0)
+ {
+ if (argi + 1 < argc)
+ {
+ if (prepend_count == 0)
+ prepend_specs = (char**) ALLOC ((argc-argi) * sizeof (char*));
+ prepend_specs[prepend_count++] = argv[++argi];
+ }
+ else
+ no_argument (argv[argi]);
+ }
+ else if (strcmp (arg, "-friend") == 0)
+ {
+ if (argi + 1 < argc)
+ {
+ if (friend_count == 0)
+ friend_specs = (char**) ALLOC ((argc-argi) * sizeof (char*));
+ friend_specs[friend_count++] = argv[++argi];
+ }
+ else
+ no_argument (argv[argi]);
+ }
+ else if (strcmp (arg, "-add") == 0)
+ {
+ if (argi + 1 < argc)
+ {
+ if (add_count == 0)
+ add_specs = (char**) ALLOC ((argc-argi) * sizeof (char*));
+ add_specs[add_count++] = argv[++argi];
+ }
+ else
+ no_argument (argv[argi]);
+ }
+ else if (strcmp (arg, "-append") == 0)
+ {
+ if (argi + 1 < argc)
+ {
+ if (append_count == 0)
+ append_specs = (char**) ALLOC ((argc-argi) * sizeof (char*));
+ append_specs[append_count++] = argv[++argi];
+ }
+ else
+ no_argument (argv[argi]);
+ }
+ else if (strcmp (arg, "-classpath") == 0)
+ {
+ if (argi + 1 < argc)
+ classpath = argv[++argi];
+ else
+ no_argument (argv[argi]);
+ }
+ else if (strcmp (arg, "-verbose") == 0 || strcmp (arg, "-v") == 0)
+ verbose++;
+ else if (strcmp (arg, "-stubs") == 0)
+ stubs++;
+ else if (strcmp (arg, "-help") == 0)
+ help ();
+ else if (strcmp (arg, "-version") == 0)
+ version ();
+ else
+ {
+ fprintf (stderr, "%s: illegal argument\n", argv[argi]);
+ exit (1);
+ }
+ }
+
+ if (argi == argc)
+ usage ();
+
+ if (classpath == NULL)
+ {
+ classpath = (char *) getenv ("CLASSPATH");
+ if (classpath == NULL)
+ classpath = "";
+ }
+
+ for (; argi < argc; argi++)
+ {
+ char *classname = argv[argi];
+ char *classfile_name, *current_output_file;
+
+ if (verbose)
+ fprintf (stderr, "Processing %s\n", classname);
+ classfile_name = find_class (classname, strlen (classname), &jcf, 1);
+ if (classfile_name == NULL)
+ {
+ fprintf (stderr, "%s: no such class\n", classname);
+ exit (1);
+ }
+ if (verbose)
+ fprintf (stderr, "Found in %s\n", classfile_name);
+ if (output_file)
+ {
+ if (strcmp (output_file, "-") == 0)
+ out = stdout;
+ else if (out == NULL)
+ out = fopen (output_file, "w");
+ if (out == NULL)
+ {
+ perror (output_file);
+ exit (1);
+ }
+ current_output_file = output_file;
+ }
+ else
+ {
+ int dir_len = strlen (output_directory);
+ int i, classname_length = strlen (classname);
+ current_output_file = (char*) ALLOC (dir_len + classname_length + 4);
+ strcpy (current_output_file, output_directory);
+ if (dir_len > 0 && output_directory[dir_len-1] != '/')
+ current_output_file[dir_len++] = '/';
+ for (i = 0; classname[i] != '\0'; i++)
+ {
+ char ch = classname[i];
+ if (ch == '.')
+ ch = '/';
+ current_output_file[dir_len++] = ch;
+ }
+ strcpy (current_output_file+dir_len, ".h");
+ out = fopen (current_output_file, "w");
+ if (out == NULL)
+ {
+ perror (current_output_file);
+ exit (1);
+ }
+ }
+ process_file (&jcf, out);
+ JCF_FINISH (&jcf);
+ if (current_output_file != output_file)
+ free (current_output_file);
+ }
+
+ if (out != NULL && out != stdout)
+ fclose (out);
+
+ return found_error;
+}
+
+/* TODO:
+
+ * Do whatever the javah -stubs flag does.
+
+ * Emit "structure forward declarations" when needed.
+
+ * Generate C headers, like javah
+
+ */
--- /dev/null
+/* Definitions for exception handling for use by the GNU compiler
+ for the Java(TM) language compiler.
+ Copyright (C) 1997 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+struct eh_range
+ {
+ /* The (byte-code PC) range of the handled block. */
+ int start_pc;
+ int end_pc;
+
+ /* A list of handlers. For each element in the list,
+ the TREE_PURPOSE is the handled class (NULL_EXPR for a finally block),
+ and the TREE_VALUE is the LABEL_DECL of the handler. */
+ tree handlers;
+
+ /* Surrunding handler, if any. */
+ struct eh_range *outer;
+
+ /* The first child range. It is is nested inside this range
+ (i.e. this.start_pc <= first_child.end_pc
+ && this.end_pc >= first_child.end_pc).
+ The children are linked together using next_sibling, and are sorted
+ by increasing start_pc and end_pc (we do not support non-nested
+ overlapping ranges). */
+ struct eh_range *first_child;
+
+ /* The next child of outer, in address order. */
+ struct eh_range *next_sibling;
+
+#if 0
+ /* Next handler, sorted by ascending start_pc then descending end_pc. */
+ tree next;
+#endif
+ };
+
+/* A dummy range that represents the entire method. */
+extern struct eh_range whole_range;
+
+#define NULL_EH_RANGE (&whole_range)
+
+extern struct eh_range * find_handler PROTO ((int));
+
+extern void method_init_exceptions PROTO ((void));
+
+extern void emit_handlers PROTO ((void));
+
--- /dev/null
+enum java_opcode {
+#define JAVAOP(NAME, CODE, KIND, TYPE, VALUE) OPCODE_##NAME = CODE,
+#include "javaop.def"
+#undef JAVAOP
+};
--- /dev/null
+/* Shift right, logical. */
+
+DEFTREECODE (URSHIFT_EXPR, "urshift_expr", "2", 2)
+
+/* Return -1, 0, 1 depending on whether the first argument is
+ less, equal, or greater to the second argument. */
+DEFTREECODE (COMPARE_EXPR, "compare_expr", "2", 2)
+
+/* Same as COMPARE_EXPR, but if either value is NaN, the result is -1. */
+DEFTREECODE (COMPARE_L_EXPR, "compare_l_expr", "2", 2)
+/* Same as COMPARE_EXPR, but if either value is NaN, the result is 1. */
+DEFTREECODE (COMPARE_G_EXPR, "compare_g_expr", "2", 2)
--- /dev/null
+/* Definitions for parsing and type checking for the GNU compiler for
+ the Java(TM) language.
+ Copyright (C) 1997, 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
+
+/* Java language-specific tree codes. */
+#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) SYM,
+enum java_tree_code {
+ __DUMMY = LAST_AND_UNUSED_TREE_CODE,
+#include "java-tree.def"
+ LAST_JAVA_TREE_CODE
+};
+#undef DEFTREECODE
+
+struct JCF;
+
+/* Usage of TREE_LANG_FLAG_?:
+ 0: IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (in IDENTIFIER_NODE)
+ RESOLVE_EXPRESSION_NAME_P (in EXPR_WITH_FILE_LOCATION)
+ IS_FOR_LOOP_P (in LOOP_EXPR)
+ 1: CLASS_HAS_SUPER_FLAG (in TREE_VEC).
+ IS_A_CLASSFILE_NAME (in IDENTIFIER_NODE)
+ COMPOUND_ASSIGN_P (in EXPR (binop_*))
+ 2: RETURN_MAP_ADJUSTED (in TREE_VEC).
+ QUALIFIED_P (in IDENTIFIER_NODE)
+ PRIMARY_P (in EXPR_WITH_FILE_LOCATION)
+ MODIFY_EXPR_FROM_INITIALIZATION_P (in MODIFY_EXPR)
+ 3: IS_AN_IMPORT_ON_DEMAND_P (in IDENTIFIER_NODE)
+ RESOLVE_PACKAGE_NAME_P (in EXPR_WITH_FILE_LOCATION)
+ 4: RESOLVE_TYPE_NAME_P (in EXPR_WITH_FILE_LOCATION)
+ 5: IS_BREAK_STMT_P (in EXPR_WITH_FILE_LOCATION)
+
+ Usage of TYPE_LANG_FLAG_?:
+ 1: TYPE_ARRAY_P (in RECORD_TYPE).
+ 2: CLASS_LOADED_P (in RECORD_TYPE).
+ 3: CLASS_FROM_SOURCE_P (in RECORD_TYPE).
+ 4: CLASS_P (in RECORD_TYPE).
+
+ Usage of DECL_LANG_FLAG_?:
+ 1: METHOD_PUBLIC (in FUNCTION_DECL).
+ FIELD_PUBLIC (in FIELD_DECL).
+ CLASS_PUBLIC (in TYPE_DECL).
+ 2: METHOD_STATIC (in FUNCTION_DECL).
+ (But note that FIELD_STATIC uses TREE_STATIC!)
+ CLASS_COMPLETE_P (in TYPE_DECL)
+ 3: METHOD_FINAL (in FUNCTION_DECL)
+ FIELD_FINAL (in FIELD_DECL)
+ CLASS_FINAL (in TYPE_DECL)
+ 4: METHOD_SYNCHRONIZED (in FUNCTION_DECL).
+ LABEL_IN_SUBR (in LABEL_DECL)
+ CLASS_INTERFACE (in TYPE_DECL)
+ FIELD_VOLATILE (int FIELD_DECL)
+ 5: METHOD_ABSTRACT (in FUNCTION_DECL).
+ LABEL_IS_SUBR_START (in LABEL_DECL)
+ CLASS_ABSTRACT (in TYPE_DECL)
+ FIELD_TRANSIENT (in FIELD_DECL)
+ 6: METHOD_TRANSIENT (in FUNCTION_DECL)
+ LABEL_CHANGED (in LABEL_DECL)
+ CLASS_SUPER (in TYPE_DECL, ACC_SUPER flag)
+ INITIALIZED_P (in FIELD_DECL, VAR_DECL, PARM_DECL)
+ 7: DECL_CONSTRUCTOR_P (in FUNCTION_DECL)
+*/
+
+/* True if the class whose TYPE_BINFO this is has a superclass.
+ (True of all classes except Object.) */
+#define CLASS_HAS_SUPER_FLAG(BINFO) TREE_LANG_FLAG_1(BINFO)
+#define CLASS_HAS_SUPER(TYPE) CLASS_HAS_SUPER_FLAG (TYPE_BINFO (TYPE))
+
+/* Return the supertype of class TYPE, or NULL_TREE is it has none. */
+#define CLASSTYPE_SUPER(TYPE) (CLASS_HAS_SUPER (TYPE) ? \
+ BINFO_TYPE (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (TYPE), 0)) : NULL_TREE)
+
+/* True if the class we are compiling is a .java source file;
+ false if it is a .class bytecode file. */
+extern int compiling_from_source;
+
+/* The class defined by the actual (main) file we are compiling. */
+extern tree main_class;
+
+/* The class we are currently processing. */
+extern tree current_class;
+
+/* Nonzero if we want to automatically do array bounds checking;
+ on by default. Use -fno-bounds-check to disable. */
+
+extern int flag_bounds_check;
+
+/* Nonzero if we should make is_compiled_class always return 1 for
+ appropriate classes that we're referencing. */
+
+extern int flag_assume_compiled;
+
+extern int flag_emit_class_files;
+
+/* The Java .class file that provides main_class; the main input file. */
+extern struct JCF main_jcf[1], *current_jcf;
+
+typedef struct CPool constant_pool;
+
+#define CONSTANT_ResolvedFlag 16
+
+/* The cpool->data[i] for a ResolvedString points to a STRING_CST. */
+#define CONSTANT_ResolvedString (CONSTANT_String+CONSTANT_ResolvedFlag)
+
+/* The cpool->data[i] for a ResolvedClass points to a RECORD_TYPE. */
+#define CONSTANT_ResolvedClass (CONSTANT_Class+CONSTANT_ResolvedFlag)
+
+#define CPOOL_UTF(CPOOL, INDEX) ((tree) (CPOOL)->data[INDEX])
+
+/* A NameAndType constant is represented as a TREE_LIST.
+ The type is the signature string (as an IDENTIFIER_NODE). */
+
+#define NAME_AND_TYPE_NAME(CPOOL, IDX) \
+ CPOOL_UTF(CPOOL, CPOOL_USHORT1(CPOOL, IDX))
+#define NAME_AND_TYPE_SIGNATURE(CPOOL, IDX) \
+ CPOOL_UTF(CPOOL, CPOOL_USHORT2(CPOOL, IDX))
+
+/* A FieldRef, MethodRef or InterfaceMethodRef constant
+ is represented as a TREE_LIST. */
+
+#define COMPONENT_REF_CLASS_INDEX(CPOOL, IDX) CPOOL_USHORT1(CPOOL, IDX)
+#define COMPONENT_REF_NAME_AND_TYPE(CPOOL, IDX) CPOOL_USHORT2(CPOOL, IDX)
+#define COMPONENT_REF_NAME(CPOOL, IDX) \
+ NAME_AND_TYPE_NAME (CPOOL, COMPONENT_REF_NAME_AND_TYPE(CPOOL, IDX))
+#define COMPONENT_REF_SIGNATURE(CPOOL, IDX) \
+ NAME_AND_TYPE_SIGNATURE (CPOOL, COMPONENT_REF_NAME_AND_TYPE(CPOOL, IDX))
+
+/* "Promoted types" that are used for primitive types smaller
+ than int. We could use int_type_node, but then we would lose
+ type information (such as needed for debugging). */
+extern tree promoted_byte_type_node;
+extern tree promoted_short_type_node;
+extern tree promoted_char_type_node;
+extern tree promoted_boolean_type_node;
+
+extern tree byte_type_node;
+extern tree short_type_node;
+extern tree int_type_node;
+extern tree long_type_node;
+
+extern tree unsigned_byte_type_node;
+extern tree unsigned_short_type_node;
+extern tree unsigned_int_type_node;
+extern tree unsigned_long_type_node;
+
+extern tree boolean_type_node;
+extern tree char_type_node;
+extern tree float_type_node;
+extern tree double_type_node;
+
+extern tree object_type_node;
+extern tree object_ptr_type_node;
+extern tree string_type_node;
+extern tree throwable_type_node;
+
+extern tree byte_array_type_node;
+extern tree short_array_type_node;
+extern tree int_array_type_node;
+extern tree long_array_type_node;
+extern tree boolean_array_type_node;
+extern tree char_array_type_node;
+extern tree double_array_type_node;
+extern tree float_array_type_node;
+extern tree array_array_type_node;
+extern tree object_array_type_node;
+extern tree string_array_type_node;
+extern tree TYPE_identifier_node; /* "TYPE" */
+extern tree init_identifier_node; /* "<init>" */
+extern tree clinit_identifier_node; /* "<clinit>" */
+extern tree void_signature_node; /* "()V" */
+extern tree finalize_identifier_node; /* "finalize" */
+extern tree length_identifier_node; /* "length" */
+extern tree this_identifier_node; /* "this" */
+extern tree super_identifier_node; /* "super" */
+extern tree one_elt_array_domain_type;
+extern tree void_type_node;
+extern tree ptr_type_node;
+/* The type of the return address of a subroutine. */
+extern tree return_address_type_node;
+
+/* Nodes for boolean constants TRUE and FALSE. */
+extern tree boolean_true_node, boolean_false_node;
+
+/* Integer constants not declared in tree.h. */
+extern tree integer_negative_one_node;
+extern tree integer_two_node;
+extern tree integer_four_node;
+
+/* The type for struct methodtable. */
+extern tree methodtable_type;
+extern tree methodtable_ptr_type;
+
+extern tree utf8const_type;
+extern tree utf8const_ptr_type;
+
+extern tree class_type_node;
+extern tree class_ptr_type;
+extern tree field_type_node;
+extern tree constants_type_node;
+extern tree dtable_type, dtable_ptr_type;
+extern tree field_ptr_type_node;
+extern tree field_info_union_node;
+extern tree method_type_node;
+extern tree method_ptr_type_node;
+#define nativecode_ptr_type_node ptr_type_node
+
+/* References to internal libjava functions we use. */
+extern tree alloc_object_node;
+extern tree soft_instanceof_node;
+extern tree soft_checkcast_node;
+extern tree soft_initclass_node;
+extern tree soft_newarray_node;
+extern tree soft_anewarray_node;
+extern tree soft_multianewarray_node;
+extern tree soft_badarrayindex_node;
+extern tree throw_node;
+extern tree soft_checkarraystore_node;
+extern tree soft_monitorenter_node;
+extern tree soft_monitorexit_node;
+extern tree soft_lookupinterfacemethod_node;
+extern tree soft_fmod_node;
+
+extern tree access_flags_type_node;
+
+extern tree class_dtable_decl;
+
+/* They need to be reset before processing each class */
+extern struct CPool *outgoing_cpool;
+extern tree current_constant_pool_data_ref;
+
+
+struct lang_identifier
+{
+ struct tree_identifier ignore;
+ tree global_value, local_value;
+
+ /* If non-NULL: An ADDR_REF to a VAR_DECL that contains
+ * the Utf8Const representation of the identifier. */
+ tree utf8_ref;
+};
+
+/* Macros for access to language-specific slots in an identifier. */
+/* UNless specifide, each of these slots contains a DECL node or null. */
+
+/* This represents the value which the identifier has in the
+ file-scope namespace. */
+#define IDENTIFIER_GLOBAL_VALUE(NODE) \
+ (((struct lang_identifier *)(NODE))->global_value)
+/* This represents the value which the identifier has in the current
+ scope. */
+#define IDENTIFIER_LOCAL_VALUE(NODE) \
+ (((struct lang_identifier *)(NODE))->local_value)
+
+/* Given an identifier NODE, get the corresponding (non-handle) class.
+ For get_identifier ("java.lang.Number"), the result is
+ the struct whose DECL_ASSEMBLER_NAME is "Classjava_lang_Number". */
+#define IDENTIFIER_CLASS_VALUE(NODE) IDENTIFIER_GLOBAL_VALUE(NODE)
+
+/* Given an identifier NODE, get the corresponding handle class.
+ For get_identifier ("java.lang.Number"), the result is
+ the struct whose DECL_ASSEMBLER_NAME is "Hjava_lang_Number". */
+#define IDENTIFIER_HANDLECLASS_VALUE(NODE) ???
+
+/* Given a signature of a reference (or array) type, or a method, return the
+ corresponding type (if one has been allocated).
+ Do not use for primitive types, since they may be ambiguous.
+ (E.g. is "I" a signature or a class name?) */
+#define IDENTIFIER_SIGNATURE_TYPE(NODE) IDENTIFIER_GLOBAL_VALUE(NODE)
+
+/* If non-NULL: An ADDR_REF to a VAR_DECL that contains
+ the Utf8Const representation of the identifier. */
+#define IDENTIFIER_UTF8_REF(NODE) \
+ (((struct lang_identifier *)(NODE))->utf8_ref)
+
+#define IDENTIFIER_UTF8_DECL(NODE) \
+ TREE_OPERAND((((struct lang_identifier *)(NODE))->utf8_ref), 0)
+
+/* For a FUNCTION_DECL, if we are compiling a .class file, then this is
+ the position in the .class file of the method code.
+ Specifically, this is the code itself, not the code attribute. */
+#define DECL_CODE_OFFSET(DECL) (DECL_LANG_SPECIFIC(DECL)->code_offset)
+/* Similarly, the length of the bytecode. */
+#define DECL_CODE_LENGTH(DECL) (DECL_LANG_SPECIFIC(DECL)->code_length)
+/* Similarly, the position of the LineNumberTable attribute. */
+#define DECL_LINENUMBERS_OFFSET(DECL) \
+ (DECL_LANG_SPECIFIC(DECL)->linenumbers_offset)
+/* Similarly, the position of the LocalVariableTable attribute
+ (following the standard attribute header). */
+#define DECL_LOCALVARIABLES_OFFSET(DECL) \
+ (DECL_LANG_SPECIFIC(DECL)->localvariables_offset)
+
+#define DECL_MAX_LOCALS(DECL) (DECL_LANG_SPECIFIC(DECL)->max_locals)
+#define DECL_MAX_STACK(DECL) (DECL_LANG_SPECIFIC(DECL)->max_stack)
+/* Number of local variable slots needed for the arguments of this function. */
+#define DECL_ARG_SLOT_COUNT(DECL) (DECL_LANG_SPECIFIC(DECL)->arg_slot_count)
+/* Pointer to the function's COMPOUND_EXPR tree */
+#define DECL_FUNCTION_BODY(DECL) (DECL_LANG_SPECIFIC(DECL)->function_decl_body)
+
+/* In a LABEL_DECL, a TREE_VEC that saves the type_map at that point. */
+#define LABEL_TYPE_STATE(NODE) (DECL_INITIAL (NODE))
+
+/* In the label of a subroutine, a dummy label that records the
+ state following a merge of all the ret instructions in this subroutine. */
+#define LABEL_RETURN_LABEL(DECL) DECL_ARGUMENTS(DECL)
+
+/* In the label of a sub-routine, records the type state at return.
+ * A local may be TYPE_UNUSED, which means that the local is not
+ * used (stored to or loaded from) in this subroutine - at least for
+ * code that we have verified so far. */
+#define LABEL_RETURN_TYPE_STATE(NODE) LABEL_TYPE_STATE (LABEL_RETURN_LABEL (NODE))
+
+/* In a TREE_VEC for a LABEL_RETURN_TYPE_STATE, notes that
+ TREE_VEC_LENGTH has been adjust to the correct stack size. */
+#define RETURN_MAP_ADJUSTED(NODE) TREE_LANG_FLAG_2(NODE)
+
+/* In the label of a sub-routine, a chain of the return location labels. */
+#define LABEL_RETURN_LABELS(node) DECL_RESULT (LABEL_RETURN_LABEL(node))
+
+/* In a LABEL_DECL, the next pending label.
+ See pending_blocks in expr.c. */
+#define LABEL_PENDING_CHAIN(NODE) DECL_RESULT(NODE)
+
+/* In a LABEL_DECL, the corresponding bytecode program counter. */
+#define LABEL_PC(NODE) ((NODE)->decl.saved_insns.i)
+
+/* Used during verification to mark the label has "changed". (See JVM Spec). */
+#define LABEL_CHANGED(NODE) DECL_LANG_FLAG_6(NODE)
+
+/* In a LABEL_DECL, true if we have verified instructions starting here. */
+#define LABEL_VERIFIED(NODE) (instruction_bits[LABEL_PC(NODE)]&BCODE_VERIFIED)
+
+/* True if this code is within a subroutine (target of a jsr). */
+#define LABEL_IN_SUBR(NODE) DECL_LANG_FLAG_4(NODE)
+/* True if this code is the start of a subroutine (target of a jsr). */
+#define LABEL_IS_SUBR_START(NODE) DECL_LANG_FLAG_5(NODE)
+
+/* In a LABEL_DECL, if LABEL_IN_SUBR(NODE), points to start of subroutine. */
+#define LABEL_SUBR_START(NODE) DECL_ABSTRACT_ORIGIN(NODE)
+
+/* In a LABEL_DECL that has LABEL_IS_SUBR_START, this points to the start
+ of surrounding subroutine in the case of a nested subroutine,
+ and NULL_TREE otherwise. */
+#define LABEL_SUBR_CONTEXT(NODE) DECL_CONTEXT (LABEL_RETURN_LABEL (NODE))
+
+/* The slot number for this local variable. */
+#define DECL_LOCAL_SLOT_NUMBER(NODE) \
+ (((struct lang_decl_var*)DECL_LANG_SPECIFIC(NODE))->slot_number)
+/* The start (bytecode) pc for the valid range of this local variable. */
+#define DECL_LOCAL_START_PC(NODE) \
+ (((struct lang_decl_var*)DECL_LANG_SPECIFIC(NODE))->start_pc)
+/* The end (bytecode) pc for the valid range of this local variable. */
+#define DECL_LOCAL_END_PC(NODE) \
+ (((struct lang_decl_var*)DECL_LANG_SPECIFIC(NODE))->end_pc)
+/* For a VAR_DECLor PARM_DECL, used to chain decls with the same
+ slot_number in decl_map. */
+#define DECL_LOCAL_SLOT_CHAIN(NODE) \
+ (((struct lang_decl_var*)DECL_LANG_SPECIFIC(NODE))->slot_chain)
+
+/* DECL_LANG_SPECIFIC for FUNCTION_DECLs. */
+struct lang_decl
+{
+ /* tree chain; not yet used. */
+ long code_offset;
+ int code_length;
+ long linenumbers_offset;
+ long localvariables_offset;
+ int arg_slots;
+ int max_locals, max_stack, arg_slot_count;
+ tree function_decl_body; /* Hold all function's statements */
+};
+
+/* DECL_LANG_SPECIFIC for VAR_DECL and PARM_DECL. */
+struct lang_decl_var
+{
+ int slot_number;
+ int start_pc;
+ int end_pc;
+ tree slot_chain;
+};
+
+struct lang_type
+{
+ tree signature;
+ struct JCF *jcf;
+};
+
+#ifdef JAVA_USE_HANDLES
+/* TYPE_BINFO_HANDLE points from a handle-class to its corresponding
+ non-handle-class, and vice verse. */
+
+#define BINFO_HANDLE(NODE) TREE_VEC_ELT ((NODE), 6)
+
+/* Given a RECORD_TYPE for a handle type, return the corresponding class. */
+#define HANDLE_TO_CLASS_TYPE(HTYPE) BINFO_HANDLE (TYPE_BINFO (HTYPE))
+
+/* Given a RECORD_TYPE for a class, return the corresponding handle type. */
+#define CLASS_TO_HANDLE_TYPE(TYPE) BINFO_HANDLE (TYPE_BINFO (TYPE))
+#else
+#define HANDLE_TO_CLASS_TYPE(HTYPE) (HTYPE)
+#define CLASS_TO_HANDLE_TYPE(TYPE) (TYPE)
+#endif
+
+#define JCF_u4 unsigned long
+#define JCF_u2 unsigned short
+
+extern tree lookup_class PROTO ((tree));
+extern tree lookup_java_constructor PROTO ((tree, tree));
+extern tree lookup_java_method PROTO ((tree, tree, tree));
+extern tree lookup_argument_method PROTO ((tree, tree, tree));
+extern tree promote_type PROTO ((tree));
+extern tree get_constant PROTO ((struct JCF*, int));
+extern tree get_name_constant PROTO ((struct JCF*, int));
+extern tree get_class_constant PROTO ((struct JCF*, int));
+extern tree parse_signature PROTO ((struct JCF *jcf, int sig_index));
+extern int jcf_parse PROTO ((struct JCF*));
+extern tree add_field PROTO ((tree, tree, tree, int));
+extern tree add_method PROTO ((tree, int, tree, tree));
+extern tree add_method_1 PROTO ((tree, int, tree, tree));
+extern tree make_class ();
+extern tree push_class PROTO ((tree, tree));
+extern tree unmangle_classname PROTO ((const char *name, int name_length));
+extern tree parse_signature_string PROTO ((const unsigned char *, int));
+extern tree get_type_from_signature PROTO ((tree));
+extern void layout_class PROTO ((tree));
+extern tree make_class ();
+extern tree build_class_ref PROTO ((tree));
+extern tree build_dtable_decl PROTO ((tree));
+extern tree build_internal_class_name PROTO ((tree));
+extern tree build_constants_constructor ();
+extern tree build_ref_from_constant_pool PROTO ((int));
+extern tree build_utf8_ref PROTO ((tree));
+extern tree ident_subst PROTO ((const char*, int,
+ const char*, int, int, const char*));
+extern tree identifier_subst PROTO ((const tree,
+ const char *, int, int, const char *));
+extern tree build_java_signature PROTO ((tree));
+extern tree build_java_argument_signature PROTO ((tree));
+extern void set_java_signature PROTO ((tree, tree));
+extern tree build_static_field_ref PROTO ((tree));
+extern tree build_address_of PROTO ((tree));
+extern tree find_local_variable PROTO ((int index, tree type, int pc));
+extern tree find_stack_slot PROTO ((int index, tree type));
+extern tree build_prim_array_type PROTO ((tree, HOST_WIDE_INT));
+extern tree build_java_array_type PROTO ((tree, HOST_WIDE_INT));
+extern int is_compiled_class PROTO ((tree));
+extern tree mangled_classname PROTO ((char*, tree));
+extern tree lookup_label PROTO ((int));
+extern tree pop_type PROTO ((tree));
+extern void pop_argument_types PROTO ((tree));
+extern tree decode_newarray_type PROTO ((int));
+extern tree lookup_field PROTO ((tree*, tree));
+extern int is_array_type_p PROTO ((tree));
+extern HOST_WIDE_INT java_array_type_length PROTO ((tree));
+extern void load_class PROTO ((tree, int));
+
+extern tree lookup_name PROTO ((tree));
+extern tree build_known_method_ref PROTO ((tree, tree, tree, tree, tree));
+extern tree build_class_init PROTO ((tree, tree));
+extern tree build_invokevirtual PROTO ((tree, tree));
+extern tree invoke_build_dtable PROTO ((int, tree));
+extern tree match_java_method PROTO ((tree, tree, tree));
+extern tree build_field_ref PROTO ((tree, tree, tree));
+extern void pushdecl_force_head PROTO ((tree));
+extern tree build_java_binop PROTO ((enum tree_code, tree, tree, tree));
+extern tree binary_numeric_promotion PROTO ((tree, tree, tree *, tree *));
+extern tree build_decl_no_layout PROTO ((enum tree_code, tree, tree));
+extern tree build_java_arrayaccess PROTO ((tree, tree, tree));
+extern tree build_newarray PROTO ((int, tree));
+extern tree build_anewarray PROTO ((tree, tree));
+extern tree build_java_array_length_access PROTO ((tree));
+extern tree build_java_arraynull_check PROTO ((tree, tree, tree));
+extern tree create_label_decl PROTO ((tree));
+extern void push_labeled_block PROTO ((tree));
+
+/* Access flags etc for a method (a FUNCTION_DECL): */
+
+#define METHOD_PUBLIC(DECL) DECL_LANG_FLAG_1 (DECL)
+#define METHOD_PRIVATE(DECL) TREE_PRIVATE (DECL)
+#define METHOD_PROTECTED(DECL) TREE_PROTECTED (DECL)
+#define METHOD_STATIC(DECL) DECL_LANG_FLAG_2 (DECL)
+#define METHOD_FINAL(DECL) DECL_LANG_FLAG_3 (DECL)
+#define METHOD_SYNCHRONIZED(DECL) DECL_LANG_FLAG_4 (DECL)
+#define METHOD_NATIVE(DECL) DECL_EXTERNAL(DECL)
+#define METHOD_ABSTRACT(DECL) DECL_LANG_FLAG_5 (DECL)
+#define METHOD_TRANSIENT(DECL) DECL_LANG_FLAG_6 (DECL)
+
+#define DECL_CONSTRUCTOR_P(DECL) DECL_LANG_FLAG_7(DECL)
+
+/* Access flags etc for a variable/field (a FIELD_DECL): */
+
+#define FIELD_PRIVATE(DECL) TREE_PRIVATE (DECL)
+#define FIELD_PROTECTED(DECL) TREE_PROTECTED (DECL)
+#define FIELD_PUBLIC(DECL) DECL_LANG_FLAG_1 (DECL)
+#define FIELD_STATIC(DECL) TREE_STATIC (DECL)
+#define FIELD_FINAL(DECL) DECL_LANG_FLAG_3 (DECL)
+#define FIELD_VOLATILE(DECL) DECL_LANG_FLAG_4 (DECL)
+#define FIELD_TRANSIENT(DECL) DECL_LANG_FLAG_5 (DECL)
+
+/* Initialized flag on variable/field/parm decl */
+
+#define INITIALIZED_P(DECL) DECL_LANG_FLAG_6 (DECL)
+
+/* Access flags etc for a class (a TYPE_DECL): */
+
+#define CLASS_PUBLIC(DECL) DECL_LANG_FLAG_1 (DECL)
+#define CLASS_FINAL(DECL) DECL_LANG_FLAG_3 (DECL)
+#define CLASS_INTERFACE(DECL) DECL_LANG_FLAG_4 (DECL)
+#define CLASS_ABSTRACT(DECL) DECL_LANG_FLAG_5 (DECL)
+#define CLASS_SUPER(DECL) DECL_LANG_FLAG_6 (DECL)
+
+/* The number of virtual methods in this class's dispatch table.
+ Does not include initial two dummy entries (one points to the
+ Class object, and the other is for G++ -fvtable-thunks compatibility). */
+#define TYPE_NVIRTUALS(TYPE) TYPE_BINFO_VIRTUALS (TYPE)
+
+/* A TREE_VEC (indexed by DECL_VINDEX) containing this class's
+ virtual methods. */
+#define TYPE_VTABLE(TYPE) TYPE_BINFO_VTABLE(TYPE)
+
+/* True of a RECORD_TYPE of a class/interface type (not array type) */
+#define CLASS_P(TYPE) TYPE_LANG_FLAG_4 (TYPE)
+/* Use CLASS_LOADED_P? FIXME */
+#define CLASS_COMPLETE_P(DECL) DECL_LANG_FLAG_2 (DECL)
+
+/* This maps a bytecode offset (PC) to various flags,
+ listed below (starting with BCODE_). */
+extern char *instruction_bits;
+
+/* True iff the byte is the start of an instruction. */
+#define BCODE_INSTRUCTION_START 1
+
+/* True iff there is a jump to this location. */
+#define BCODE_JUMP_TARGET 2
+
+/* True iff there is a return to this location.
+ (I.e. the preceedng instruction was a call.) */
+#define BCODE_RETURN_TARGET 4
+
+/* True iff this is the start of an exception handler. */
+#define BCODE_EXCEPTION_TARGET 16
+
+/* True iff there is a jump to this location (and it needs a label). */
+#define BCODE_TARGET \
+ (BCODE_JUMP_TARGET|BCODE_RETURN_TARGET \
+ | BCODE_EXCEPTION_TARGET)
+
+/* True iff there is an entry in the linenumber table for this location. */
+#define BCODE_HAS_LINENUMBER 32
+
+/* True iff there is more than one entry in the linenumber table for
+ this location. (This probably does not make much sense.) */
+#define BCODE_HAS_MULTI_LINENUMBERS 64
+
+/* True if this instruction has been verified. */
+#define BCODE_VERIFIED 8
+
+/* A pointer to the line number table of the current method. */
+extern unsigned char *linenumber_table;
+/* The length (in items) of the line number table. */
+extern int linenumber_count;
+
+/* In type_map, means that slot is uninitialized or otherwise unusable. */
+#define TYPE_UNKNOWN NULL_TREE
+
+/* In type_map, means the second half of a 64-bit double or long. */
+#define TYPE_SECOND void_type_node
+
+/* In type_map, means the null type (i.e. type of a null reference). */
+#define TYPE_NULL ptr_type_node
+
+/* In a type map means the type the address subroutine return address. */
+#define TYPE_RETURN_ADDR return_address_type_node
+
+/* In a subroutine's return type map, indicates that the slot was neither
+ used nor set in the subroutine. */
+#define TYPE_UNUSED error_mark_node
+
+/* A array mapping variable/stack slot index to the type current
+ in that variable/stack slot.
+ TYPE_UNKNOWN, TYPE_SECOND, and TYPE_NULL are special cases. */
+extern tree *type_map;
+
+/* Map a stack index to the type currently in that slot. */
+#define stack_type_map (type_map+DECL_MAX_LOCALS(current_function_decl))
+
+/* True iff TYPE takes two variable/stack slots. */
+#define TYPE_IS_WIDE(TYPE) \
+ ((TYPE) == double_type_node || (TYPE) == long_type_node)
+
+/* True iff TYPE is a Java array type. */
+#define TYPE_ARRAY_P(TYPE) TYPE_LANG_FLAG_1 (TYPE)
+
+/* If FUNCTION_TYPE or METHOD_TYPE: cache for build_java_argument_signature. */
+#define TYPE_ARGUMENT_SIGNATURE(TYPE) TYPE_VFIELD(TYPE)
+
+/* Given an array type, give the type of the elements. */
+/* FIXME this use of TREE_TYPE conflicts with something or other. */
+#define TYPE_ARRAY_ELEMENT(ATYPE) TREE_TYPE(ATYPE)
+
+/* True if class TYPE has been loaded. */
+#define CLASS_LOADED_P(TYPE) TYPE_LANG_FLAG_2 (TYPE)
+
+/* True if class TYPE was defined in Java source code. */
+#define CLASS_FROM_SOURCE_P(TYPE) TYPE_LANG_FLAG_3 (TYPE)
+
+/* True if identifier ID was seen while processing a single type import stmt */
+#define IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P(ID) TREE_LANG_FLAG_0 (ID)
+
+/* True if identifier ID was seen while processing an import statement */
+#define IS_A_CLASSFILE_NAME(ID) TREE_LANG_FLAG_1 (ID)
+
+/* True if ID is a qualified named (contains . or /) */
+#define QUALIFIED_P(ID) TREE_LANG_FLAG_2 (ID)
+
+/* True if ID is an already processed import on demand */
+#define IS_AN_IMPORT_ON_DEMAND_P(ID) TREE_LANG_FLAG_3 (ID)
+
+/* True if EXPR is RHS sub-tree of a compound assign expression */
+#define COMPOUND_ASSIGN_P(EXPR) TREE_LANG_FLAG_1 (EXPR)
+
+/* True if EXPR (a WFL in that case) was created after the
+ reduction of PRIMARY . XXX */
+#define PRIMARY_P(EXPR) TREE_LANG_FLAG_2 (EXPR)
+
+/* True if EXPR (a MODIFY_EXPR in that case) is the result of variable
+ initialization during its declaration */
+#define MODIFY_EXPR_FROM_INITIALIZATION_P(EXPR) TREE_LANG_FLAG_2 (EXPR)
+
+/* True if EXPR (a WFL in that case) resolves into an expression name */
+#define RESOLVE_EXPRESSION_NAME_P(WFL) TREE_LANG_FLAG_0 (WFL)
+
+/* True if EXPR (a LOOP_EXPR in that case) is part of a for statement */
+#define IS_FOR_LOOP_P(EXPR) TREE_LANG_FLAG_0 (EXPR)
+
+/* True if EXPR (a WFL in that case) resolves into a package name */
+#define RESOLVE_PACKAGE_NAME_P(WFL) TREE_LANG_FLAG_3 (WFL)
+
+/* True if EXPR (a WFL in that case) resolves into a type name */
+#define RESOLVE_TYPE_NAME_P(WFL) TREE_LANG_FLAG_4 (WFL)
+
+/* True if STMT (a WFL in that case) holds a BREAK statement */
+#define IS_BREAK_STMT_P(WFL) TREE_LANG_FLAG_5 (WFL)
+
+/* Add a FIELD_DECL to RECORD_TYPE RTYPE.
+ The field has name NAME (a char*), and type FTYPE.
+ Unless this is the first field, FIELD most hold the previous field.
+ FIELD is set to the newly created FIELD_DECL.
+
+ We set DECL_ARTIFICIAL so these fields get skipped by make_class_data
+ if compiling java.lang.Object or java.lang.Class. */
+
+#define PUSH_FIELD(RTYPE, FIELD, NAME, FTYPE) \
+{ tree tmp_field = build_decl (FIELD_DECL, get_identifier(NAME), FTYPE); \
+ if (TYPE_FIELDS (RTYPE) == NULL_TREE) TYPE_FIELDS (RTYPE) = tmp_field; \
+ else TREE_CHAIN(FIELD) = tmp_field; \
+ DECL_CONTEXT (tmp_field) = RTYPE; \
+ DECL_ARTIFICIAL (tmp_field) = 1; \
+ FIELD = tmp_field; }
+
+#define FINISH_RECORD(RTYPE) layout_type (RTYPE)
+
+/* Start building a RECORD_TYPE constructor with a given TYPE in CONS. */
+#define START_RECORD_CONSTRUCTOR(CONS, CTYPE) { \
+ CONS = build (CONSTRUCTOR, CTYPE, NULL_TREE, NULL_TREE);\
+ TREE_CHAIN(CONS) = TYPE_FIELDS (CTYPE); }
+
+/* Append a field initializer to CONS for the dummy field for the inherited
+ fields. The dummy field has the given VALUE, and the same type as the
+ super-class. Must be specified before calls to PUSH_FIELD_VALUE. */
+
+#define PUSH_SUPER_VALUE(CONS, VALUE) {\
+ tree field = TREE_CHAIN(CONS);\
+ if (DECL_NAME (field) != NULL_TREE) abort();\
+ CONSTRUCTOR_ELTS(CONS) = tree_cons (field, VALUE, CONSTRUCTOR_ELTS(CONS));\
+ TREE_CHAIN(CONS) = TREE_CHAIN (field); }
+
+/* Append a field initializer to CONS for a field with the given VALUE.
+ NAME is a char* string used for error checking;
+ the initializer must be specified in order. */
+#define PUSH_FIELD_VALUE(CONS, NAME, VALUE) {\
+ tree field = TREE_CHAIN(CONS);\
+ if (strcmp (IDENTIFIER_POINTER (DECL_NAME (field)), NAME) != 0) abort();\
+ CONSTRUCTOR_ELTS(CONS) = tree_cons (field, VALUE, CONSTRUCTOR_ELTS(CONS));\
+ TREE_CHAIN(CONS) = TREE_CHAIN (field); }
+
+/* Finish creating a record CONSTRUCTOR CONS. */
+#define FINISH_RECORD_CONSTRUCTOR(CONS) \
+ CONSTRUCTOR_ELTS(CONS) = nreverse (CONSTRUCTOR_ELTS(CONS))
+
+/* New tree code for expression, so we can expand then individually. */
+#define JAVA_UNARY_PLUS_EXPR ((int)LAST_AND_UNUSED_TREE_CODE + 2)
+#define JAVA_NEW_ARRAY_EXPR ((int)LAST_AND_UNUSED_TREE_CODE + 3)
+#define JAVA_NEW_CLASS_EXPR ((int)LAST_AND_UNUSED_TREE_CODE + 4)
+#define JAVA_THIS_EXPR ((int)LAST_AND_UNUSED_TREE_CODE + 5)
+
+/* Macro(s) using the definitions above */
+#define CALL_CONSTRUCTOR_P(NODE) (TREE_CODE (NODE) == JAVA_NEW_CLASS_EXPR)
+
--- /dev/null
+/* Table of opcodes for byte codes defined by the Java(TM) virtual
+ machine specification.
+ Copyright (C) 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc.
+
+Written by Per Bothner <bothner@cygnus.com>, February 1996.
+*/
+
+/* JAVAOP (OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE), where:
+ OPNAME is the name of the opcode.
+ OPCODE is the 1-byte opcode value.
+ OPKIND is the kind of operation.
+ OPERAND_TYPE is the type operands affected.
+ OPERAND_VALUE tells where to get the value. (Its meaning
+ depends on OPKIND.) */
+
+/* Various macro used in OPERAND_VALUE:
+IMMEDIATE_s1: An immediate signed 1-byte value in the byte-code stream.
+IMMEDIATE_s2: An immediate signed 2-byte value in the byte-code stream.
+IMMEDIATE_u1: An immediate unsigned 1-byte value in the byte-code stream.
+IMMEDIATE_u2: An immediate unsigned 2-byte value in the byte-code stream.
+
+CONST_INDEX_1: An immediate unsigned 1-byte index into the constant pool.
+CONST_INDEX_2: An immediate unsigned 2-byte index into the constant pool.
+*/
+
+/* More specifically, this is the meaning of the various OPKINDs:
+
+BINOP: binary operation
+ OPERAND_TYPE is the argument type.
+ OPERAND_VALUE is PLUS, MINUS, MULT, TRUNC_DIV, RDIV, REM,
+ LSHIFT, RSHIFT, URSHIFT, BIT_AND, BIT_IOR, BIT_XOR,
+ COMPARE, COMPARE_L, or COMPARE_G.
+
+UNOP: unary operation
+ OPERAND_TYPE is the argument type.
+ OPERAND_VALUE is NEG.
+
+INVOKE: invoke operations
+ OPERAND_TYPE is VIRTUAL, SPECIAL, STATIC, or INTERFACE.
+ OPERAND_VALUE is 1 if interface, 0 otherwise.
+
+OBJECT: new, checkcast, instanceof
+ OPERAND_TYPE is PTR.
+ OPERAND_VALUE is NEW, CHECKCAST, or INSTANCEOF.
+
+BRANCH: branch operations
+ OPERAND_TYPE is GOTO, CALL, or RETURN.
+ OPERAND_VALUE is IMMEDIATE_s2, VAR_INDEX_1, IMMEDIATE_s4,
+ or VAR_INDEX_2.
+
+STACK: Various stack operations.
+
+PUSHC: Push a constant onto the operand stack.
+ OPERAND_VALUE maybe be the value to push,
+ or IMMEDIATE_s1 or IMMEDIATE_s2 if the constant is immediate,
+ or CONST_INDEX_1 or CONST_INDEX_2 for a constant pool index.
+
+LOAD: Push a value from a local variable onto the operand stack.
+ OPERAND_VALUE is the index of the local variable in the current
+ Java frame. It can be a literal, or IMMEDIATE_i2.
+
+CONVERT: Convert top of stack value from one type to another.
+ OPERAND_TYPE is the argument type.
+ OPERAND_VALUE is the result type.
+
+TEST: Compares an integer (popped from the stack) against zero.
+ If the test (in OPERAND_VALUE) is true, goto a relative
+ offset given by the next two bytes.
+
+COND: Compares two values (popped from the stack) againt each other.
+ If the test (in OPERAND_VALUE) is true, goto a relative
+ offset given by the next two bytes.
+
+SWITCH:
+ OPERAND_VALUE is either TABLE or LOOKUP.
+
+ARRAY:
+ OPERAND_VALUE is LOAD, STORE, LENGTH, or NEW.
+
+FIELD: Extracts from or stores into a field.
+ OPERAND_TYPE is 1 for a static field, 0 for a regular field.
+ OPERAND_VALUE is 1 for a put operation, 0 for a get operation.
+
+SPECIAL:
+ Random bunch of opcodes.
+
+*/
+
+JAVAOP (nop, 0, STACK, POP, 0)
+JAVAOP (aconst_null, 1, PUSHC, PTR, 0)
+JAVAOP (iconst_m1, 2, PUSHC, INT, -1)
+JAVAOP (iconst_0, 3, PUSHC, INT, 0)
+JAVAOP (iconst_1, 4, PUSHC, INT, 1)
+JAVAOP (iconst_2, 5, PUSHC, INT, 2)
+JAVAOP (iconst_3, 6, PUSHC, INT, 3)
+JAVAOP (iconst_4, 7, PUSHC, INT, 4)
+JAVAOP (iconst_5, 8, PUSHC, INT, 5)
+JAVAOP (lconst_0, 9, PUSHC, LONG, 0)
+JAVAOP (lconst_1, 10, PUSHC, LONG, 1)
+JAVAOP (fconst_0, 11, PUSHC, FLOAT, 0)
+JAVAOP (fconst_1, 12, PUSHC, FLOAT, 1)
+JAVAOP (fconst_2, 13, PUSHC, FLOAT, 2)
+JAVAOP (dconst_0, 14, PUSHC, DOUBLE, 0)
+JAVAOP (dconst_1, 15, PUSHC, DOUBLE, 1)
+JAVAOP (bipush, 16, PUSHC, INT, IMMEDIATE_s1)
+JAVAOP (sipush, 17, PUSHC, INT, IMMEDIATE_s2)
+JAVAOP (ldc, 18, PUSHC, INT, CONST_INDEX_1)
+JAVAOP (ldc_w, 19, PUSHC, INT, CONST_INDEX_2)
+JAVAOP (ldc2_w, 20, PUSHC, LONG, CONST_INDEX_2)
+JAVAOP (iload, 21, LOAD, INT, IMMEDIATE_u1)
+JAVAOP (lload, 22, LOAD, LONG, IMMEDIATE_u1)
+JAVAOP (fload, 23, LOAD, FLOAT, IMMEDIATE_u1)
+JAVAOP (dload, 24, LOAD, DOUBLE, IMMEDIATE_u1)
+JAVAOP (aload, 25, LOAD, PTR, IMMEDIATE_u1)
+JAVAOP (iload_0, 26, LOAD, INT, 0)
+JAVAOP (iload_1, 27, LOAD, INT, 1)
+JAVAOP (iload_2, 28, LOAD, INT, 2)
+JAVAOP (iload_3, 29, LOAD, INT, 3)
+JAVAOP (lload_0, 30, LOAD, LONG, 0)
+JAVAOP (lload_1, 31, LOAD, LONG, 1)
+JAVAOP (lload_2, 32, LOAD, LONG, 2)
+JAVAOP (lload_3, 33, LOAD, LONG, 3)
+JAVAOP (fload_0, 34, LOAD, FLOAT, 0)
+JAVAOP (fload_1, 35, LOAD, FLOAT, 1)
+JAVAOP (fload_2, 36, LOAD, FLOAT, 2)
+JAVAOP (fload_3, 37, LOAD, FLOAT, 3)
+JAVAOP (dload_0, 38, LOAD, DOUBLE, 0)
+JAVAOP (dload_1, 39, LOAD, DOUBLE, 1)
+JAVAOP (dload_2, 40, LOAD, DOUBLE, 2)
+JAVAOP (dload_3, 41, LOAD, DOUBLE, 3)
+JAVAOP (aload_0, 42, LOAD, PTR, 0)
+JAVAOP (aload_1, 43, LOAD, PTR, 1)
+JAVAOP (aload_2, 44, LOAD, PTR, 2)
+JAVAOP (aload_3, 45, LOAD, PTR, 3)
+JAVAOP (iaload, 46, ARRAY, INT, LOAD)
+JAVAOP (laload, 47, ARRAY, LONG, LOAD)
+JAVAOP (faload, 48, ARRAY, FLOAT, LOAD)
+JAVAOP (daload, 49, ARRAY, DOUBLE, LOAD)
+JAVAOP (aaload, 50, ARRAY, PTR, LOAD)
+JAVAOP (baload, 51, ARRAY, BYTE, LOAD)
+JAVAOP (caload, 52, ARRAY, CHAR, LOAD)
+JAVAOP (saload, 53, ARRAY, SHORT, LOAD)
+JAVAOP (istore, 54, STORE, INT, IMMEDIATE_u1)
+JAVAOP (lstore, 55, STORE, LONG, IMMEDIATE_u1)
+JAVAOP (fstore, 56, STORE, FLOAT, IMMEDIATE_u1)
+JAVAOP (dstore, 57, STORE, DOUBLE, IMMEDIATE_u1)
+JAVAOP (astore, 58, STORE, PTR, IMMEDIATE_u1)
+JAVAOP (istore_0, 59, STORE, INT, 0)
+JAVAOP (istore_1, 60, STORE, INT, 1)
+JAVAOP (istore_2, 61, STORE, INT, 2)
+JAVAOP (istore_3, 62, STORE, INT, 3)
+JAVAOP (lstore_0, 63, STORE, LONG, 0)
+JAVAOP (lstore_1, 64, STORE, LONG, 1)
+JAVAOP (lstore_2, 65, STORE, LONG, 2)
+JAVAOP (lstore_3, 66, STORE, LONG, 3)
+JAVAOP (fstore_0, 67, STORE, FLOAT, 0)
+JAVAOP (fstore_1, 68, STORE, FLOAT, 1)
+JAVAOP (fstore_2, 69, STORE, FLOAT, 2)
+JAVAOP (fstore_3, 70, STORE, FLOAT, 3)
+JAVAOP (dstore_0, 71, STORE, DOUBLE, 0)
+JAVAOP (dstore_1, 72, STORE, DOUBLE, 1)
+JAVAOP (dstore_2, 73, STORE, DOUBLE, 2)
+JAVAOP (dstore_3, 74, STORE, DOUBLE, 3)
+JAVAOP (astore_0, 75, STORE, PTR, 0)
+JAVAOP (astore_1, 76, STORE, PTR, 1)
+JAVAOP (astore_2, 77, STORE, PTR, 2)
+JAVAOP (astore_3, 78, STORE, PTR, 3)
+JAVAOP (iastore, 79, ARRAY, INT, STORE)
+JAVAOP (lastore, 80, ARRAY, LONG, STORE)
+JAVAOP (fastore, 81, ARRAY, FLOAT, STORE)
+JAVAOP (dastore, 82, ARRAY, DOUBLE, STORE)
+JAVAOP (aastore, 83, ARRAY, PTR, STORE)
+JAVAOP (bastore, 84, ARRAY, BYTE, STORE)
+JAVAOP (castore, 85, ARRAY, CHAR, STORE)
+JAVAOP (sastore, 86, ARRAY, SHORT, STORE)
+JAVAOP (pop, 87, STACK, POP, 1)
+JAVAOP (pop2, 88, STACK, POP, 2)
+JAVAOP (dup, 89, STACK, DUP, 1)
+JAVAOP (dup_x1, 90, STACK, DUPx1, 1)
+JAVAOP (dup_x2, 91, STACK, DUPx2, 1)
+JAVAOP (dup2, 92, STACK, DUP, 2)
+JAVAOP (dup2_x1, 93, STACK, DUPx1, 2)
+JAVAOP (dup2_x2, 94, STACK, DUPx2, 2)
+JAVAOP (swap, 95, STACK, SWAP, 0)
+JAVAOP (iadd, 96, BINOP, INT, PLUS)
+JAVAOP (ladd, 97, BINOP, LONG, PLUS)
+JAVAOP (fadd, 98, BINOP, FLOAT, PLUS)
+JAVAOP (dadd, 99, BINOP, DOUBLE, PLUS)
+JAVAOP (isub, 100, BINOP, INT, MINUS)
+JAVAOP (lsub, 101, BINOP, LONG, MINUS)
+JAVAOP (fsub, 102, BINOP, FLOAT, MINUS)
+JAVAOP (dsub, 103, BINOP, DOUBLE, MINUS)
+JAVAOP (imul, 104, BINOP, INT, MULT)
+JAVAOP (lmul, 105, BINOP, LONG, MULT)
+JAVAOP (fmul, 106, BINOP, FLOAT, MULT)
+JAVAOP (dmul, 107, BINOP, DOUBLE, MULT)
+JAVAOP (idiv, 108, BINOP, INT, TRUNC_DIV)
+JAVAOP (ldiv, 109, BINOP, LONG, TRUNC_DIV)
+JAVAOP (fdiv, 110, BINOP, FLOAT, RDIV)
+JAVAOP (ddiv, 111, BINOP, DOUBLE, RDIV)
+JAVAOP (irem, 112, BINOP, INT, REM)
+JAVAOP (lrem, 113, BINOP, LONG, REM)
+JAVAOP (frem, 114, BINOP, FLOAT, REM)
+JAVAOP (drem, 115, BINOP, DOUBLE, REM)
+JAVAOP (ineg, 116, UNOP, INT, NEG)
+JAVAOP (lneg, 117, UNOP, LONG, NEG)
+JAVAOP (fneg, 118, UNOP, FLOAT, NEG)
+JAVAOP (dneg, 119, UNOP, DOUBLE, NEG)
+JAVAOP (ishl, 120, BINOP, INT, LSHIFT)
+JAVAOP (lshl, 121, BINOP, LONG, LSHIFT)
+JAVAOP (ishr, 122, BINOP, INT, RSHIFT)
+JAVAOP (lshr, 123, BINOP, LONG, RSHIFT)
+JAVAOP (iushr, 124, BINOP, INT, URSHIFT)
+JAVAOP (lushr, 125, BINOP, LONG, URSHIFT)
+JAVAOP (iand, 126, BINOP, INT, BIT_AND)
+JAVAOP (land, 127, BINOP, LONG, BIT_AND)
+JAVAOP (ior, 128, BINOP, INT, BIT_IOR)
+JAVAOP (lor, 129, BINOP, LONG, BIT_IOR)
+JAVAOP (ixor, 130, BINOP, INT, BIT_XOR)
+JAVAOP (lxor, 131, BINOP, LONG, BIT_XOR)
+JAVAOP (iinc, 132, SPECIAL, INT, IINC)
+JAVAOP (i2l, 133, CONVERT, INT, LONG)
+JAVAOP (i2f, 134, CONVERT, INT, FLOAT)
+JAVAOP (i2d, 135, CONVERT, INT, DOUBLE)
+JAVAOP (l2i, 136, CONVERT, LONG, INT)
+JAVAOP (l2f, 137, CONVERT, LONG, FLOAT)
+JAVAOP (l2d, 138, CONVERT, LONG, DOUBLE)
+JAVAOP (f2i, 139, CONVERT, FLOAT, INT)
+JAVAOP (f2l, 140, CONVERT, FLOAT, LONG)
+JAVAOP (f2d, 141, CONVERT, FLOAT, DOUBLE)
+JAVAOP (d2i, 142, CONVERT, DOUBLE, INT)
+JAVAOP (d2l, 143, CONVERT, DOUBLE, LONG)
+JAVAOP (d2f, 144, CONVERT, DOUBLE, FLOAT)
+JAVAOP (i2b, 145, CONVERT2, INT, BYTE)
+JAVAOP (i2c, 146, CONVERT2, INT, CHAR)
+JAVAOP (i2s, 147, CONVERT2, INT, SHORT)
+JAVAOP (lcmp, 148, BINOP, LONG, COMPARE)
+JAVAOP (fcmpl, 149, BINOP, FLOAT, COMPARE_L)
+JAVAOP (fcmpg, 150, BINOP, FLOAT, COMPARE_G)
+JAVAOP (dcmpl, 151, BINOP, DOUBLE, COMPARE_L)
+JAVAOP (dcmpg, 152, BINOP, DOUBLE, COMPARE_G)
+JAVAOP (ifeq, 153, TEST, INT, EQ)
+JAVAOP (ifne, 154, TEST, INT, NE)
+JAVAOP (iflt, 155, TEST, INT, LT)
+JAVAOP (ifge, 156, TEST, INT, GE)
+JAVAOP (ifgt, 157, TEST, INT, GT)
+JAVAOP (ifle, 158, TEST, INT, LE)
+JAVAOP (if_icmpeq, 159, COND, INT, EQ)
+JAVAOP (if_icmpne, 160, COND, INT, NE)
+JAVAOP (if_icmplt, 161, COND, INT, LT)
+JAVAOP (if_icmpge, 162, COND, INT, GE)
+JAVAOP (if_icmpgt, 163, COND, INT, GT)
+JAVAOP (if_icmple, 164, COND, INT, LE)
+JAVAOP (if_acmpeq, 165, COND, PTR, EQ)
+JAVAOP (if_acmpne, 166, COND, PTR, NE)
+JAVAOP (goto, 167, BRANCH, GOTO, IMMEDIATE_s2)
+JAVAOP (jsr, 168, JSR, CALL, IMMEDIATE_s2)
+JAVAOP (ret, 169, RET, RETURN, VAR_INDEX_1)
+JAVAOP (tableswitch, 170, SWITCH, INT, TABLE)
+JAVAOP (lookupswitch, 171, SWITCH, INT, LOOKUP)
+JAVAOP (ireturn, 172, RETURN, INT, 0)
+JAVAOP (lreturn, 173, RETURN, LONG, 0)
+JAVAOP (freturn, 174, RETURN, FLOAT, 0)
+JAVAOP (dreturn, 175, RETURN, DOUBLE, 0)
+JAVAOP (areturn, 176, RETURN, PTR, 0)
+JAVAOP (return, 177, RETURN, VOID, 0)
+JAVAOP (getstatic, 178, FIELD, 1, 0)
+JAVAOP (putstatic, 179, FIELD, 1, 1)
+JAVAOP (getfield, 180, FIELD, 0, 0)
+JAVAOP (putfield, 181, FIELD, 0, 1)
+JAVAOP (invokevirtual, 182, INVOKE, VIRTUAL,0)
+JAVAOP (invokespecial, 183, INVOKE, SPECIAL, 0)
+JAVAOP (invokestatic, 184, INVOKE, STATIC, 0)
+JAVAOP (invokeinterface,185, INVOKE, INTERFACE, 1)
+JAVAOP (new, 187, OBJECT, PTR, NEW)
+JAVAOP (newarray, 188, ARRAY, NUM, NEW)
+JAVAOP (anewarray, 189, ARRAY, PTR, NEW)
+JAVAOP (arraylength, 190, ARRAY, INT, LENGTH)
+JAVAOP (athrow, 191, SPECIAL, ANY, THROW)
+JAVAOP (checkcast, 192, OBJECT, PTR, CHECKCAST)
+JAVAOP (instanceof, 193, OBJECT, PTR, INSTANCEOF)
+JAVAOP (monitorenter, 194, SPECIAL, MONITOR, ENTER)
+JAVAOP (monitorexit, 195, SPECIAL, MONITOR, EXIT)
+JAVAOP (wide, 196, SPECIAL, ANY, WIDE)
+JAVAOP (multianewarray,197, ARRAY, MULTI, NEW)
+JAVAOP (ifnull, 198, TEST, PTR, EQ)
+JAVAOP (ifnonnull, 199, TEST, PTR, NE)
+JAVAOP (goto_w, 200, BRANCH, GOTO, IMMEDIATE_s4)
+JAVAOP (jsr_w, 201, JSR, CALL, IMMEDIATE_s4)
+JAVAOP (breakpoint, 202, SPECIAL, ANY, BREAK)
+JAVAOP (ret_w, 209, RET, RETURN, VAR_INDEX_2)
+JAVAOP (impdep1, 254, IMPL, ANY, 1)
+JAVAOP (impdep2, 255, IMPL, ANY, 2)
--- /dev/null
+/* Utility macros to handle Java(TM) byte codes.
+
+ Copyright (C) 1996 Free Software Foundation, Inc.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
+
+#ifndef JAVAOP_H
+#define JAVAOP_H
+
+typedef char int8;
+typedef unsigned char uint8;
+#ifndef int16
+#define int16 short
+#endif
+typedef unsigned int16 uint16;
+
+#ifndef int32
+#define int32 long
+#endif
+typedef unsigned int32 uint32;
+
+/* A signed 64-bit (or more) integral type, suiteable for Java's 'long'. */
+#ifndef int64
+#define int64 long long
+#endif
+/* An unsigned 64-bit (or more) integral type, same length as int64. */
+#ifndef uint64
+#define uint64 unsigned int64
+#endif
+
+typedef uint16 jchar;
+typedef int8 jbyte;
+typedef int16 jshort;
+typedef int32 jint;
+typedef int64 jlong;
+typedef void* jref;
+
+/* A 32-bit IEEE single-precision float. */
+#ifndef jfloat
+#define jfloat float
+#endif
+
+/* A 32-bit IEEE double-precision float. */
+#ifndef jdouble
+#define jdouble double
+#endif
+
+union Word {
+ jint i;
+ jfloat f;
+ void *p;
+};
+
+/* A jword is an unsigned integral type big enough for a 32-bit jint
+ or jfloat *or* a pointer. It is the type appropriate for stack
+ locations and local variables in a Java interpreter. */
+
+
+#ifndef jword
+#define jword uint32
+#endif
+
+#if !defined(inline) && !defined(__GC__) && !defined(__cplusplus)
+#define inline static
+#endif
+
+#ifndef IMMEDIATE_u1
+#define IMMEDIATE_u1 (PC++, CHECK_PC_IN_RANGE(PC), BCODE[PC-1])
+#endif
+#ifndef IMMEDIATE_s1
+#define IMMEDIATE_s1 (PC++, CHECK_PC_IN_RANGE(PC), (signed char)BCODE[PC-1])
+#endif
+#ifndef IMMEDIATE_s2
+#define IMMEDIATE_s2 (PC+=2, CHECK_PC_IN_RANGE(PC), \
+ (signed char) BCODE[PC-2] * 256 + BCODE[PC-1])
+#endif
+#ifndef IMMEDIATE_u2
+#define IMMEDIATE_u2 (PC+=2, CHECK_PC_IN_RANGE(PC),\
+ (BCODE[PC-2] * 256 + BCODE[PC-1]))
+#endif
+#ifndef IMMEDIATE_s4
+#define IMMEDIATE_s4 (PC+=4, CHECK_PC_IN_RANGE(PC), \
+ ((jint)((BCODE[PC-4] << 24) | (BCODE[PC-3] << 16) \
+ | (BCODE[PC-2] << 8) | (BCODE[PC-1]))))
+#endif
+
+inline jfloat
+WORD_TO_FLOAT(jword w)
+{ union Word wu;
+ wu.i = w;
+ return wu.f;
+}
+
+inline jlong
+WORDS_TO_LONG(jword hi, jword lo)
+{
+ return ((jlong) hi << 32) | ((jlong)lo & (((jlong)1 << 32) -1));
+}
+
+union DWord {
+ jdouble d;
+ jlong l;
+ jword w[2];
+};
+
+inline jdouble
+WORDS_TO_DOUBLE(jword hi, jword lo)
+{ union DWord wu;
+ wu.l = WORDS_TO_LONG(hi, lo);
+ return wu.d;
+}
+
+/* If PREFIX_CHAR is the first character of the Utf8 encoding of a character,
+ return the number of bytes taken by the encoding.
+ Return -1 for a continuation character. */
+#define UT8_CHAR_LENGTH(PREFIX_CHAR) \
+ ((unsigned char)(PREFIX_CHAR) < 128 ? 1 \
+ : ((PREFIX_CHAR) & 0x40) == 0 ? -1 \
+ : ((PREFIX_CHAR) & 0x20) == 0 ? 2 \
+ : ((PREFIX_CHAR) & 0x10) == 0 ? 3 \
+ : ((PREFIX_CHAR) & 0x08) == 0 ? 4 : 5)
+
+#endif /* !JAVAOP_H */
--- /dev/null
+/* Program to dump out a Java(TM) .class file.
+ Functionally similar to Sun's javap.
+
+ Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
+
+/*
+ jcf-dump is a program to print out the contents of class files.
+ Usage: jcf-dump [FLAGS] CLASS
+ Each CLASS is either:
+ + the name of a class in the CLASSPATH (e.g "java.lang.String"), or
+ + the name of a class *file* (e.g. "/home/me/work/package/Foo.class").
+ + The name of a .zip or .jar file (which prints all the classes in the
+ archive).
+
+ OPTIONS:
+ -c
+ Dis-assemble each method.
+ -classpath PATH
+ Overrides $CLASSPATH.
+ --print-main
+ Print nothing if there is no valid "main" method;
+ otherwise, print only the class name.
+ --javap
+ Print output in the style of Sun's javap program. VERY UNFINISHED.
+ */
+
+
+#include <stdio.h>
+#include "jcf.h"
+
+/* Outout file. */
+FILE *out;
+/* Name of output file, if NULL if stdout. */
+char *output_file = NULL;
+
+int verbose = 0;
+
+int flag_disassemble_methods = 0;
+int flag_print_class_info = 1;
+int flag_print_constant_pool = 1;
+int flag_print_fields = 1;
+int flag_print_methods = 1;
+int flag_print_attributes = 1;
+
+/* Print names of classes that have a "main" method. */
+int flag_print_main = 0;
+
+/* Index in constant pool of this class. */
+int this_class_index = 0;
+
+int class_access_flags = 0;
+
+/* Print in format similar to javap. VERY IMCOMPLETE. */
+int flag_javap_compatible = 0;
+
+static int print_access_flags PROTO ((FILE *, uint16));
+static void print_constant_terse PROTO ((FILE*, JCF*, int, int));
+static void print_constant PROTO ((FILE *, JCF *, int, int));
+static void print_constant_ref PROTO ((FILE *, JCF *, int));
+static void disassemble_method PROTO ((JCF*, unsigned char *, int));
+static void print_name PROTO ((FILE*, JCF*, int));
+static void print_signature PROTO ((FILE*, JCF*, int, int));
+
+#define PRINT_SIGNATURE_RESULT_ONLY 1
+#define PRINT_SIGNATURE_ARGS_ONLY 2
+
+extern char* open_class();
+
+int
+DEFUN(utf8_equal_string, (jcf, index, value),
+ JCF *jcf AND int index AND char * value)
+{
+ if (CPOOL_INDEX_IN_RANGE (&jcf->cpool, index)
+ && JPOOL_TAG (jcf, index) == CONSTANT_Utf8)
+ {
+ int len = strlen (value);
+ if (JPOOL_UTF_LENGTH (jcf, index) == len
+ && memcmp (JPOOL_UTF_DATA (jcf, index), value, len) == 0)
+ return 1;
+ }
+ return 0;
+}
+
+#define HANDLE_MAGIC(MAGIC, MINOR, MAJOR) \
+ this_class_index = 0; \
+ if (flag_print_class_info) \
+ fprintf (out, \
+ "Magic number: 0x%0x, minor_version: %d, major_version: %d.\n", \
+ MAGIC, MINOR, MAJOR)
+
+#define HANDLE_START_CONSTANT_POOL(COUNT) \
+ if (flag_print_constant_pool) \
+ fprintf (out, "\nConstant pool (count: %d):\n", COUNT)
+
+#define HANDLE_SOURCEFILE(INDEX) \
+{ fprintf (out, "Attribute "); \
+ print_constant_terse (out, jcf, attribute_name, CONSTANT_Utf8); \
+ fprintf (out, ", length:%d, #%d=", attribute_length, INDEX); \
+ print_constant_terse (out, jcf, INDEX, CONSTANT_Utf8); fputc ('\n', out); }
+
+#define HANDLE_CLASS_INFO(ACCESS_FLAGS, THIS, SUPER, INTERFACES_COUNT) \
+ this_class_index = THIS; \
+ class_access_flags = ACCESS_FLAGS; \
+ if (flag_print_class_info) \
+ { fprintf (out, "\nAccess flags: 0x%x", ACCESS_FLAGS); \
+ print_access_flags (out, ACCESS_FLAGS); \
+ fputc ('\n', out); \
+ fprintf (out, "This class: "); \
+ if (flag_print_constant_pool) \
+ fprintf (out, "%d=", THIS); \
+ print_constant_terse (out, jcf, THIS, CONSTANT_Class); \
+ if (flag_print_constant_pool || SUPER != 0) \
+ fprintf (out, ", super: "); \
+ if (flag_print_constant_pool) \
+ { \
+ fprintf (out, "%d", SUPER); \
+ if (SUPER != 0) \
+ fputc ('=', out); \
+ } \
+ if (SUPER != 0) \
+ print_constant_terse (out, jcf, SUPER, CONSTANT_Class); \
+ fprintf (out, "\nInterfaces (count: %d):\n", INTERFACES_COUNT); \
+ }
+
+#define IGNORE_ATTRIBUTE(JCF, NAME, NAME_LENGTH) \
+ (flag_print_attributes <= 0)
+
+#define HANDLE_CLASS_INTERFACE(INDEX) \
+ if (flag_print_class_info) \
+ { fprintf (out, "- Implements: %d=", INDEX); \
+ print_constant_terse (out, jcf, INDEX, CONSTANT_Class); \
+ fputc ('\n', out); }
+
+#define HANDLE_START_FIELDS(FIELDS_COUNT) \
+ if (flag_print_fields) \
+ fprintf (out, "\nFields (count: %d):\n", FIELDS_COUNT)
+
+#define HANDLE_START_FIELD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
+ if (flag_print_fields) \
+ { fprintf (out, "Field name:"); \
+ print_constant_terse (out, jcf, NAME, CONSTANT_Utf8); \
+ print_access_flags (out, ACCESS_FLAGS); \
+ fprintf (out, " Signature: "); \
+ if (flag_print_constant_pool) \
+ fprintf (out, "%d=", SIGNATURE); \
+ print_signature (out, jcf, SIGNATURE, 0); \
+ fputc ('\n', out); } \
+ else \
+ flag_print_attributes--;
+
+#define HANDLE_END_FIELD() \
+ if (! flag_print_fields) \
+ flag_print_attributes++;
+
+#define HANDLE_START_METHODS(METHODS_COUNT) \
+ if (flag_print_methods) \
+ fprintf (out, "\nMethods (count: %d):\n", METHODS_COUNT); \
+ else \
+ flag_print_attributes--;
+
+
+#define HANDLE_END_METHODS() \
+ if (! flag_print_methods) \
+ flag_print_attributes++;
+
+#define HANDLE_METHOD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
+{ \
+ if (flag_print_methods) \
+ { \
+ if (flag_javap_compatible) \
+ { \
+ fprintf (out, " "); \
+ print_access_flags (out, ACCESS_FLAGS); \
+ fputc (' ', out); \
+ print_signature (out, jcf, SIGNATURE, PRINT_SIGNATURE_RESULT_ONLY); \
+ fputc (' ', out); \
+ print_constant_terse (out, jcf, NAME, CONSTANT_Utf8); \
+ print_signature (out, jcf, SIGNATURE, PRINT_SIGNATURE_ARGS_ONLY); \
+ fputc ('\n', out); \
+ } \
+ else \
+ { \
+ fprintf (out, "\nMethod name:"); \
+ print_constant_terse (out, jcf, NAME, CONSTANT_Utf8); \
+ print_access_flags (out, ACCESS_FLAGS); \
+ fprintf (out, " Signature: "); \
+ if (flag_print_constant_pool) \
+ fprintf (out, "%d=", SIGNATURE); \
+ print_signature (out, jcf, SIGNATURE, 0); \
+ fputc ('\n', out); \
+ } \
+ } \
+ if (flag_print_main && ACCESS_FLAGS == (ACC_STATIC|ACC_PUBLIC) \
+ && utf8_equal_string (jcf, NAME, "main") \
+ && utf8_equal_string (jcf, SIGNATURE, "([Ljava/lang/String;)V") \
+ && this_class_index > 0 \
+ && (class_access_flags & ACC_PUBLIC)) \
+ { \
+ print_constant_terse(out, jcf, this_class_index, CONSTANT_Class); \
+ fputc ('\n', out); \
+ } \
+}
+
+#define COMMON_HANDLE_ATTRIBUTE(JCF, INDEX, LENGTH) \
+( fprintf (out, "Attribute "), \
+ print_constant_terse (out, jcf, INDEX, CONSTANT_Utf8), \
+ fprintf (out, ", length:%d", LENGTH) )
+
+#define HANDLE_CONSTANTVALUE(VALUE_INDEX) \
+( COMMON_HANDLE_ATTRIBUTE(JCF, attribute_name, attribute_length), \
+ fprintf (out, ", value: "), \
+ print_constant_ref (out, jcf, VALUE_INDEX), \
+ fprintf (out, "\n") )
+
+#define HANDLE_CODE_ATTRIBUTE(MAX_STACK, MAX_LOCALS, CODE_LENGTH) \
+{ COMMON_HANDLE_ATTRIBUTE(JCF, attribute_name, attribute_length); \
+ fprintf (out, ", max_stack:%d, max_locals:%d, code_length:%d\n", \
+ MAX_STACK, MAX_LOCALS, CODE_LENGTH); \
+ disassemble_method (jcf, jcf->read_ptr, CODE_LENGTH); }
+
+#define HANDLE_EXCEPTIONS_ATTRIBUTE(COUNT) \
+{ int n = (COUNT); int i; \
+ COMMON_HANDLE_ATTRIBUTE(JCF, attribute_name, attribute_length); \
+ fprintf (out, ", count: %d\n", n); \
+ for (i = 0; i < n; i++) {\
+ int ex_index = JCF_readu2 (jcf); \
+ fprintf (out, "%3d: ", i); \
+ print_constant_ref (out, jcf, ex_index); \
+ fputc ('\n', out); } }
+
+#define HANDLE_LOCALVARIABLETABLE_ATTRIBUTE(COUNT) \
+{ int n = (COUNT); int i; \
+ COMMON_HANDLE_ATTRIBUTE(JCF, attribute_name, attribute_length); \
+ fprintf (out, ", count: %d\n", n); \
+ for (i = 0; i < n; i++) {\
+ int start_pc = JCF_readu2 (jcf); \
+ int length = JCF_readu2 (jcf); \
+ int name_index = JCF_readu2 (jcf); \
+ int signature_index = JCF_readu2 (jcf); \
+ int slot = JCF_readu2 (jcf); \
+ fprintf (out, " slot#%d: name: %d=", slot, name_index); \
+ print_name (out, jcf, name_index); \
+ fprintf (out, ", type: %d=", signature_index); \
+ print_signature (out, jcf, signature_index, 0); \
+ fprintf (out, " (pc: %d length: %d)\n", start_pc, length); }}
+
+#define HANDLE_LINENUMBERTABLE_ATTRIBUTE(COUNT) \
+{ int n = (COUNT); int i; \
+ COMMON_HANDLE_ATTRIBUTE(jcf, attribute_name, attribute_length); \
+ fprintf (out, ", count: %d\n", n); \
+ if (flag_disassemble_methods) \
+ for (i = 0; i < n; i++) {\
+ int start_pc = JCF_readu2 (jcf); \
+ int line_number = JCF_readu2 (jcf); \
+ fprintf (out, " line: %d at pc: %d\n", line_number, start_pc); }\
+ else \
+ JCF_SKIP (jcf, 4 * n); }
+
+#define PROCESS_OTHER_ATTRIBUTE(JCF, INDEX, LENGTH) \
+{ COMMON_HANDLE_ATTRIBUTE(JCF, INDEX, LENGTH); \
+ fputc ('\n', out); JCF_SKIP (JCF, LENGTH); }
+
+#define START_FINAL_ATTRIBUTES(ATTRIBUTES_COUNT) \
+ if (flag_print_attributes > 0) \
+ fprintf (out, "\nAttributes (count: %d):\n", attributes_count);
+
+#include "javaop.h"
+#include "jcf-reader.c"
+
+static void
+DEFUN(print_constant_ref, (stream, jcf, index),
+ FILE *stream AND JCF *jcf AND int index)
+{
+ fprintf (stream, "#%d=<", index);
+ if (index <= 0 || index >= JPOOL_SIZE(jcf))
+ fprintf (stream, "out of range");
+ else
+ print_constant (stream, jcf, index, 1);
+ fprintf (stream, ">", index);
+}
+
+static int
+DEFUN (print_access_flags, (stream, flags),
+ FILE *stream AND uint16 flags)
+{
+ if (flags & ACC_PUBLIC) fprintf (stream, " public");
+ if (flags & ACC_PRIVATE) fprintf (stream, " private");
+ if (flags & ACC_PROTECTED) fprintf (stream, " protected");
+ if (flags & ACC_STATIC) fprintf (stream, " static");
+ if (flags & ACC_FINAL) fprintf (stream, " final");
+ if (flags & ACC_SYNCHRONIZED) fprintf (stream, " synchronized");
+ if (flags & ACC_VOLATILE) fprintf (stream, " volatile");
+ if (flags & ACC_TRANSIENT) fprintf (stream, " transient");
+ if (flags & ACC_NATIVE) fprintf (stream, " native");
+ if (flags & ACC_INTERFACE) fprintf (stream, " interface");
+ if (flags & ACC_ABSTRACT) fprintf (stream, " abstract");
+}
+
+
+static void
+DEFUN(print_name, (stream, jcf, name_index),
+ FILE* stream AND JCF* jcf AND int name_index)
+{
+ if (JPOOL_TAG (jcf, name_index) != CONSTANT_Utf8)
+ fprintf (stream, "<not a UTF8 constant>");
+ else
+ jcf_print_utf8 (stream, JPOOL_UTF_DATA (jcf,name_index),
+ JPOOL_UTF_LENGTH (jcf, name_index));
+}
+
+/* If the type of the constant at INDEX matches EXPECTED,
+ print it tersely, otherwise more verbosely. */
+
+void
+DEFUN(print_constant_terse, (out, jcf, index, expected),
+ FILE *out AND JCF *jcf AND int index AND int expected)
+{
+ if (JPOOL_TAG (jcf, index) != expected)
+ {
+ fprintf (out, "<Unexpected constant type ");
+ print_constant (out, jcf, index, 1);
+ fprintf (out, ">");
+ }
+ else
+ print_constant (out, jcf, index, 0);
+}
+
+/* Print the constant at INDEX in JCF's constant pool.
+ If verbosity==0, print very tersely (no extraneous text).
+ If verbosity==1, prefix the type of the constant.
+ If verbosity==2, add more descriptive text. */
+
+static void
+DEFUN(print_constant, (out, jcf, index, verbosity),
+ FILE *out AND JCF *jcf AND int index AND int verbosity)
+{
+ int j, n;
+ jlong num;
+ char *str;
+ int kind = JPOOL_TAG (jcf, index);
+ switch (kind)
+ {
+ case CONSTANT_Class:
+ n = JPOOL_USHORT1 (jcf, index);
+ if (verbosity > 0)
+ fprintf (out, verbosity > 1 ? "Class name: %d=" : "Class ", n);
+ if (! CPOOL_INDEX_IN_RANGE (&jcf->cpool, n))
+ fprintf (out, "<out of range>");
+ else if (verbosity < 2 && JPOOL_TAG (jcf, n) == CONSTANT_Utf8)
+ {
+ int len = JPOOL_UTF_LENGTH (jcf, n);
+ jcf_print_utf8_replace (out, JPOOL_UTF_DATA(jcf,n), len, '/', '.');
+ }
+ else
+ print_constant_terse (out, jcf, n, CONSTANT_Utf8);
+ break;
+ case CONSTANT_Fieldref:
+ str = "Field"; goto field_or_method;
+ case CONSTANT_Methodref:
+ str = "Method"; goto field_or_method;
+ case CONSTANT_InterfaceMethodref:
+ str = "InterfaceMethod"; goto field_or_method;
+ field_or_method:
+ {
+ uint16 tclass = JPOOL_USHORT1 (jcf, index);
+ uint16 name_and_type = JPOOL_USHORT2 (jcf, index);
+ if (verbosity == 2)
+ fprintf (out, "%sref class: %d=", str, tclass);
+ else if (verbosity > 0)
+ fprintf (out, "%s ", str);
+ print_constant_terse (out, jcf, tclass, CONSTANT_Class);
+ fprintf (out, verbosity < 2 ? "." : " name_and_type: %d=<",
+ name_and_type);
+ print_constant_terse (out, jcf, name_and_type, CONSTANT_NameAndType);
+ if (verbosity == 2)
+ fputc ('>', out);
+ }
+ break;
+ case CONSTANT_String:
+ j = JPOOL_USHORT1 (jcf, index);
+ if (verbosity > 0)
+ fprintf (out, verbosity > 1 ? "String %d=" : "String ", j);
+ print_constant_terse (out, jcf, j, CONSTANT_Utf8);
+ break;
+ case CONSTANT_Integer:
+ if (verbosity > 0)
+ fprintf (out, "Integer ");
+ num = JPOOL_INT (jcf, index);
+ goto integer;
+ case CONSTANT_Long:
+ if (verbosity > 0)
+ fprintf (out, "Long ");
+ num = JPOOL_LONG (jcf, index);
+ goto integer;
+ integer:
+ {
+ char buffer[25];
+ format_int (buffer, num, 10);
+ fprintf (out, "%s", buffer);
+ if (verbosity > 1)
+ {
+ format_uint (buffer, (uint64)num, 16);
+ fprintf (out, "=0x%s", buffer);
+ }
+ }
+ break;
+ case CONSTANT_Float:
+ {
+ jfloat fnum = JPOOL_FLOAT (jcf, index);
+ fprintf (out, "%s%.10g", verbosity > 1 ? "Float " : "", (double) fnum);
+ if (verbosity > 1)
+ fprintf (out, ", bits = 0x%08lx", (long) (* (int32 *) &fnum));
+ break;
+ }
+ case CONSTANT_Double:
+ {
+ jdouble dnum = JPOOL_DOUBLE (jcf, index);
+ fprintf (out, "%s%.20g", verbosity > 1 ? "Double " : "", dnum);
+ if (verbosity > 1)
+ {
+ int32 hi, lo;
+ hi = JPOOL_UINT (jcf, index);
+ lo = JPOOL_UINT (jcf, index + 1);
+ fprintf (out, ", bits = 0x%08lx%08lx", (long) hi, (long) lo);
+ }
+ break;
+ }
+ case CONSTANT_NameAndType:
+ {
+ uint16 name = JPOOL_USHORT1 (jcf, index);
+ uint16 sig = JPOOL_USHORT2 (jcf, index);
+ if (verbosity > 0)
+ fprintf (out, verbosity > 1 ? "%s name: %d=" : "%s ",
+ "NameAndType", name);
+ print_name (out, jcf, name);
+ if (verbosity <= 1)
+ fputc (' ', out);
+ else
+ fprintf (out, ", signature: %d=", sig);
+ print_signature (out, jcf, sig, 0);
+ }
+ break;
+ case CONSTANT_Utf8:
+ {
+ register unsigned char *str = JPOOL_UTF_DATA (jcf, index);
+ int length = JPOOL_UTF_LENGTH (jcf, index);
+ if (verbosity > 0)
+ { /* Print as 8-bit bytes. */
+ fputs ("Utf8: \"", out);
+ while (--length >= 0)
+ jcf_print_char (out, *str++);
+ }
+ else
+ { /* Print as Unicode. */
+ fputc ('\"', out);
+ jcf_print_utf8 (out, str, length);
+ }
+ fputc ('\"', out);
+ }
+ break;
+ default:
+ fprintf (out, "(Unknown constant type %d)", kind);
+ }
+}
+
+void
+DEFUN(print_constant_pool, (jcf),
+ JCF *jcf)
+{
+ int i;
+ for (i = 1; i < JPOOL_SIZE(jcf); i++)
+ {
+ int kind = JPOOL_TAG (jcf, i);
+ fprintf (out, "#%d: ", i);
+ print_constant (out, jcf, i, 2);
+ fprintf (out, "\n");
+ if (kind == CONSTANT_Double || kind == CONSTANT_Long)
+ i++; /* These take up two slots in the constant table */
+ }
+}
+
+static void
+DEFUN(print_signature_type, (stream, ptr, limit),
+ FILE* stream AND const unsigned char **ptr AND const unsigned char *limit)
+{
+ int array_size;
+ if ((*ptr) >= limit)
+ return;
+ switch (*(*ptr))
+ {
+ case '[':
+ array_size = -1;
+ for ((*ptr)++; (*ptr) < limit && isdigit (**ptr); (*ptr)++)
+ {
+ int digit =
+ array_size = (array_size < 0 ? 0 : 10 * array_size) + *(*ptr) - '0';
+ }
+ print_signature_type (stream, ptr, limit);
+ if (array_size == -1)
+ fprintf (stream, "[]");
+ else
+ fprintf (stream, "[%d]", array_size);
+ break;
+ case '(':
+ {
+ int nargs = 0;
+ fputc (*(*ptr)++, stream);
+ for (; **ptr != ')' && *ptr < limit; nargs++)
+ {
+ if (nargs > 0)
+ fputc (',', stream);
+ print_signature_type (stream, ptr, limit);
+ }
+ if (*ptr < limit)
+ {
+ fputc (*(*ptr)++, stream);
+ print_signature_type (stream, ptr, limit);
+ }
+ else
+ fprintf (stream, "???");
+ }
+ break;
+
+ case 'B': fprintf (stream, "byte"); (*ptr)++; break;
+ case 'C': fprintf (stream, "char"); (*ptr)++; break;
+ case 'D': fprintf (stream, "double"); (*ptr)++; break;
+ case 'F': fprintf (stream, "float"); (*ptr)++; break;
+ case 'S': fprintf (stream, "short"); (*ptr)++; break;
+ case 'I': fprintf (stream, "int"); (*ptr)++; break;
+ case 'J': fprintf (stream, "long"); (*ptr)++; break;
+ case 'Z': fprintf (stream, "boolean"); (*ptr)++; break;
+ case 'V': fprintf (stream, "void"); (*ptr)++; break;
+
+ case 'L':
+ for ((*ptr)++; (*ptr)<limit && *(*ptr) != ';'; (*ptr)++)
+ jcf_print_char (stream, *(*ptr) == '/' ? '.' : *(*ptr));
+ if (*(*ptr) == ';')
+ (*ptr)++;
+ break;
+ default:
+ jcf_print_char (stream, *(*ptr)++);
+ }
+}
+
+static void
+DEFUN(print_signature, (stream, jcf, signature_index, int options),
+ FILE* stream AND JCF *jcf AND int signature_index AND int options)
+{
+ if (JPOOL_TAG (jcf, signature_index) != CONSTANT_Utf8)
+ print_constant_terse (out, jcf, signature_index, CONSTANT_Utf8);
+ else
+ {
+ int j;
+ const unsigned char *str = JPOOL_UTF_DATA (jcf, signature_index);
+ int length = JPOOL_UTF_LENGTH (jcf, signature_index);
+ const unsigned char *limit;
+ limit = str + length;
+ if (str >= limit)
+ fprintf (stream, "<empty signature string>");
+ else
+ {
+ if (options & PRINT_SIGNATURE_RESULT_ONLY)
+ {
+ while (str < limit && *str++ != ')') ;
+ }
+ if (options & PRINT_SIGNATURE_ARGS_ONLY)
+ {
+ *str++;
+ fputc ('(', stream);
+ while (str < limit && *str != ')')
+ {
+ print_signature_type (stream, &str, limit);
+ if (*str != ')')
+ fputs (", ", stream);
+ }
+ fputc (')', stream);
+ }
+ else
+ {
+ print_signature_type (stream, &str, limit);
+ if (str < limit)
+ {
+ fprintf (stream, "<junk:");
+ jcf_print_utf8 (stream, str, limit - str);
+ fputc ('>', stream);
+ }
+ }
+ }
+ }
+}
+
+int
+DEFUN (usage, (), )
+{
+ fprintf (stderr, "Usage: jcf-dump [-o outputfile] [-c] classname\n");
+ exit(1);
+}
+
+void
+DEFUN(process_class, (jcf),
+ JCF *jcf)
+{
+ int code;
+ if (jcf_parse_preamble (jcf) != 0)
+ fprintf (stderr, "Not a valid Java .class file.\n");
+
+ /* Parse and possibly print constant pool */
+ code = jcf_parse_constant_pool (jcf);
+ if (code != 0)
+ {
+ fprintf (stderr, "error while parsing constant pool\n");
+ exit (-1);
+ }
+ code = verify_constant_pool (jcf);
+ if (code > 0)
+ {
+ fprintf (stderr, "error in constant pool entry #%d\n", code);
+ exit (-1);
+ }
+ if (flag_print_constant_pool)
+ print_constant_pool (jcf);
+
+ jcf_parse_class (jcf);
+ code = jcf_parse_fields (jcf);
+ if (code != 0)
+ {
+ fprintf (stderr, "error while parsing fields\n");
+ exit (-1);
+ }
+ code = jcf_parse_methods (jcf);
+ if (code != 0)
+ {
+ fprintf (stderr, "error while parsing methods\n");
+ exit (-1);
+ }
+ code = jcf_parse_final_attributes (jcf);
+ if (code != 0)
+ {
+ fprintf (stderr, "error while parsing final attributes\n");
+ exit (-1);
+ }
+ jcf->filename = NULL;
+}
+
+int
+DEFUN(main, (argc, argv),
+ int argc AND char** argv)
+{
+ JCF jcf[1];
+ int argi;
+ if (argc <= 1)
+ usage ();
+
+ for (argi = 1; argi < argc; argi++)
+ {
+ char *arg = argv[argi];
+ if (arg[0] == '-')
+ {
+ if (strcmp (arg, "-o") == 0 && argi + 1 < argc)
+ output_file = argv[++argi];
+ else if (arg[1] == '-')
+ {
+ arg++;
+ if (strcmp (arg, "-classpath") == 0 && argi + 1 < argc)
+ classpath = argv[++argi];
+ else if (strcmp (arg, "-verbose") == 0)
+ verbose++;
+ else if (strcmp (arg, "-print-main") == 0)
+ flag_print_main++;
+ else if (strcmp (arg, "-javap") == 0)
+ {
+ flag_javap_compatible++;
+ flag_print_constant_pool = 0;
+ }
+ else if (arg[2] == '\0')
+ break;
+ else
+ {
+ fprintf (stderr, "%s: illegal argument\n", argv[argi]);
+ exit (-1);
+ }
+
+ }
+ else if (strcmp (arg, "-classpath") == 0 && argi + 1 < argc)
+ classpath = argv[++argi];
+ else if (strcmp (arg, "-verbose") == 0)
+ verbose++;
+ else if (strcmp (arg, "-print-main") == 0)
+ flag_print_main++;
+ else if (strcmp (arg, "-c") == 0)
+ flag_disassemble_methods++;
+ else
+ {
+ fprintf (stderr, "%s: illegal argument\n", argv[argi]);
+ exit (-1);
+ }
+ }
+ else
+ break;
+ }
+ if (argi == argc)
+ usage ();
+ if (flag_print_main)
+ {
+ flag_print_fields = 0;
+ flag_print_methods = 0;
+ flag_print_constant_pool = 0;
+ flag_print_attributes = 0;
+ flag_print_class_info = 0;
+ }
+
+ if (classpath == NULL)
+ {
+ classpath = (char *) getenv ("CLASSPATH");
+ if (classpath == NULL)
+ classpath = "";
+ }
+
+ if (output_file)
+ {
+ out = fopen (output_file, "w");
+ if (out)
+ {
+ fprintf (stderr, "Cannot open '%s' for output.\n", output_file);
+ exit (-1);
+ }
+ }
+ else
+ out = stdout;
+
+ if (argi >= argc)
+ {
+ fprintf (out, "Reading .class from <standard input>.\n");
+#if JCF_USE_STDIO
+ open_class ("<stdio>", jcf, stdin);
+#else
+ open_class ("<stdio>", jcf, 0);
+#endif
+ process_class (jcf);
+ }
+ else
+ {
+ for (; argi < argc; argi++)
+ {
+ char *arg = argv[argi];
+ char* class_filename = find_class (arg, strlen (arg), jcf, 1);
+ if (class_filename == NULL)
+ class_filename = find_classfile (arg, jcf);
+ if (class_filename == NULL)
+ {
+ perror ("Could not find class");
+ exit (-1);
+ }
+ JCF_FILL (jcf, 4);
+ if (GET_u4 (jcf->read_ptr) == ZIPMAGIC)
+ {
+ long compressed_size, member_size;
+ int compression_method, filename_length, extra_length;
+ int general_purpose_bits;
+ char *filename;
+ int total_length;
+ if (flag_print_class_info)
+ fprintf (out, "Reading classes from archive %s.\n",
+ class_filename);
+ for (;;)
+ {
+ int skip = 0;
+ jcf_filbuf_t save_filbuf = jcf->filbuf;
+ long magic = JCF_readu4_le (jcf);
+ if (magic == 0x02014b50 || magic == 0x06054b50)
+ break; /* got to central directory */
+ if (magic != 0x04034b50) /* ZIPMAGIC (little-endian) */
+ {
+ fprintf (stderr, "bad format of .zip archine\n");
+ exit (-1);
+ }
+ JCF_FILL (jcf, 26);
+ JCF_SKIP (jcf, 2);
+ general_purpose_bits = JCF_readu2_le (jcf);
+ compression_method = JCF_readu2_le (jcf);
+ JCF_SKIP (jcf, 8);
+ compressed_size = JCF_readu4_le (jcf);
+ member_size = JCF_readu4_le (jcf);
+ filename_length = JCF_readu2_le (jcf);
+ extra_length = JCF_readu2_le (jcf);
+ total_length = filename_length + extra_length
+ + compressed_size;
+ if (jcf->read_end - jcf->read_ptr < total_length)
+ jcf_trim_old_input (jcf);
+ JCF_FILL (jcf, total_length);
+ filename = jcf->read_ptr;
+ JCF_SKIP (jcf, filename_length);
+ JCF_SKIP (jcf, extra_length);
+ if (filename_length > 0
+ && filename[filename_length-1] == '/')
+ {
+ if (flag_print_class_info)
+ fprintf (out, "[Skipping directory %.*s]\n",
+ filename_length, filename);
+ skip = 1;
+ }
+ else if (compression_method != 0)
+ {
+ if (flag_print_class_info)
+ fprintf (out, "[Skipping compressed file %.*s]\n",
+ filename_length, filename);
+ skip = 1;
+ }
+ else if (member_size < 4
+ || GET_u4 (jcf->read_ptr) != 0xcafebabe)
+ {
+ if (flag_print_class_info)
+ fprintf (out, "[Skipping non-.class member %.*s]\n",
+ filename_length, filename);
+ skip = 1;
+ }
+ else
+ {
+ if (flag_print_class_info)
+ fprintf (out, "Reading class member: %.*s.\n",
+ filename_length, filename);
+ }
+ if (skip)
+ {
+ JCF_SKIP (jcf, compressed_size);
+ }
+ else
+ {
+ unsigned char *save_end;
+ jcf->filbuf = jcf_unexpected_eof;
+ save_end = jcf->read_end;
+ jcf->read_end = jcf->read_ptr + compressed_size;
+ process_class (jcf);
+ jcf->filbuf = save_filbuf;
+ jcf->read_end = save_end;
+ }
+ }
+ }
+ else
+ {
+ if (flag_print_class_info)
+ fprintf (out, "Reading .class from %s.\n", class_filename);
+ process_class (jcf);
+ }
+ JCF_FINISH(jcf);
+ }
+ }
+}
+
+static void
+DEFUN(disassemble_method, (jcf, byte_ops, len),
+ JCF* jcf AND unsigned char *byte_ops AND int len)
+{
+#undef AND /* Causes problems with opcodes for iand and land. */
+#undef PTR
+ int PC;
+ int i;
+ if (flag_disassemble_methods == 0)
+ return;
+#define BCODE byte_ops
+ for (PC = 0; PC < len;)
+ {
+ int oldpc = PC;
+ int saw_index;
+ jlong LONG_temp;
+ jint INT_temp;
+ jfloat FLOAT_temp;
+ jdouble DOUBLE_temp;
+ switch (byte_ops[PC++])
+ {
+
+/* This is the actual code emitted for each of opcodes in javaops.def.
+ The actual opcode-specific stuff is handled by the OPKIND macro.
+ I.e. for an opcode whose OPKIND is BINOP, the BINOP will be called.
+ Those macros are defiend below. The OPKINDs that do not have any
+ inline parameters (such as BINOP) and therefore do mot need anything
+ else to me printed out just use an empty body. */
+
+#define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
+ case OPCODE: \
+ fprintf (out, "%3d: %s", oldpc, #OPNAME); \
+ OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
+ fputc ('\n', out); \
+ break;
+
+#define CONST_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
+#define CONST_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
+#define VAR_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
+#define VAR_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
+
+#define CHECK_PC_IN_RANGE(PC) (PC < 0 || PC > len ? \
+ (fprintf(stderr, "Bad byte codes.\n"), exit(-1)) : 1)
+
+/* Print out operand (if not implied by the opcode) for PUSCH opcodes.
+ These all push a constant onto the opcode stack. */
+#define PUSHC(OPERAND_TYPE, OPERAND_VALUE) \
+ saw_index = 0, INT_temp = (OPERAND_VALUE); \
+ if (oldpc+1 == PC) /* nothing */; \
+ else if (saw_index) fprintf (out, " "), print_constant_ref (out, jcf, INT_temp); \
+ else fprintf (out, " %d", INT_temp);
+
+/* Print out operand (a local variable index) for LOAD opcodes.
+ These all push local variable onto the opcode stack. */
+#define LOAD(OPERAND_TYPE, OPERAND_VALUE) \
+ INT_temp = (OPERAND_VALUE); \
+ if (oldpc+1 == PC) /* nothing - local index implied by opcode */; \
+ else fprintf (out, " %d", INT_temp);
+
+/* Handle STORE opcodes same as LOAD opcodes.
+ These all store a value from the opcode stack in a local variable. */
+#define STORE LOAD
+
+/* Handle more kind of opcodes. */
+#define STACK(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+#define UNOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+#define BINOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+#define CONVERT(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+#define CONVERT2(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+#define RETURN(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+#define UNKNOWN(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
+
+/* Handle putfield and getfield opcodes, with static versions. */
+#define FIELD(MAYBE_STATIC, PUT_OR_GET) \
+ fputc (' ', out); print_constant_ref (out, jcf, IMMEDIATE_u2)
+
+/* Print operand for invoke opcodes. */
+#define INVOKE(OPERAND_TYPE, OPERAND_VALUE) \
+ fputc (' ', out); print_constant_ref (out, jcf, IMMEDIATE_u2);\
+ PC += 2 * OPERAND_VALUE /* for invokeinterface */;
+
+#define OBJECT(OPERAND_TYPE, OPERAND_VALUE) \
+ fputc (' ', out); print_constant_ref (out, jcf, IMMEDIATE_u2);
+
+#define ARRAY(OPERAND_TYPE, SUBOP) \
+ ARRAY_##SUBOP(OPERAND_TYPE)
+/* Handle sub-categories of ARRAY opcodes. */
+#define ARRAY_LOAD(TYPE) /* nothing */
+#define ARRAY_STORE(TYPE) /* nothing */
+#define ARRAY_LENGTH(TYPE) /* nothing */
+#define ARRAY_NEW(TYPE) ARRAY_NEW_##TYPE
+#define ARRAY_NEW_NUM \
+ INT_temp = IMMEDIATE_u1; \
+ { char *str; \
+ switch (INT_temp) { \
+ case 4: str = "boolean"; break; \
+ case 5: str = "char"; break; \
+ case 6: str = "float"; break; \
+ case 7: str = "double"; break; \
+ case 8: str = "byte"; break; \
+ case 9: str = "short"; break; \
+ case 10: str = "int"; break; \
+ case 11: str = "long"; break; \
+ default: str = "<unknown type code %d>"; break; \
+ } \
+ fputc (' ', out); fprintf (out, str, INT_temp); }
+
+#define ARRAY_NEW_PTR \
+ fputc (' ', out); print_constant_ref (out, jcf, IMMEDIATE_u2);
+
+#define ARRAY_NEW_MULTI \
+ fputc (' ', out); print_constant_ref (out, jcf, IMMEDIATE_u2); \
+ fprintf (out, " %d", IMMEDIATE_u1); /* number of dimensions */
+
+#define TEST(OPERAND_TYPE, OPERAND_VALUE) \
+ fprintf (out, " %d", oldpc + IMMEDIATE_s2)
+
+#define BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
+ saw_index = 0, INT_temp = (OPERAND_VALUE); \
+ fprintf (out, " %d", saw_index ? INT_temp : oldpc + INT_temp)
+
+#define JSR(OPERAND_TYPE, OPERAND_VALUE) \
+ saw_index = 0, INT_temp = (OPERAND_VALUE); \
+ fprintf (out, " %d", saw_index ? INT_temp : oldpc + INT_temp)
+
+#define RET(OPERAND_TYPE, OPERAND_VALUE) \
+ INT_temp = (OPERAND_VALUE); \
+ fprintf (out, " %d", INT_temp);
+
+#define SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
+ PC = (PC + 3) / 4 * 4; TABLE_OR_LOOKUP##_SWITCH
+
+#define LOOKUP_SWITCH \
+ { jint default_offset = IMMEDIATE_s4; jint npairs = IMMEDIATE_s4; \
+ fprintf (out, " npairs=%d, default=%d", npairs, default_offset+oldpc); \
+ while (--npairs >= 0) { \
+ jint match = IMMEDIATE_s4; jint offset = IMMEDIATE_s4; \
+ fprintf (out, "\n%10ld: %ld", (long)match, (long)(offset+oldpc)); } \
+ }
+
+#define TABLE_SWITCH \
+ { jint default_offset = IMMEDIATE_s4; \
+ jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4; \
+ fprintf (out, " low==%d, high=%ddefault=%d", \
+ low, high, default_offset+oldpc); \
+ for (; low <= high; low++) { \
+ jint offset = IMMEDIATE_s4; \
+ fprintf (out, "\n%10ld: %ld", (long)low, (long)(offset+oldpc)); } \
+ }
+
+#define SPECIAL(OPERAND_TYPE, OPERAND_VALUE) \
+ SPECIAL_##OPERAND_VALUE(OPERAND_TYPE)
+
+#define SPECIAL_IINC(OPERAND_TYPE) \
+ INT_temp = IMMEDIATE_u1; \
+ fprintf (out, "%d %d", INT_temp, IMMEDIATE_s1)
+
+#define SPECIAL_WIDE(OPERAND_TYPE) \
+ INT_temp = IMMEDIATE_u1; fprintf (out, "%d", INT_temp)
+
+#define SPECIAL_EXIT(OPERAND_TYPE) /* nothing */
+#define SPECIAL_ENTER(OPERAND_TYPE) /* nothing */
+#define SPECIAL_BREAK(OPERAND_TYPE) /* nothing */
+#define SPECIAL_THROW(OPERAND_TYPE) /* nothing */
+
+#define IMPL(OPERAND_TYPE, OPERAND_VALUE) \
+ fprintf (out, " %d", IMMEDIATE_u##OPERAND_VALUE)
+
+#define COND(OPERAND_TYPE, OPERAND_VALUE) \
+ TEST(OPERAND_TYPE, OPERAND_VALUE)
+
+#include "javaop.def"
+ default:
+ fprintf (out, "%3d: unknown(%3d)\n", oldpc, byte_ops[PC]);
+ }
+ }
+
+ /* Print exception table. */
+ i = GET_u2(byte_ops+len);
+ if (i > 0)
+ {
+ unsigned char *ptr = byte_ops+len+2;
+ fprintf (out, "Exceptions (count: %d):\n", i);
+ for (; --i >= 0; ptr+= 8)
+ {
+ int start_pc = GET_u2 (ptr);
+ int end_pc = GET_u2 (ptr+2);
+ int handler_pc = GET_u2 (ptr+4);
+ int catch_type = GET_u2 (ptr+6);
+ fprintf (out, " start: %d, end: %d, handler: %d, type: %d",
+ start_pc, end_pc, handler_pc, catch_type);
+ if (catch_type == 0)
+ fputs (" /* finally */", out);
+ else
+ {
+ fputc('=', out);
+ print_constant_terse (out, jcf, catch_type, CONSTANT_Class);
+ }
+ fputc ('\n', out);
+ }
+ }
+}
--- /dev/null
+/* Utility routines for finding and reading Java(TM) .class files.
+ Copyright (C) 1996 Free Software Foundation, Inc.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
+
+#include <stdio.h>
+
+#define ENABLE_UNZIP 1
+
+#include "jcf.h"
+#ifdef __STDC__
+#include <stdlib.h>
+#endif
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <fcntl.h>
+
+/* DOS brain-damage */
+#ifndef O_BINARY
+#define O_BINARY 0 /* MS-DOS brain-damage */
+#endif
+
+char *classpath;
+
+int
+DEFUN(jcf_unexpected_eof, (jcf, count),
+ JCF *jcf AND int count)
+{
+ if (jcf->filename)
+ fprintf (stderr, "Premature end of .class file %s.\n", jcf->filename);
+ else
+ fprintf (stderr, "Premature end of .class file <stdin>.\n");
+ exit (-1);
+}
+
+void
+DEFUN(jcf_trim_old_input, (jcf),
+ JCF *jcf)
+{
+ int count = jcf->read_ptr - jcf->buffer;
+ if (count > 0)
+ {
+ memmove (jcf->buffer, jcf->read_ptr, jcf->read_end - jcf->read_ptr);
+ jcf->read_ptr -= count;
+ jcf->read_end -= count;
+ }
+}
+
+int
+DEFUN(jcf_filbuf_from_stdio, (jcf, count),
+ JCF *jcf AND int count)
+{
+ FILE *file = (FILE*) (jcf->read_state);
+ if (count > jcf->buffer_end - jcf->read_ptr)
+ {
+ JCF_u4 old_read_ptr = jcf->read_ptr - jcf->buffer;
+ JCF_u4 old_read_end = jcf->read_end - jcf->buffer;
+ JCF_u4 old_size = jcf->buffer_end - jcf->buffer;
+ JCF_u4 new_size = (old_size == 0 ? 2000 : 2 * old_size) + count;
+ unsigned char *new_buffer = jcf->buffer == NULL ? ALLOC (new_size)
+ : REALLOC (jcf->buffer, new_size);
+ jcf->buffer = new_buffer;
+ jcf->buffer_end = new_buffer + new_size;
+ jcf->read_ptr = new_buffer + old_read_ptr;
+ jcf->read_end = new_buffer + old_read_end;
+ }
+ count -= jcf->read_end - jcf->read_ptr;
+ if (count <= 0)
+ return 0;
+ if (fread (jcf->read_end, 1, count, file) != count)
+ jcf_unexpected_eof (jcf, count);
+ jcf->read_end += count;
+ return 0;
+}
+
+#if ENABLE_UNZIP
+#include "zipfile.h"
+
+struct ZipFileCache *SeenZipFiles = NULL;
+
+int
+DEFUN(open_in_zip, (jcf,
+zipfile, zipmember),
+ JCF *jcf AND const char *zipfile AND const char *zipmember)
+{
+ struct ZipFileCache* zipf;
+ ZipDirectory *zipd;
+ int i, len;
+ for (zipf = SeenZipFiles; ; zipf = zipf->next)
+ {
+ if (zipf == NULL)
+ {
+ char magic [4];
+ int fd = open (zipfile, O_RDONLY | O_BINARY);
+ if (read (fd, magic, 4) != 4 || GET_u4 (magic) != (JCF_u4)ZIPMAGIC)
+ return -1;
+ lseek (fd, 0L, SEEK_SET);
+ zipf = ALLOC (sizeof (struct ZipFileCache) + strlen (zipfile) + 1);
+ zipf->next = SeenZipFiles;
+ zipf->name = (char*)(zipf+1);
+ strcpy (zipf->name, zipfile);
+ SeenZipFiles = zipf;
+ zipf->z.fd = fd;
+ if (fd == -1)
+ {
+ /* A missing zip file is not considered an error. */
+ zipf->z.count = 0;
+ zipf->z.dir_size = 0;
+ zipf->z.central_directory = NULL;
+ return -1;
+ }
+ else
+ {
+ if (read_zip_archive (&zipf->z) != 0)
+ return -2; /* This however should be an error - FIXME */
+ }
+ break;
+ }
+ if (strcmp (zipf->name, zipfile) == 0)
+ break;
+ }
+
+ if (!zipmember)
+ return 0;
+
+ len = strlen (zipmember);
+
+ zipd = (struct ZipDirectory*) zipf->z.central_directory;
+ for (i = 0; i < zipf->z.count; i++, zipd = ZIPDIR_NEXT (zipd))
+ {
+ if (len == zipd->filename_length &&
+ strncmp (ZIPDIR_FILENAME (zipd), zipmember, len) == 0)
+ {
+ JCF_ZERO (jcf);
+ jcf->buffer = ALLOC (zipd->size);
+ jcf->buffer_end = jcf->buffer + zipd->size;
+ jcf->read_ptr = jcf->buffer;
+ jcf->read_end = jcf->buffer_end;
+ jcf->filbuf = jcf_unexpected_eof;
+ jcf->filename = (char *) strdup (zipfile);
+ jcf->classname = (char *) strdup (zipmember);
+ jcf->zipd = (void *)zipd;
+ if (lseek (zipf->z.fd, zipd->filestart, 0) < 0
+ || read (zipf->z.fd, jcf->buffer, zipd->size) != zipd->size)
+ return -2;
+ return 0;
+ }
+ }
+ return -1;
+}
+#endif /* ENABLE_UNZIP */
+
+#if JCF_USE_STDIO
+char*
+DEFUN(open_class, (filename, jcf, stream),
+ char *filename AND JCF *jcf AND FILE* stream)
+{
+ if (jcf)
+ {
+ JCF_ZERO (jcf);
+ jcf->buffer = NULL;
+ jcf->buffer_end = NULL;
+ jcf->read_ptr = NULL;
+ jcf->read_end = NULL;
+ jcf->read_state = stream;
+ jcf->filbuf = jcf_filbuf_from_stdio;
+ }
+ else
+ fclose (stream);
+ return filename;
+}
+#else
+char*
+DEFUN(open_class, (filename, jcf, fd),
+ char *filename AND JCF *jcf AND int fd)
+{
+ if (jcf)
+ {
+ struct stat stat_buf;
+ if (fstat (fd, &stat_buf) != 0
+ || ! S_ISREG (stat_buf.st_mode))
+ {
+ perror ("Could not figure length of .class file");
+ return NULL;
+ }
+ JCF_ZERO (jcf);
+ jcf->buffer = ALLOC (stat_buf.st_size);
+ jcf->buffer_end = jcf->buffer + stat_buf.st_size;
+ jcf->read_ptr = jcf->buffer;
+ jcf->read_end = jcf->buffer_end;
+ jcf->read_state = NULL;
+ jcf->filename = filename;
+ if (read (fd, jcf->buffer, stat_buf.st_size) != stat_buf.st_size)
+ {
+ perror ("Failed to read .class file");
+ return NULL;
+ }
+ close (fd);
+ jcf->filbuf = jcf_unexpected_eof;
+ }
+ else
+ close (fd);
+ return filename;
+}
+#endif
+
+
+char *
+DEFUN(find_classfile, (filename_length, jcf),
+ char *filename AND JCF *jcf)
+{
+#if JCF_USE_STDIO
+ FILE *stream = fopen (filename, "rb");
+ if (stream == NULL)
+ return NULL;
+ return open_class (arg, jcf, stream);
+#else
+ int fd = open (filename, O_RDONLY | O_BINARY);
+ if (fd < 0)
+ return NULL;
+ return open_class (filename, jcf, fd);
+#endif
+}
+
+/* Returns a freshly malloc'd string with the fully qualified pathname
+ of the .class file for the class CLASSNAME. Returns NULL on
+ failure. If JCF != NULL, it is suitably initialized. With
+ DO_CLASS_FILE set to 1, search a .class/.java file named after
+ CLASSNAME, otherwise, search a ZIP directory entry named after
+ CLASSNAME. */
+
+char *
+DEFUN(find_class, (classname, classname_length, jcf, do_class_file),
+ const char *classname AND int classname_length AND JCF *jcf AND int do_class_file)
+
+{
+#if JCF_USE_STDIO
+ FILE *stream;
+#else
+ int fd;
+#endif
+ int i, j, k, java, class;
+ struct stat java_buf, class_buf;
+
+ /* Allocate and zero out the buffer, since we don't explicitly put a
+ null pointer when we're copying it below. */
+ int buflen = strlen (classpath) + classname_length + 10;
+ char *buffer = (char *) ALLOC (buflen);
+ bzero (buffer, buflen);
+
+ jcf->java_source = jcf->outofsynch = 0;
+ for (j = 0; classpath[j] != '\0'; )
+ {
+ for (i = 0; classpath[j] != ':' && classpath[j] != '\0'; i++, j++)
+ buffer[i] = classpath[j];
+ if (classpath[j] == ':')
+ j++;
+ if (i > 0) /* Empty directory is redundant */
+ {
+ int dir_len;
+ if (buffer[i-1] != '/')
+ buffer[i++] = '/';
+ dir_len = i-1;
+ for (k = 0; k < classname_length; k++, i++)
+ {
+ char ch = classname[k];
+ buffer[i] = ch == '.' ? '/' : ch;
+ }
+ if (do_class_file)
+ strcpy (buffer+i, ".class");
+#if ENABLE_UNZIP
+ if (dir_len > 4
+ && buffer[dir_len-4] == '.' && buffer[dir_len-3] == 'z'
+ && buffer[dir_len-2] == 'i' && buffer[dir_len-1] == 'p')
+ {
+ int err_code;
+ JCF _jcf;
+ if (!do_class_file)
+ strcpy (buffer+i, "/");
+ buffer[dir_len] = '\0';
+ if (do_class_file)
+ SOURCE_FRONTEND_DEBUG
+ (("Trying [...%s]:%s",
+ &buffer[dir_len-(dir_len > 15 ? 15 : dir_len)],
+ buffer+dir_len+1));
+ if (jcf == NULL)
+ jcf = &_jcf;
+ err_code = open_in_zip (jcf, buffer, buffer+dir_len+1);
+ if (err_code == 0)
+ {
+ if (!do_class_file)
+ jcf->seen_in_zip = 1;
+ else
+ {
+ buffer[dir_len] = '(';
+ strcpy (buffer+i, ".class)");
+ }
+ if (jcf == &_jcf)
+ JCF_FINISH (jcf);
+ return buffer;
+ }
+ else
+ continue;
+ }
+#endif
+ /* If we do directories, do them here */
+ if (!do_class_file)
+ {
+ struct stat dir_buff;
+ int dir;
+ buffer[i] = '\0'; /* Was previously unterminated here. */
+ if (!(dir = stat (buffer, &dir_buff)))
+ {
+ jcf->seen_in_zip = 0;
+ goto found;
+ }
+ }
+
+ /* Check for out of synch .class/.java files */
+ class = stat (buffer, &class_buf);
+ strcpy (buffer+i, ".java");
+ java = stat (buffer, &java_buf);
+ if ((!java && !class) && java_buf.st_mtime >= class_buf.st_mtime)
+ jcf->outofsynch = 1;
+#if JCF_USE_STDIO
+ if (!class)
+ {
+ strcpy (buffer+i, ".class");
+ SOURCE_FRONTEND_DEBUG (("Trying %s", buffer));
+ stream = fopen (buffer, "rb");
+ if (stream)
+ goto found;
+ }
+ /* Give .java a try, if necessary */
+ if (!java)
+ {
+ strcpy (buffer+i, ".java");
+ SOURCE_FRONTEND_DEBUG (("Trying %s", buffer));
+ stream = fopen (buffer, "r");
+ if (stream)
+ {
+ jcf->java_source = 1;
+ goto found;
+ }
+ }
+#else
+ if (!class)
+ {
+ strcpy (buffer+i, ".class");
+ SOURCE_FRONTEND_DEBUG (("Trying %s", buffer));
+ fd = open (buffer, O_RDONLY | O_BINARY);
+ if (fd >= 0)
+ goto found;
+ }
+ /* Give .java a try, if necessary */
+ if (!java)
+ {
+ if (do_class_file)
+ strcpy (buffer+i, ".java");
+ SOURCE_FRONTEND_DEBUG (("Trying %s", buffer));
+ fd = open (buffer, O_RDONLY | O_BINARY);
+ if (fd >= 0)
+ {
+ jcf->java_source = 1;
+ goto found;
+ }
+ }
+#endif
+ }
+ }
+ free (buffer);
+ return NULL;
+ found:
+#if JCF_USE_STDIO
+ if (jcf->java_source)
+ return NULL; /* FIXME */
+ else
+ return open_class (buffer, jcf, stream);
+#else
+ if (jcf->java_source)
+ {
+ JCF_ZERO (jcf); /* JCF_FINISH relies on this */
+ jcf->java_source = 1;
+ jcf->filename = (char *) strdup (buffer);
+ close (fd); /* We use STDIO for source file */
+ }
+ else if (do_class_file)
+ buffer = open_class (buffer, jcf, fd);
+ jcf->classname = (char *) ALLOC (classname_length + 1);
+ strncpy (jcf->classname, classname, classname_length + 1);
+ jcf->classname = (char *) strdup (classname);
+ return buffer;
+#endif
+}
+
+void
+DEFUN(jcf_print_char, (stream, ch),
+ FILE *stream AND int ch)
+{
+ switch (ch)
+ {
+ case '\'':
+ case '\\':
+ case '\"':
+ fprintf (stream, "\\%c", ch);
+ break;
+ case '\n':
+ fprintf (stream, "\\n");
+ break;
+ case '\t':
+ fprintf (stream, "\\t");
+ break;
+ case '\r':
+ fprintf (stream, "\\r");
+ break;
+ default:
+ if (ch >= ' ' && ch < 127)
+ putc (ch, stream);
+ else if (ch < 256)
+ fprintf (stream, "\\%03x", ch);
+ else
+ fprintf (stream, "\\u%04x", ch);
+ }
+}
+
+/* Print UTF8 string at STR of length LENGTH bytes to STREAM. */
+
+void
+DEFUN(jcf_print_utf8, (stream, str, length),
+ FILE *stream AND register unsigned char *str AND int length)
+{
+ unsigned char* limit = str + length;
+ while (str < limit)
+ {
+ int ch = UTF8_GET (str, limit);
+ if (ch < 0)
+ {
+ fprintf (stream, "\\<invalid>");
+ return;
+ }
+ jcf_print_char (stream, ch);
+ }
+}
+
+/* Same as jcf_print_utf8, but print IN_CHAR as OUT_CHAR. */
+
+void
+DEFUN(jcf_print_utf8_replace, (stream, str, length, in_char, out_char),
+ FILE *stream AND unsigned char *str AND int length
+ AND int in_char AND int out_char)
+{
+
+ int i;/* FIXME - actually handle Unicode! */
+ for (i = 0; i < length; i++)
+ {
+ int ch = str[i];
+ jcf_print_char (stream, ch == in_char ? out_char : ch);
+ }
+}
+
+/* Check that all the cross-references in the constant pool are
+ valid. Returns 0 on success.
+ Otherwise, returns the index of the (first) invalid entry. */
+
+int
+DEFUN(verify_constant_pool, (jcf),
+ JCF *jcf)
+{
+ int i, n;
+ for (i = 1; i < JPOOL_SIZE (jcf); i++)
+ {
+ switch (JPOOL_TAG (jcf, i))
+ {
+ case CONSTANT_NameAndType:
+ n = JPOOL_USHORT2 (jcf, i);
+ if (n <= 0 || n >= JPOOL_SIZE(jcf)
+ || JPOOL_TAG (jcf, n) != CONSTANT_Utf8)
+ return i;
+ /* ... fall through ... */
+ case CONSTANT_Class:
+ case CONSTANT_String:
+ n = JPOOL_USHORT1 (jcf, i);
+ if (n <= 0 || n >= JPOOL_SIZE(jcf)
+ || JPOOL_TAG (jcf, n) != CONSTANT_Utf8)
+ return i;
+ break;
+ case CONSTANT_Fieldref:
+ case CONSTANT_Methodref:
+ case CONSTANT_InterfaceMethodref:
+ n = JPOOL_USHORT1 (jcf, i);
+ if (n <= 0 || n >= JPOOL_SIZE(jcf)
+ || JPOOL_TAG (jcf, n) != CONSTANT_Class)
+ return i;
+ n = JPOOL_USHORT2 (jcf, i);
+ if (n <= 0 || n >= JPOOL_SIZE(jcf)
+ || JPOOL_TAG (jcf, n) != CONSTANT_NameAndType)
+ return i;
+ break;
+ case CONSTANT_Long:
+ case CONSTANT_Double:
+ i++;
+ break;
+ case CONSTANT_Float:
+ case CONSTANT_Integer:
+ case CONSTANT_Utf8:
+ case CONSTANT_Unicode:
+ break;
+ default:
+ return i;
+ }
+ }
+ return 0;
+}
+
+void
+DEFUN(format_uint, (buffer, value, base),
+ char *buffer AND uint64 value AND int base)
+{
+#define WRITE_BUF_SIZE (4 + sizeof(uint64) * 8)
+ char buf[WRITE_BUF_SIZE];
+ register char *buf_ptr = buf+WRITE_BUF_SIZE; /* End of buf. */
+ int chars_written;
+ int i;
+
+ /* Now do the actual conversion, placing the result at the *end* of buf. */
+ /* Note this code does not pretend to be optimized. */
+ do {
+ int digit = value % base;
+ static char digit_chars[] = "0123456789abcdefghijklmnopqrstuvwxyz";
+ *--buf_ptr = digit_chars[digit];
+ value /= base;
+ } while (value != 0);
+
+ chars_written = buf+WRITE_BUF_SIZE - buf_ptr;
+ for (i = 0; i < chars_written; i++)
+ buffer[i] = *buf_ptr++;
+ buffer[i] = 0;
+}
+
+void
+DEFUN(format_int, (buffer, value, base),
+ char *buffer AND jlong value AND int base)
+{
+ uint64 abs_value;
+ if (value < 0)
+ {
+ abs_value = -(uint64)value;
+ *buffer++ = '-';
+ }
+ else
+ abs_value = (uint64) value;
+ format_uint (buffer, abs_value, base);
+}
--- /dev/null
+/* Parser for Java(TM) .class files.
+ Copyright (C) 1996 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Written by Per Bothner <bothner@cygnus.com> */
+
+#include <stdio.h>
+#include <ctype.h>
+#include "config.h"
+#include "tree.h"
+#include "obstack.h"
+#include "flags.h"
+#include "java-except.h"
+#include "input.h"
+#include "java-tree.h"
+
+/* A CONSTANT_Utf8 element is converted to an IDENTIFIER_NODE at parse time. */
+#define JPOOL_UTF(JCF, INDEX) CPOOL_UTF(&(JCF)->cpool, INDEX)
+#define JPOOL_UTF_LENGTH(JCF, INDEX) IDENTIFIER_LENGTH (JPOOL_UTF (JCF, INDEX))
+#define JPOOL_UTF_DATA(JCF, INDEX) \
+ ((unsigned char*) IDENTIFIER_POINTER (JPOOL_UTF (JCF, INDEX)))
+#define HANDLE_CONSTANT_Utf8(JCF, INDEX, LENGTH) \
+ do { \
+ unsigned char save; unsigned char *text; \
+ JCF_FILL (JCF, (LENGTH)+1); /* Make sure we read 1 byte beyond string. */ \
+ text = (JCF)->read_ptr; \
+ save = text[LENGTH]; \
+ text[LENGTH] = 0; \
+ (JCF)->cpool.data[INDEX] = (jword) get_identifier (text); \
+ text[LENGTH] = save; \
+ JCF_SKIP (JCF, LENGTH); } while (0)
+
+#include "jcf.h"
+#ifdef __STDC__
+/* For getenv */
+#include <stdlib.h>
+#endif
+
+#ifndef SEEK_SET
+#include <unistd.h>
+#endif
+
+extern struct obstack *saveable_obstack;
+extern struct obstack temporary_obstack;
+extern struct obstack permanent_obstack;
+
+/* The class we are currently processing. */
+tree current_class = NULL_TREE;
+
+/* The class we started with. */
+tree main_class = NULL_TREE;
+
+/* The FIELD_DECL for the current field. */
+static tree current_field = NULL_TREE;
+
+static tree current_method = NULL_TREE;
+
+static tree give_name_to_class PROTO ((JCF *jcf, int index));
+
+void parse_zip_file_entries (void);
+void process_zip_dir();
+
+/* Source file compilation declarations */
+static void parse_source_file ();
+extern int java_error_count;
+#define java_parse_abort_on_error() \
+ { \
+ if (java_error_count) \
+ { \
+ java_report_errors (); \
+ java_pop_parser_context (); \
+ return; \
+ } \
+ }
+
+/* Handle "SourceFile" attribute. */
+
+void
+set_source_filename (jcf, index)
+ JCF *jcf;
+ int index;
+{
+ tree sfname_id = get_name_constant (jcf, index);
+ char *sfname = IDENTIFIER_POINTER (sfname_id);
+ if (input_filename != NULL)
+ {
+ int old_len = strlen (input_filename);
+ int new_len = IDENTIFIER_LENGTH (sfname_id);
+ /* Use the current input_filename (derived from the class name)
+ if it has a directory prefix, but otherwise matches sfname. */
+ if (old_len > new_len
+ && strcmp (sfname, input_filename + old_len - new_len) == 0
+ && (input_filename[old_len - new_len - 1] == '/'
+ || input_filename[old_len - new_len - 1] == '\\'))
+ return;
+ }
+ input_filename = sfname;
+ DECL_SOURCE_FILE (TYPE_NAME (current_class)) = sfname;
+ if (current_class == main_class) main_input_filename = input_filename;
+}
+
+#define HANDLE_SOURCEFILE(INDEX) set_source_filename (jcf, INDEX)
+
+#define HANDLE_CLASS_INFO(ACCESS_FLAGS, THIS, SUPER, INTERFACES_COUNT) \
+{ tree super_class = SUPER==0 ? NULL_TREE : get_class_constant (jcf, SUPER); \
+ current_class = give_name_to_class (jcf, THIS); \
+ set_super_info (ACCESS_FLAGS, current_class, super_class, INTERFACES_COUNT);}
+
+#define HANDLE_CLASS_INTERFACE(INDEX) \
+ add_interface (current_class, get_class_constant (jcf, INDEX))
+
+#define HANDLE_START_FIELD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
+{ int sig_index = SIGNATURE; \
+ current_field = add_field (current_class, get_name_constant (jcf, NAME), \
+ parse_signature (jcf, sig_index), ACCESS_FLAGS); \
+ set_java_signature (TREE_TYPE (current_field), JPOOL_UTF (jcf, sig_index)); }
+
+#define HANDLE_END_FIELDS() \
+ (current_field = NULL_TREE)
+
+#define HANDLE_CONSTANTVALUE(INDEX) \
+{ tree constant; int index = INDEX; \
+ if (JPOOL_TAG (jcf, index) == CONSTANT_String) { \
+ tree name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index)); \
+ constant = build_utf8_ref (name); \
+ } \
+ else \
+ constant = get_constant (jcf, index); \
+ set_constant_value (current_field, constant); }
+
+#define HANDLE_METHOD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
+ (current_method = add_method (current_class, ACCESS_FLAGS, \
+ get_name_constant (jcf, NAME), \
+ get_name_constant (jcf, SIGNATURE)), \
+ DECL_LOCALVARIABLES_OFFSET (current_method) = 0, \
+ DECL_LINENUMBERS_OFFSET (current_method) = 0)
+
+#define HANDLE_END_METHODS() \
+{ tree handle_type = CLASS_TO_HANDLE_TYPE (current_class); \
+ if (handle_type != current_class) layout_type (handle_type); }
+
+#define HANDLE_CODE_ATTRIBUTE(MAX_STACK, MAX_LOCALS, CODE_LENGTH) \
+{ DECL_MAX_STACK (current_method) = (MAX_STACK); \
+ DECL_MAX_LOCALS (current_method) = (MAX_LOCALS); \
+ DECL_CODE_LENGTH (current_method) = (CODE_LENGTH); \
+ DECL_CODE_OFFSET (current_method) = JCF_TELL (jcf); }
+
+#define HANDLE_LOCALVARIABLETABLE_ATTRIBUTE(COUNT) \
+{ int n = (COUNT); \
+ DECL_LOCALVARIABLES_OFFSET (current_method) = JCF_TELL (jcf) - 2; \
+ JCF_SKIP (jcf, n * 10); }
+
+#define HANDLE_LINENUMBERTABLE_ATTRIBUTE(COUNT) \
+{ int n = (COUNT); \
+ DECL_LINENUMBERS_OFFSET (current_method) = JCF_TELL (jcf) - 2; \
+ JCF_SKIP (jcf, n * 4); }
+
+#include "jcf-reader.c"
+
+static int yydebug;
+
+tree
+parse_signature (jcf, sig_index)
+ JCF *jcf;
+ int sig_index;
+{
+ if (sig_index <= 0 || sig_index >= JPOOL_SIZE(jcf)
+ || JPOOL_TAG (jcf, sig_index) != CONSTANT_Utf8)
+ fatal ("invalid field/method signature");
+ else
+ {
+ return parse_signature_string (JPOOL_UTF_DATA (jcf, sig_index),
+ JPOOL_UTF_LENGTH (jcf, sig_index));
+ }
+}
+
+void
+init_lex ()
+{
+ /* Make identifier nodes long enough for the language-specific slots. */
+ set_identifier_size (sizeof (struct lang_identifier));
+}
+
+void
+set_yydebug (value)
+ int value;
+{
+ yydebug = value;
+}
+
+tree
+get_constant (jcf, index)
+ JCF *jcf;
+ int index;
+{
+ tree value;
+ int tag;
+ if (index <= 0 || index >= JPOOL_SIZE(jcf))
+ goto bad;
+ tag = JPOOL_TAG (jcf, index);
+ if ((tag & CONSTANT_ResolvedFlag) || tag == CONSTANT_Utf8)
+ return (tree) jcf->cpool.data[index];
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ switch (tag)
+ {
+ case CONSTANT_Integer:
+ {
+ jint num = JPOOL_INT(jcf, index);
+ value = build_int_2 (num, num < 0 ? -1 : 0);
+ TREE_TYPE (value) = int_type_node;
+ break;
+ }
+ case CONSTANT_Long:
+ {
+ jint num = JPOOL_INT (jcf, index);
+ HOST_WIDE_INT lo, hi;
+ lshift_double (num, 0, 32, 64, &lo, &hi, 0);
+ num = JPOOL_INT (jcf, index+1);
+ add_double (lo, hi, num, 0, &lo, &hi);
+ value = build_int_2 (lo, hi);
+ TREE_TYPE (value) = long_type_node;
+ force_fit_type (value, 0);
+ break;
+ }
+#if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
+ case CONSTANT_Float:
+ {
+ jint num = JPOOL_INT(jcf, index);
+ REAL_VALUE_TYPE d;
+#ifdef REAL_ARITHMETIC
+ d = REAL_VALUE_FROM_TARGET_SINGLE (num);
+#else
+ union { float f; jint i; } u;
+ u.i = num;
+ d = u.f;
+#endif
+ value = build_real (float_type_node, d);
+ break;
+ }
+ case CONSTANT_Double:
+ {
+ HOST_WIDE_INT num[2];
+ REAL_VALUE_TYPE d;
+ HOST_WIDE_INT lo, hi;
+ num[0] = JPOOL_INT (jcf, index);
+ lshift_double (num[0], 0, 32, 64, &lo, &hi, 0);
+ num[0] = JPOOL_INT (jcf, index+1);
+ add_double (lo, hi, num[0], 0, &lo, &hi);
+ if (FLOAT_WORDS_BIG_ENDIAN)
+ {
+ num[0] = hi;
+ num[1] = lo;
+ }
+ else
+ {
+ num[0] = lo;
+ num[1] = hi;
+ }
+#ifdef REAL_ARITHMETIC
+ d = REAL_VALUE_FROM_TARGET_DOUBLE (num);
+#else
+ union { double d; jint i[2]; } u;
+ u.i[0] = (jint) num[0];
+ u.i[1] = (jint) num[1];
+ d = u.d;
+#endif
+ value = build_real (double_type_node, d);
+ break;
+ }
+#endif /* TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT */
+ case CONSTANT_String:
+ {
+ extern struct obstack *expression_obstack;
+ tree name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index));
+ char *utf8_ptr = IDENTIFIER_POINTER (name);
+ unsigned char *str_ptr;
+ int utf8_len = IDENTIFIER_LENGTH (name);
+ unsigned char *str = (unsigned char*)utf8_ptr;
+ int i = utf8_len;
+ int str_len;
+
+ /* Count the number of Unicode characters in the string,
+ while checking for a malformed Utf8 string. */
+ for (str_len = 0; i > 0; str_len++)
+ {
+ int char_len = UT8_CHAR_LENGTH (*str);
+ if (char_len < 0 || char_len > 2 || char_len > i)
+ fatal ("bad string constant");
+ str += char_len;
+ i -= char_len;
+ }
+
+ value = make_node (STRING_CST);
+ TREE_STRING_LENGTH (value) = 2 * str_len;
+ TREE_STRING_POINTER (value)
+ = obstack_alloc (expression_obstack, 2 * str_len);
+ str_ptr = (unsigned char *) TREE_STRING_POINTER (value);
+ str = (unsigned char*)utf8_ptr;
+ for (i = 0; i < str_len; i++)
+ {
+ int char_value;
+ int char_len = UT8_CHAR_LENGTH (*str);
+ switch (char_len)
+ {
+ case 1:
+ char_value = *str++;
+ break;
+ case 2:
+ char_value = *str++ & 0x1F;
+ char_value = (char_value << 6) | (*str++ & 0x3F);
+ break;
+ case 3:
+ char_value = *str_ptr++ & 0x0F;
+ char_value = (char_value << 6) | (*str++ & 0x3F);
+ char_value = (char_value << 6) | (*str++ & 0x3F);
+ break;
+ default:
+ goto bad;
+ }
+ if (BYTES_BIG_ENDIAN)
+ {
+ *str_ptr++ = char_value >> 8;
+ *str_ptr++ = char_value & 0xFF;
+ }
+ else
+ {
+ *str_ptr++ = char_value & 0xFF;
+ *str_ptr++ = char_value >> 8;
+ }
+ }
+ }
+ break;
+ default:
+ goto bad;
+ }
+ pop_obstacks ();
+ JPOOL_TAG(jcf, index) = tag | CONSTANT_ResolvedFlag;
+ jcf->cpool.data [index] = (jword) value;
+ return value;
+ bad:
+ fatal ("bad value constant type %d, index %d",
+ JPOOL_TAG( jcf, index ), index);
+}
+
+tree
+get_name_constant (jcf, index)
+ JCF *jcf;
+ int index;
+{
+ tree name = get_constant (jcf, index);
+ if (TREE_CODE (name) != IDENTIFIER_NODE)
+ fatal ("bad nameandtype index %d", index);
+ return name;
+}
+
+static tree
+give_name_to_class (jcf, i)
+ JCF *jcf;
+ int i;
+{
+ if (i <= 0 || i >= JPOOL_SIZE(jcf)
+ || JPOOL_TAG (jcf, i) != CONSTANT_Class)
+ fatal ("bad class index %d", i);
+ else
+ {
+ tree this_class;
+ int j = JPOOL_USHORT1 (jcf, i);
+ /* verify_constant_pool confirmed that j is a CONSTANT_Utf8. */
+ tree class_name = unmangle_classname (JPOOL_UTF_DATA (jcf, j),
+ JPOOL_UTF_LENGTH (jcf, j));
+ this_class = lookup_class (class_name);
+ input_filename = DECL_SOURCE_FILE (TYPE_NAME (this_class));
+ lineno = 0;
+ if (main_input_filename == NULL && jcf == main_jcf)
+ main_input_filename = input_filename;
+
+ jcf->cpool.data[i] = (jword) this_class;
+ JPOOL_TAG (jcf, i) = CONSTANT_ResolvedClass;
+ return this_class;
+ }
+}
+
+/* Get the class of the CONSTANT_Class whose constant pool index is I. */
+
+tree
+get_class_constant (JCF *jcf , int i)
+{
+ tree type;
+ if (i <= 0 || i >= JPOOL_SIZE(jcf)
+ || (JPOOL_TAG (jcf, i) & ~CONSTANT_ResolvedFlag) != CONSTANT_Class)
+ fatal ("bad class index %d", i);
+
+ if (JPOOL_TAG (jcf, i) != CONSTANT_ResolvedClass)
+ {
+ int name_index = JPOOL_USHORT1 (jcf, i);
+ /* verify_constant_pool confirmed that name_index is a CONSTANT_Utf8. */
+ char *name = JPOOL_UTF_DATA (jcf, name_index);
+ int nlength = JPOOL_UTF_LENGTH (jcf, name_index);
+ if (name[0] == '[') /* Handle array "classes". */
+ type = parse_signature_string (name, nlength);
+ else
+ {
+ tree cname = unmangle_classname (name, nlength);
+ type = lookup_class (cname);
+ }
+ jcf->cpool.data[i] = (jword) type;
+ JPOOL_TAG (jcf, i) = CONSTANT_ResolvedClass;
+ }
+ else
+ type = (tree) jcf->cpool.data[i];
+ return type;
+}
+
+void
+fix_classpath ()
+{
+ static char default_path[] = DEFAULT_CLASS_PATH;
+
+ if (classpath == NULL)
+ {
+ classpath = (char *) getenv ("CLASSPATH");
+ if (classpath == NULL)
+ {
+ warning ("CLASSPATH not set");
+ classpath = default_path;
+ }
+ }
+}
+
+void
+DEFUN(jcf_out_of_synch, (jcf),
+ JCF *jcf)
+{
+ char *source = strdup (jcf->filename);
+ int i = strlen (source);
+
+ while (source[i] != '.')
+ i--;
+
+ source [i] = '\0';
+ warning ("Class file `%s' out of synch with `%s.java'",
+ jcf->filename, source);
+ free (source);
+}
+
+/* Load CLASS_OR_NAME. CLASS_OR_NAME can be a mere identifier if
+ called from the parser, otherwise it's a RECORD_TYPE node. If
+ VERBOSE is 1, print error message on failure to load a class. */
+
+void
+load_class (class_or_name, verbose)
+ tree class_or_name;
+ int verbose;
+{
+ JCF this_jcf, *jcf;
+ tree name = (TREE_CODE (class_or_name) == IDENTIFIER_NODE ?
+ class_or_name : DECL_NAME (TYPE_NAME (class_or_name)));
+ tree save_current_class = current_class;
+ char *save_input_filename = input_filename;
+ JCF *save_current_jcf = current_jcf;
+ long saved_pos;
+ if (current_jcf->read_state)
+ saved_pos = ftell (current_jcf->read_state);
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+
+ if (!classpath)
+ fix_classpath ();
+ /* Search in current zip first. */
+ if (find_in_current_zip (IDENTIFIER_POINTER (name),
+ IDENTIFIER_LENGTH (name), &jcf) == 0)
+ if (find_class (IDENTIFIER_POINTER (name), IDENTIFIER_LENGTH (name),
+ &this_jcf, 1) == 0)
+ {
+ if (verbose)
+ {
+ error ("Cannot find class file class %s.",
+ IDENTIFIER_POINTER (name));
+ TYPE_SIZE (class_or_name) = error_mark_node;
+ if (!strcmp (classpath, DEFAULT_CLASS_PATH))
+ fatal ("giving up");
+ pop_obstacks (); /* FIXME: one pop_obstack() per function */
+ }
+ return;
+ }
+ else
+ {
+ this_jcf.seen_in_zip = 0;
+ current_jcf = &this_jcf;
+ if (this_jcf.outofsynch)
+ jcf_out_of_synch (current_jcf);
+ }
+ else
+ current_jcf = jcf;
+
+ if (current_jcf->java_source)
+ jcf_parse_source (current_jcf);
+ else {
+ int saved_lineno = lineno;
+ input_filename = current_jcf->filename;
+ jcf_parse (current_jcf);
+ lineno = saved_lineno;
+ }
+
+ if (!current_jcf->seen_in_zip)
+ JCF_FINISH (current_jcf);
+/* DECL_IGNORED_P (TYPE_NAME (class_or_name)) = 1;*/
+ pop_obstacks ();
+
+ current_class = save_current_class;
+ input_filename = save_input_filename;
+ current_jcf = save_current_jcf;
+ if (current_jcf->read_state)
+ fseek (current_jcf->read_state, saved_pos, SEEK_SET);
+}
+
+/* Parse a source file when JCF refers to a source file. This piece
+ needs further work as far as error handling and report. */
+
+int
+jcf_parse_source (jcf)
+ JCF *jcf;
+{
+ java_parser_context_save_global ();
+
+ input_filename = current_jcf->filename;
+ if (!(finput = fopen (input_filename, "r")))
+ fatal ("input file `%s' just disappeared - jcf_parse_source",
+ input_filename);
+
+ parse_source_file (1); /* Parse only */
+ if (current_class && TREE_TYPE (current_class))
+ CLASS_FROM_SOURCE_P (TREE_TYPE (current_class)) = 1;
+
+ fclose (finput);
+ java_parser_context_restore_global ();
+}
+
+/* Parse the .class file JCF. */
+
+int
+jcf_parse (jcf)
+ JCF* jcf;
+{
+ int i, code;
+
+ if (jcf_parse_preamble (jcf) != 0)
+ fatal ("Not a valid Java .class file.\n");
+ code = jcf_parse_constant_pool (jcf);
+ if (code != 0)
+ fatal ("error while parsing constant pool");
+ code = verify_constant_pool (jcf);
+ if (code > 0)
+ fatal ("error in constant pool entry #%d\n", code);
+
+ jcf_parse_class (jcf);
+ if (main_class == NULL_TREE)
+ main_class = current_class;
+ if (! quiet_flag && TYPE_NAME (current_class))
+ fprintf (stderr, " class %s",
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
+ CLASS_LOADED_P (current_class) = 1;
+
+ for (i = 1; i < JPOOL_SIZE(jcf); i++)
+ {
+ switch (JPOOL_TAG (jcf, i))
+ {
+ case CONSTANT_Class:
+ get_class_constant (jcf, i);
+ break;
+ }
+ }
+
+ code = jcf_parse_fields (jcf);
+ if (code != 0)
+ fatal ("error while parsing fields");
+ code = jcf_parse_methods (jcf);
+ if (code != 0)
+ fatal ("error while parsing methods");
+ code = jcf_parse_final_attributes (jcf);
+ if (code != 0)
+ fatal ("error while parsing final attributes");
+
+ /* The fields of class_type_node are already in correct order. */
+ if (current_class != class_type_node && current_class != object_type_node)
+ TYPE_FIELDS (current_class) = nreverse (TYPE_FIELDS (current_class));
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ layout_class (current_class);
+ pop_obstacks ();
+}
+
+void
+init_outgoing_cpool ()
+{
+ current_constant_pool_data_ref = NULL_TREE;
+ if (outgoing_cpool == NULL)
+ {
+ static CPool outgoing_cpool_buffer;
+ outgoing_cpool = &outgoing_cpool_buffer;
+ CPOOL_INIT(outgoing_cpool);
+ }
+ else
+ {
+ CPOOL_REINIT(outgoing_cpool);
+ }
+}
+
+void
+parse_class_file ()
+{
+ tree method;
+ char *save_input_filename = input_filename;
+ int save_lineno = lineno;
+
+ input_filename = DECL_SOURCE_FILE (TYPE_NAME (current_class));
+ lineno = 0;
+ debug_start_source_file (input_filename);
+ init_outgoing_cpool ();
+
+ for ( method = TYPE_METHODS (CLASS_TO_HANDLE_TYPE (current_class));
+ method != NULL_TREE; method = TREE_CHAIN (method))
+ {
+ JCF *jcf = current_jcf;
+
+ if (METHOD_NATIVE (method) || METHOD_ABSTRACT (method))
+ continue;
+
+ if (DECL_CODE_OFFSET (method) == 0)
+ {
+ error ("missing Code attribute");
+ continue;
+ }
+
+ lineno = 0;
+ if (DECL_LINENUMBERS_OFFSET (method))
+ {
+ register int i;
+ register unsigned char *ptr;
+ JCF_SEEK (jcf, DECL_LINENUMBERS_OFFSET (method));
+ linenumber_count = i = JCF_readu2 (jcf);
+ linenumber_table = ptr = jcf->read_ptr;
+
+ for (ptr += 2; --i >= 0; ptr += 4)
+ {
+ int line = GET_u2 (ptr);
+ /* Set initial lineno lineno to smallest linenumber.
+ * Needs to be set before init_function_start. */
+ if (lineno == 0 || line < lineno)
+ lineno = line;
+ }
+ }
+ else
+ {
+ linenumber_table = NULL;
+ linenumber_count = 0;
+ }
+
+ start_java_method (method);
+
+ give_name_to_locals (jcf);
+
+ /* Actually generate code. */
+ expand_byte_code (jcf, method);
+
+ end_java_method ();
+ }
+
+ if (flag_emit_class_files)
+ write_classfile (current_class);
+ make_class_data (current_class);
+ register_class ();
+ rest_of_decl_compilation (TYPE_NAME (current_class), (char*) 0, 1, 0);
+
+ debug_end_source_file (save_lineno);
+ input_filename = save_input_filename;
+ lineno = save_lineno;
+}
+
+/* Parse a source file, as pointed by the current JCF. If PARSE_ONLY
+ is non zero, we're not parsing a file found on the command line and
+ we skip things related to code generation. */
+
+static void
+parse_source_file (parse_only)
+ int parse_only;
+{
+ lang_init_source (1); /* Error msgs have no method prototypes */
+ java_push_parser_context ();
+ java_init_lex (); /* Initialize the parser */
+ java_parse_abort_on_error ();
+ java_parse (); /* Parse and build partial tree nodes. */
+ java_parse_abort_on_error ();
+ java_complete_class (); /* Parse unsatisfied class decl. */
+ java_parse_abort_on_error ();
+ java_check_circular_reference (); /* Check on circular references */
+ java_parse_abort_on_error ();
+ java_check_methods (); /* Check the methods */
+ java_parse_abort_on_error ();
+ java_layout_classes ();
+ java_parse_abort_on_error ();
+ if (!parse_only)
+ {
+ lang_init_source (2); /* Error msgs have method prototypes */
+ java_complete_expand_methods (); /* Complete and expand method bodies */
+ java_parse_abort_on_error ();
+ java_expand_finals (); /* Expand and check the finals */
+ java_parse_abort_on_error ();
+ java_check_final (); /* Check unitialized final */
+ java_parse_abort_on_error ();
+ if (! flag_emit_class_files)
+ emit_register_class ();
+ java_report_errors (); /* Final step for this file */
+ }
+ if (flag_emit_class_files)
+ write_classfile (current_class);
+ java_pop_parser_context ();
+}
+
+int
+yyparse ()
+{
+ /* Everything migh be enclosed within a loop processing each file after
+ the other one. */
+
+ switch (jcf_figure_file_type (current_jcf))
+ {
+ case JCF_ZIP:
+ parse_zip_file_entries ();
+ emit_register_class ();
+ break;
+ case JCF_CLASS:
+ jcf_parse (current_jcf);
+ parse_class_file ();
+ emit_register_class ();
+ break;
+ case JCF_SOURCE:
+ parse_source_file (0); /* Parse and generate */
+ break;
+ }
+ return 0;
+}
+
+static struct ZipFileCache *localToFile;
+
+/* Process all class entries found in the zip file. */
+void
+parse_zip_file_entries (void)
+{
+ struct ZipDirectory *zdir;
+ int i;
+
+ for (i = 0, zdir = (ZipDirectory *)localToFile->z.central_directory;
+ i < localToFile->z.count; i++, zdir = ZIPDIR_NEXT (zdir))
+ {
+ tree class;
+
+ /* We don't need to consider those files. */
+ if (!zdir->size || !zdir->filename_offset)
+ continue;
+
+ class = lookup_class (get_identifier (ZIPDIR_FILENAME (zdir)));
+ current_jcf = TYPE_LANG_SPECIFIC (class)->jcf;
+ current_class = class;
+
+ if ( !CLASS_LOADED_P (class))
+ {
+ fseek (current_jcf->read_state, current_jcf->zip_offset, SEEK_SET);
+ jcf_parse (current_jcf);
+ }
+
+ input_filename = current_jcf->filename;
+
+ parse_class_file ();
+ FREE (current_jcf->buffer); /* No longer necessary */
+ /* Note: there is a way to free this buffer right after a class seen
+ in a zip file has been parsed. The idea is the set its jcf in such
+ a way that buffer will be reallocated the time the code for the class
+ will be generated. FIXME. */
+ }
+}
+
+/* Read all the entries of the zip file, creates a class and a JCF. Sets the
+ jcf up for further processing and link it to the created class. */
+
+void process_zip_dir()
+{
+ int i;
+ ZipDirectory *zdir;
+
+ for (i = 0, zdir = (ZipDirectory *)localToFile->z.central_directory;
+ i < localToFile->z.count; i++, zdir = ZIPDIR_NEXT (zdir))
+ {
+ char *class_name, *file_name, *class_name_in_zip_dir;
+ tree class;
+ JCF *jcf;
+ int j;
+
+ class_name_in_zip_dir = ZIPDIR_FILENAME (zdir);
+
+ /* We choose to not to process entries with a zero size or entries
+ not bearing the .class extention. */
+ if (!zdir->size || !zdir->filename_offset ||
+ strncmp (&class_name_in_zip_dir[zdir->filename_length-6],
+ ".class", 6))
+ {
+ /* So it will be skipped in parse_zip_file_entries */
+ zdir->size = 0;
+ continue;
+ }
+
+ class_name = ALLOC (zdir->filename_length+1-6);
+ file_name = ALLOC (zdir->filename_length+1);
+ jcf = ALLOC (sizeof (JCF));
+ JCF_ZERO (jcf);
+
+ strncpy (class_name, class_name_in_zip_dir, zdir->filename_length-6);
+ class_name [zdir->filename_length-6] = '\0';
+ strncpy (file_name, class_name_in_zip_dir, zdir->filename_length);
+ file_name [zdir->filename_length] = '\0';
+
+ for (j=0; class_name[j]; j++)
+ class_name [j] = (class_name [j] == '/' ? '.' : class_name [j]);
+
+ /* Yes, we write back the true class name into the zip directory. */
+ strcpy (class_name_in_zip_dir, class_name);
+ zdir->filename_length = j;
+ class = lookup_class (get_identifier (class_name));
+
+ jcf->read_state = finput;
+ jcf->filbuf = jcf_filbuf_from_stdio;
+ jcf->seen_in_zip = 1;
+ jcf->java_source = 0;
+ jcf->zip_offset = zdir->filestart;
+ jcf->classname = class_name;
+ jcf->filename = file_name;
+
+ TYPE_LANG_SPECIFIC (class) =
+ (struct lang_type *) perm_calloc (1, sizeof (struct lang_type));
+ TYPE_LANG_SPECIFIC (class)->jcf = jcf;
+ }
+}
+
+/* Lookup class NAME and figure whether is a class already found in the current
+ zip file. */
+int
+DEFUN(find_in_current_zip, (name, length, jcf),
+ char *name AND int length AND JCF **jcf)
+{
+ JCF *local_jcf;
+ tree class_name = maybe_get_identifier (name), class, icv;
+
+ if (!class_name)
+ return 0;
+
+ if (!(icv = IDENTIFIER_CLASS_VALUE (class_name)))
+ return 0;
+
+ class = TREE_TYPE (icv);
+
+ /* Doesn't have jcf specific info ? It's not ours */
+ if (!TYPE_LANG_SPECIFIC (class) || !TYPE_LANG_SPECIFIC (class)->jcf)
+ return 0;
+
+ *jcf = local_jcf = TYPE_LANG_SPECIFIC (class)->jcf;
+ fseek (local_jcf->read_state, local_jcf->zip_offset, SEEK_SET);
+ return 1;
+}
+
+/* Figure what kind of file we're dealing with */
+int
+DEFUN(jcf_figure_file_type, (jcf),
+ JCF *jcf)
+{
+ unsigned char magic_string[4];
+ uint32 magic;
+
+ if (fread (magic_string, 1, 4, jcf->read_state) != 4)
+ jcf_unexpected_eof (jcf, 4);
+
+ fseek (jcf->read_state, 0L, SEEK_SET);
+ magic = GET_u4 (magic_string);
+
+ if (magic == 0xcafebabe)
+ return JCF_CLASS;
+
+ if (!open_in_zip (jcf, input_filename, NULL))
+ {
+ localToFile = ALLOC (sizeof (struct ZipFileCache));
+ bcopy (SeenZipFiles, localToFile, sizeof (struct ZipFileCache));
+ process_zip_dir (); /* Register all the class defined there */
+ return JCF_ZIP;
+ }
+
+ return JCF_SOURCE;
+}
+
--- /dev/null
+/* This file read a Java(TM) .class file.
+ It is not stand-alone: It depends on tons of macros, and the
+ intent is you #include this file after you've defined the macros.
+
+ Copyright (C) 1996 Free Software Foundation, Inc.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+#include "jcf.h"
+#include "zipfile.h"
+
+int
+DEFUN(get_attribute, (jcf),
+ JCF *jcf)
+{
+ uint16 attribute_name = (JCF_FILL (jcf, 6), JCF_readu2 (jcf));
+ uint32 attribute_length = JCF_readu4 (jcf);
+ uint32 start_pos = JCF_TELL(jcf);
+ int name_length;
+ unsigned char *name_data;
+ JCF_FILL (jcf, attribute_length);
+ if (attribute_name <= 0 || attribute_name >= JPOOL_SIZE(jcf))
+ return -2;
+ if (JPOOL_TAG (jcf, attribute_name) != CONSTANT_Utf8)
+ return -2;
+ name_length = JPOOL_UTF_LENGTH (jcf, attribute_name);
+ name_data = JPOOL_UTF_DATA (jcf, attribute_name);
+
+#ifdef IGNORE_ATTRIBUTE
+ if (IGNORE_ATTRIBUTE (jcf, attribute_name, attribute_length))
+ {
+ JCF_SKIP (jcf, attribute_length);
+ }
+ else
+#endif
+#ifdef HANDLE_SOURCEFILE
+ if (name_length == 10 && memcmp (name_data, "SourceFile", 10) == 0)
+ {
+ uint16 sourcefile_index = JCF_readu2 (jcf);
+ HANDLE_SOURCEFILE(sourcefile_index);
+ }
+ else
+#endif
+#ifdef HANDLE_CONSTANTVALUE
+ if (name_length == 13 && memcmp (name_data, "ConstantValue", 13) == 0)
+ {
+ uint16 constantvalue_index = JCF_readu2 (jcf);
+ if (constantvalue_index <= 0 || constantvalue_index >= JPOOL_SIZE(jcf))
+ return -2;
+ HANDLE_CONSTANTVALUE(constantvalue_index);
+ }
+ else
+#endif
+#ifdef HANDLE_CODE_ATTRIBUTE
+ if (name_length == 4 && memcmp (name_data, "Code", 4) == 0)
+ {
+ uint16 j;
+ uint16 max_stack = JCF_readu2 (jcf);
+ uint16 max_locals = JCF_readu2 (jcf);
+ uint32 code_length = JCF_readu4 (jcf);
+ uint16 exception_table_length, attributes_count;
+ if (code_length + 12 > attribute_length)
+ return -1;
+ HANDLE_CODE_ATTRIBUTE(max_stack, max_locals, code_length);
+ JCF_SKIP (jcf, code_length);
+ exception_table_length = JCF_readu2 (jcf);
+ if (code_length + 8 * exception_table_length + 12 > attribute_length)
+ return -1;
+ JCF_SKIP (jcf, 2 * 4 * exception_table_length);
+ attributes_count = JCF_readu2 (jcf);
+ for (j = 0; j < attributes_count; j++)
+ {
+ int code = get_attribute (jcf);
+ if (code != 0)
+ return code;
+ }
+ }
+ else
+#endif /* HANDLE_CODE_ATTRIBUTE */
+#ifdef HANDLE_EXCEPTIONS_ATTRIBUTE
+ if (name_length == 10 && memcmp (name_data, "Exceptions", 10) == 0)
+ {
+ uint16 count = JCF_readu2 (jcf);
+ HANDLE_EXCEPTIONS_ATTRIBUTE (count);
+ }
+ else
+#endif
+#ifdef HANDLE_LINENUMBERTABLE_ATTRIBUTE
+ if (name_length == 15 && memcmp (name_data, "LineNumberTable", 15) == 0)
+ {
+ uint16 count = JCF_readu2 (jcf);
+ HANDLE_LINENUMBERTABLE_ATTRIBUTE (count);
+ }
+ else
+#endif
+#ifdef HANDLE_LOCALVARIABLETABLE_ATTRIBUTE
+ if (name_length == 18 && memcmp (name_data, "LocalVariableTable", 18) == 0)
+ {
+ uint16 count = JCF_readu2 (jcf);
+ HANDLE_LOCALVARIABLETABLE_ATTRIBUTE (count);
+ }
+ else
+#endif
+ {
+#ifdef PROCESS_OTHER_ATTRIBUTE
+ PROCESS_OTHER_ATTRIBUTE(jcf, attribute_name, attribute_length);
+#else
+ JCF_SKIP (jcf, attribute_length);
+#endif
+ }
+ if (start_pos + attribute_length != JCF_TELL(jcf))
+ return -1;
+ return 0;
+}
+
+/* Read and handle the pre-amble. */
+int
+DEFUN(jcf_parse_preamble, (jcf),
+ JCF* jcf)
+{
+ uint32 magic = (JCF_FILL (jcf, 8), JCF_readu4 (jcf));
+ uint16 minor_version = JCF_readu2 (jcf);
+ uint16 major_version = JCF_readu2 (jcf);
+#ifdef HANDLE_MAGIC
+ HANDLE_MAGIC (magic, minor_version, major_version);
+#endif
+ if (magic != 0xcafebabe)
+ return -1;
+ else
+ return 0;
+}
+
+/* Read and handle the constant pool.
+
+ Return 0 if OK.
+ Return -2 if a bad cross-reference (index of other constant) was seen.
+*/
+int
+DEFUN(jcf_parse_constant_pool, (jcf),
+ JCF* jcf)
+{
+ int i, n;
+ JPOOL_SIZE (jcf) = (JCF_FILL (jcf, 2), JCF_readu2 (jcf));
+ jcf->cpool.tags = ALLOC (JPOOL_SIZE (jcf));
+ jcf->cpool.data = ALLOC (sizeof (jword) * JPOOL_SIZE (jcf));
+ jcf->cpool.tags[0] = 0;
+#ifdef HANDLE_START_CONSTANT_POOL
+ HANDLE_START_CONSTANT_POOL (JPOOL_SIZE (jcf));
+#endif
+ for (i = 1; i < (int) JPOOL_SIZE (jcf); i++)
+ {
+ int constant_kind;
+
+ /* Make sure at least 9 bytes are available. This is enough
+ for all fixed-sized constant pool entries (so we don't need many
+ more JCF_FILL calls below), but is is small enough that
+ we are guaranteed to not hit EOF (in a valid .class file). */
+ JCF_FILL (jcf, 9);
+ constant_kind = JCF_readu (jcf);
+ jcf->cpool.tags[i] = constant_kind;
+ switch (constant_kind)
+ {
+ case CONSTANT_String:
+ case CONSTANT_Class:
+ jcf->cpool.data[i] = JCF_readu2 (jcf);
+ break;
+ case CONSTANT_Fieldref:
+ case CONSTANT_Methodref:
+ case CONSTANT_InterfaceMethodref:
+ case CONSTANT_NameAndType:
+ jcf->cpool.data[i] = JCF_readu2 (jcf);
+ jcf->cpool.data[i] |= JCF_readu2 (jcf) << 16;
+ break;
+ case CONSTANT_Integer:
+ case CONSTANT_Float:
+ jcf->cpool.data[i] = JCF_readu4 (jcf);
+ break;
+ case CONSTANT_Long:
+ case CONSTANT_Double:
+ jcf->cpool.data[i] = JCF_readu4 (jcf);
+ i++; /* These take up two spots in the constant pool */
+ jcf->cpool.tags[i] = 0;
+ jcf->cpool.data[i] = JCF_readu4 (jcf);
+ break;
+ case CONSTANT_Utf8:
+ n = JCF_readu2 (jcf);
+ JCF_FILL (jcf, n);
+#ifdef HANDLE_CONSTANT_Utf8
+ HANDLE_CONSTANT_Utf8(jcf, i, n);
+#else
+ jcf->cpool.data[i] = JCF_TELL(jcf) - 2;
+ JCF_SKIP (jcf, n);
+#endif
+ break;
+ default:
+ return i;
+ }
+ }
+ return 0;
+}
+
+/* Read various class flags and numbers. */
+
+void
+DEFUN(jcf_parse_class, (jcf),
+ JCF* jcf)
+{
+ int i;
+ uint16 interfaces_count;
+ JCF_FILL (jcf, 8);
+ jcf->access_flags = JCF_readu2 (jcf);
+ jcf->this_class = JCF_readu2 (jcf);
+ jcf->super_class = JCF_readu2 (jcf);
+ interfaces_count = JCF_readu2 (jcf);
+
+#ifdef HANDLE_CLASS_INFO
+ HANDLE_CLASS_INFO(jcf->access_flags, jcf->this_class, jcf->super_class, interfaces_count);
+#endif
+
+ JCF_FILL (jcf, 2 * interfaces_count);
+
+ /* Read interfaces. */
+ for (i = 0; i < interfaces_count; i++)
+ {
+ uint16 index = JCF_readu2 (jcf);
+#ifdef HANDLE_CLASS_INTERFACE
+ HANDLE_CLASS_INTERFACE (index);
+#endif
+ }
+}
+
+/* Read fields. */
+int
+DEFUN(jcf_parse_fields, (jcf),
+ JCF* jcf)
+{
+ int i, j;
+ uint16 fields_count;
+ JCF_FILL (jcf, 2);
+ fields_count = JCF_readu2 (jcf);
+
+#ifdef HANDLE_START_FIELDS
+ HANDLE_START_FIELDS (fields_count);
+#endif
+ for (i = 0; i < fields_count; i++)
+ {
+ uint16 access_flags = (JCF_FILL (jcf, 8), JCF_readu2 (jcf));
+ uint16 name_index = JCF_readu2 (jcf);
+ uint16 signature_index = JCF_readu2 (jcf);
+ uint16 attribute_count = JCF_readu2 (jcf);
+#ifdef HANDLE_START_FIELD
+ HANDLE_START_FIELD (access_flags, name_index, signature_index,
+ attribute_count);
+#endif
+ for (j = 0; j < attribute_count; j++)
+ {
+ int code = get_attribute (jcf);
+ if (code != 0)
+ return code;
+ }
+#ifdef HANDLE_END_FIELD
+ HANDLE_END_FIELD ();
+#endif
+ }
+#ifdef HANDLE_END_FIELDS
+ HANDLE_END_FIELDS ();
+#endif
+ return 0;
+}
+
+/* Read methods. */
+
+int
+DEFUN(jcf_parse_one_method, (jcf),
+ JCF* jcf)
+{
+ int i;
+ uint16 access_flags = (JCF_FILL (jcf, 8), JCF_readu2 (jcf));
+ uint16 name_index = JCF_readu2 (jcf);
+ uint16 signature_index = JCF_readu2 (jcf);
+ uint16 attribute_count = JCF_readu2 (jcf);
+#ifdef HANDLE_METHOD
+ HANDLE_METHOD(access_flags, name_index, signature_index, attribute_count);
+#endif
+ for (i = 0; i < attribute_count; i++)
+ {
+ int code = get_attribute (jcf);
+ if (code != 0)
+ return code;
+ }
+ return 0;
+}
+
+int
+DEFUN(jcf_parse_methods, (jcf),
+ JCF* jcf)
+{
+ int i;
+ uint16 methods_count;
+ JCF_FILL (jcf, 2);
+ methods_count = JCF_readu2 (jcf);
+#ifdef HANDLE_START_METHODS
+ HANDLE_START_METHODS (methods_count);
+#endif
+ for (i = 0; i < methods_count; i++)
+ {
+ int code = jcf_parse_one_method (jcf);
+ if (code != 0)
+ return code;
+ }
+#ifdef HANDLE_END_METHODS
+ HANDLE_END_METHODS ();
+#endif
+ return 0;
+}
+
+/* Read attributes. */
+int
+DEFUN(jcf_parse_final_attributes, (jcf),
+ JCF *jcf)
+{
+ int i;
+ uint16 attributes_count = (JCF_FILL (jcf, 2), JCF_readu2 (jcf));
+#ifdef START_FINAL_ATTRIBUTES
+ START_FINAL_ATTRIBUTES (attributes_count)
+#endif
+ for (i = 0; i < attributes_count; i++)
+ {
+ int code = get_attribute (jcf);
+ if (code != 0)
+ return code;
+ }
+ return 0;
+}
+
--- /dev/null
+/* Write out a Java(TM) class file.
+ Copyright (C) 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+#include "config.h"
+#include "tree.h"
+#include "java-tree.h"
+#include "jcf.h"
+#include <stdio.h>
+#include "obstack.h"
+#undef AND
+#include "rtl.h"
+#include "java-opcodes.h"
+#include "parse.h" /* for BLOCK_EXPR_BODY */
+#include "buffer.h"
+
+extern struct obstack temporary_obstack;
+
+/* The buffer allocated for bytecode for the current method. */
+
+struct buffer bytecode = NULL_BUFFER;
+
+/* Make sure bytecode.data is big enough for at least N more bytes. */
+
+#define RESERVE(N) \
+ do { if (bytecode.ptr + (N) > bytecode.limit) buffer_grow (&bytecode, N); } while (0)
+
+/* Add a 1-byte instruction/operand I to bytecode.data,
+ assuming space has already been RESERVE'd. */
+
+#define OP1(I) (*bytecode.ptr++ = (I))
+
+/* Like OP1, but I is a 2-byte big endian integer. */
+
+#define OP2(I) \
+ do { int _I = (I); OP1 (_I >> 8); OP1 (_I); } while (0)
+
+/* Like OP1, but I is a 4-byte big endian integer. */
+
+#define OP4(I) \
+ do { int _I = (I); OP1 (_I >> 24); OP1 (_I >> 16); \
+ OP1 (_I >> 8); OP1 (_I); } while (0)
+
+/* The current stack size (stack pointer) in the current method. */
+
+int code_SP = 0;
+
+/* The largest extent of stack size (stack pointer) in the current method. */
+
+int code_SP_max = 0;
+
+CPool *code_cpool;
+
+/* Macro to call each time we push I words on the JVM stack. */
+
+#define NOTE_PUSH(I) \
+ do { code_SP += (I); if (code_SP > code_SP_max) code_SP_max = code_SP; } while (0)
+
+/* Macro to call each time we pop I words from the JVM stack. */
+
+#define NOTE_POP(I) \
+ do { code_SP -= (I); if (code_SP < 0) abort(); } while (0)
+
+/* A chunk or segment of a .class file. */
+
+struct chunk
+{
+ /* The next segment of this .class file. */
+ struct chunk *next;
+
+ /* The actual data in this segment to be written to the .class file. */
+ unsigned char *data;
+
+ /* The size of the segment to be written to the .class file. */
+ int size;
+};
+
+/* Utility macros for appending (big-endian) data to a buffer.
+ We assume a local variable 'ptr' points into where we want to
+ write next, and we assume enoygh space has been allocated. */
+
+#define PUT1(X) (*ptr++ = (X))
+#define PUT2(X) (PUT1((X) >> 8), PUT1((X) & 0xFF))
+#define PUT4(X) (PUT2((X) >> 16), PUT2((X) & 0xFFFF))
+#define PUTN(P, N) (bcopy(P, ptr, N), ptr += (N))
+
+\f
+/* A buffer for storing line number entries for the current method. */
+struct buffer linenumbers = NULL_BUFFER;
+
+/* Append a line number entry for the given PC and LINE into
+ linenumbers.data. This will later before a LineNumberTable attribute. */
+
+void
+put_linenumber (pc, line)
+ int pc, line;
+{
+ register unsigned char *ptr;
+ if (linenumbers.ptr == linenumbers.limit)
+ buffer_grow (&linenumbers, 4);
+ ptr = linenumbers.ptr;
+ PUT2 (pc);
+ PUT2 (line);
+ linenumbers.ptr = ptr;
+}
+\f
+/* The index of jvm local variable allocated for this DECL.
+ This is assign when generating .class files;
+ contrast DECL_LOCAL_SLOT_NUMBER whcih is set when *reading* a .class file.
+ (We don't allocate DECL_LANG_SPECIFIC for locals from Java sourc code.) */
+
+#define DECL_LOCAL_INDEX(DECL) DECL_ALIGN(DECL)
+
+struct localvar_info
+{
+ tree decl;
+
+ int start_pc;
+
+ /* Offset in LocalVariableTable. */
+ int debug_offset;
+};
+
+struct buffer localvars = NULL_BUFFER;
+
+#define localvar_buffer ((struct localvar_info*) localvars.data)
+#define localvar_max ((struct localvar_info*) localvars.ptr - localvar_buffer)
+
+/* A buffer for storing LocalVariableTable entries entries. */
+
+struct buffer localvartable = NULL_BUFFER;
+
+int
+localvar_alloc (decl, start_pc)
+ tree decl;
+ int start_pc;
+{
+ int wide = TYPE_IS_WIDE (TREE_TYPE (decl));
+ int index;
+ register struct localvar_info *info = (struct localvar_info*)localvars.data;
+ register struct localvar_info *limit = (struct localvar_info*)localvars.ptr;
+ for (index = 0; info < limit; index++, info++)
+ {
+ if (info->decl == NULL_TREE
+ && (! wide || (info+1)->decl == NULL_TREE))
+ break;
+ }
+ if (info == limit)
+ {
+ buffer_grow (&localvars, sizeof (struct localvar_info));
+ info = (struct localvar_info*)localvars.data + index;
+ localvars.ptr = (unsigned char *) (info + 1 + wide);
+ }
+ info->decl = decl;
+ if (wide)
+ (info+1)->decl = TYPE_SECOND;
+ DECL_LOCAL_INDEX (decl) = index;
+ info->start_pc = start_pc;
+
+ if (DECL_NAME (decl) != NULL_TREE)
+ {
+ /* Generate debugging info. */
+ int i;
+ register unsigned char *ptr;
+ buffer_grow (&localvartable, 10);
+ ptr = localvartable.ptr;
+ info->debug_offset = ptr - localvartable.data;
+ PUT2 (start_pc);
+ PUT2 (0); /* length - fill in later */
+ i = find_utf8_constant (code_cpool, DECL_NAME (decl));
+ PUT2 (i); /* name_index*/
+ i = find_utf8_constant (code_cpool,
+ build_java_signature (TREE_TYPE (decl)));
+ PUT2 (i); /* descriptor_index */
+ PUT2 (index);
+ localvartable.ptr = ptr;
+ }
+ else
+ info->debug_offset = -1;
+}
+
+int
+localvar_free (decl, end_pc)
+ tree decl;
+ int end_pc;
+{
+ register unsigned char *ptr;
+ int index = DECL_LOCAL_INDEX (decl);
+ register struct localvar_info *info = &localvar_buffer [index];
+ int wide = TYPE_IS_WIDE (TREE_TYPE (decl));
+ int i;
+
+ i = info->debug_offset;
+ if (i >= 0)
+ {
+ register unsigned char *ptr;
+ /* Point to length field of local_variable_table. */
+ ptr = localvartable.data + i + 2;
+ i = end_pc - info->start_pc;
+ PUT2 (i);
+ }
+
+ if (info->decl != decl)
+ abort ();
+ info->decl = NULL_TREE;
+ if (wide)
+ {
+ info++;
+ if (info->decl != TYPE_SECOND)
+ abort ();
+ info->decl = NULL_TREE;
+ }
+
+}
+
+\f
+#define STACK_TARGET 1
+#define IGNORE_TARGET 2
+
+/* Allocate a new chunk on obstack WORK, and link it in after LAST.
+ Set the data and size fields to DATA and SIZE, respectively.
+ However, if DATA is NULL and SIZE>0, allocate a buffer as well. */
+
+struct chunk *
+alloc_chunk (last, data, size, work)
+ struct chunk *last;
+ unsigned char *data;
+ int size;
+ struct obstack *work;
+{
+ struct chunk *chunk = (struct chunk *)
+ obstack_alloc (work, sizeof(struct chunk));
+
+ if (data == NULL && size > 0)
+ data = obstack_alloc (work, size);
+
+ chunk->next = NULL;
+ chunk->data = data;
+ chunk->size = size;
+ last->next = chunk;
+ return chunk;
+}
+
+/* Get the access flags of a class (TYPE_DECL), a method (FUNCTION_DECL), or
+ a field (FIELD_DECL or VAR_DECL, if static), as encoded in a .class file. */
+
+int
+get_access_flags (decl)
+ tree decl;
+{
+ int flags = 0;
+ int isfield = TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL;
+ if (CLASS_PUBLIC (decl)) /* same as FIELD_PUBLIC and METHOD_PUBLIC */
+ flags |= ACC_PUBLIC;
+ if (CLASS_FINAL (decl)) /* same as FIELD_FINAL and METHOD_FINAL */
+ flags |= ACC_PUBLIC;
+ if (isfield || TREE_CODE (decl) == FUNCTION_DECL)
+ {
+ if (TREE_PROTECTED (decl))
+ flags |= ACC_PROTECTED;
+ if (TREE_PRIVATE (decl))
+ flags |= ACC_PRIVATE;
+ }
+ else if (TREE_CODE (decl) == TYPE_DECL)
+ {
+ if (CLASS_SUPER (decl))
+ flags |= ACC_SUPER;
+ if (CLASS_ABSTRACT (decl))
+ flags |= ACC_ABSTRACT;
+ if (CLASS_INTERFACE (decl))
+ flags |= ACC_INTERFACE;
+ }
+ else
+ fatal ("internal error - bad argument to get_access_flags");
+ if (TREE_CODE (decl) == FUNCTION_DECL)
+ {
+ if (METHOD_NATIVE (decl))
+ flags |= ACC_NATIVE;
+ if (METHOD_STATIC (decl))
+ flags |= ACC_STATIC;
+ if (METHOD_FINAL (decl))
+ flags |= ACC_FINAL;
+ if (METHOD_SYNCHRONIZED (decl))
+ flags |= ACC_SYNCHRONIZED;
+ if (METHOD_ABSTRACT (decl))
+ flags |= ACC_ABSTRACT;
+ }
+ if (isfield)
+ {
+ if (FIELD_STATIC (decl))
+ flags |= ACC_STATIC;
+ if (FIELD_VOLATILE (decl))
+ flags |= ACC_VOLATILE;
+ if (FIELD_TRANSIENT (decl))
+ flags |= ACC_TRANSIENT;
+ }
+ return flags;
+}
+
+/* Write the list of segments starting at CHUNKS to STREAM. */
+
+void
+write_chunks (stream, chunks)
+ FILE* stream;
+ struct chunk *chunks;
+{
+ for (; chunks != NULL; chunks = chunks->next)
+ fwrite (chunks->data, chunks->size, 1, stream);
+}
+
+void
+push_constant1 (index)
+ int index;
+{
+ if (index < 256)
+ {
+ OP1 (OPCODE_ldc);
+ OP1 (index);
+ }
+ else
+ {
+ OP1 (OPCODE_ldc_w);
+ OP2 (index);
+ }
+}
+
+void
+push_constant2 (index)
+ int index;
+{
+ RESERVE (3);
+ OP1 (OPCODE_ldc2_w);
+ OP2 (index);
+}
+
+void
+push_int_const (i)
+ HOST_WIDE_INT i;
+{
+ RESERVE(3);
+ if (i >= -1 && i <= 5)
+ OP1(OPCODE_iconst_0 + i);
+ else if (i >= -128 && i < 128)
+ {
+ OP1(OPCODE_bipush);
+ OP1(i);
+ }
+ else if (i >= -32768 && i < 32768)
+ {
+ OP1(OPCODE_sipush);
+ OP2(i);
+ }
+ else
+ {
+ i = find_constant1 (code_cpool, CONSTANT_Integer, i & 0xFFFFFFFF);
+ push_constant1 (i);
+ }
+}
+
+void
+push_long_const (lo, hi)
+ HOST_WIDE_INT lo, hi;
+{
+ if (hi == 0 && lo >= 0 && lo <= 1)
+ {
+ RESERVE(1);
+ OP1(OPCODE_lconst_0 + lo);
+ }
+#if 0
+ else if ((jlong) (jint) i == i)
+ {
+ push_int_const ((jint) i);
+ RESERVE (1);
+ OP1 (OPCODE_i2l);
+ }
+#endif
+ else
+ {
+ HOST_WIDE_INT w1, w2;
+ lshift_double (lo, hi, -32, 64, &w1, &w2, 1);
+ hi = find_constant1 (code_cpool, CONSTANT_Long,
+ w1 & 0xFFFFFFFF, lo & 0xFFFFFFFF);
+ push_constant2 (hi);
+ }
+}
+
+void
+field_op (field, opcode)
+ tree field;
+ int opcode;
+{
+ int index = find_fieldref_index (code_cpool, field);
+ RESERVE (3);
+ OP1 (opcode);
+ OP2 (index);
+}
+
+/* Returns an integer in the range 0 (for 'int') through 4 (for object
+ reference) to 7 (for 'short') which matches the pattern of how JVM
+ opcodes typically depend on the operand type. */
+
+int
+adjust_typed_op (type)
+ tree type;
+{
+ switch (TREE_CODE (type))
+ {
+ case BOOLEAN_TYPE: return 5;
+ case CHAR_TYPE: return 6;
+ case POINTER_TYPE:
+ case RECORD_TYPE: return 4;
+ case INTEGER_TYPE:
+ switch (TYPE_PRECISION (type))
+ {
+ case 8: return 5;
+ case 16: return 7;
+ case 32: return 0;
+ case 64: return 1;
+ }
+ break;
+ case REAL_TYPE:
+ switch (TYPE_PRECISION (type))
+ {
+ case 32: return 2;
+ case 64: return 3;
+ }
+ break;
+ }
+ abort ();
+}
+
+void
+maybe_wide (opcode, index)
+ int opcode, index;
+{
+ if (index >= 256)
+ {
+ RESERVE (4);
+ OP1 (196); /* wide */
+ OP1 (opcode);
+ OP2 (index);
+ }
+ else
+ {
+ RESERVE (2);
+ OP1 (opcode);
+ OP1 (index);
+ }
+}
+
+#define PC BUFFER_LENGTH(&bytecode)
+
+/* Generate byetcode for sub-expression EXP of METHOD.
+ TARGET is one of STACK_TARGET or IGNORE_TARGET. */
+
+void
+generate_bytecode_insns (method, exp, target)
+ tree method;
+ tree exp;
+ int target;
+{
+ rtx value;
+ tree type = TREE_TYPE (exp);
+ enum java_opcode jopcode;
+ int op;
+ switch (TREE_CODE (exp))
+ {
+ case BLOCK:
+ if (BLOCK_EXPR_BODY (exp))
+ {
+ tree local;
+ for (local = BLOCK_EXPR_DECLS (exp); local; )
+ {
+ tree next = TREE_CHAIN (local);
+ localvar_alloc (local, PC);
+ local = next;
+ }
+ generate_bytecode_insns (method, BLOCK_EXPR_BODY (exp), target);
+ for (local = BLOCK_EXPR_DECLS (exp); local; )
+ {
+ tree next = TREE_CHAIN (local);
+ localvar_free (local, PC);
+ local = next;
+ }
+ }
+ break;
+ case COMPOUND_EXPR:
+ generate_bytecode_insns (method, TREE_OPERAND (exp, 0), IGNORE_TARGET);
+ generate_bytecode_insns (method, TREE_OPERAND (exp, 1), target);
+ break;
+ case EXPR_WITH_FILE_LOCATION:
+ {
+ char *saved_input_filename = input_filename;
+ int saved_lineno = lineno;
+ input_filename = EXPR_WFL_FILENAME (exp);
+ lineno = EXPR_WFL_LINENO (exp);
+ if (EXPR_WFL_EMIT_LINE_NOTE (exp))
+ put_linenumber (PC, EXPR_WFL_LINENO (exp));
+ generate_bytecode_insns (method, EXPR_WFL_NODE (exp), target);
+ input_filename = saved_input_filename;
+ lineno = saved_lineno;
+ }
+ break;
+ case INTEGER_CST:
+ if (target == IGNORE_TARGET) ; /* do nothing */
+ else if (TREE_CODE (type) == POINTER_TYPE)
+ {
+ if (! integer_zerop (exp))
+ abort();
+ RESERVE(1);
+ OP1 (OPCODE_aconst_null);
+ NOTE_PUSH (1);
+ }
+ else if (TYPE_PRECISION (type) <= 32)
+ {
+ push_int_const (TREE_INT_CST_LOW (exp));
+ NOTE_PUSH (1);
+ }
+ else
+ {
+ push_long_const (TREE_INT_CST_LOW (exp), TREE_INT_CST_HIGH (exp));
+ NOTE_PUSH (2);
+ }
+ break;
+ case VAR_DECL:
+ if (TREE_STATIC (exp))
+ {
+ field_op (exp, OPCODE_getstatic);
+ break;
+ }
+ /* ... fall through ... */
+ case PARM_DECL:
+ {
+ int kind = adjust_typed_op (type);
+ int index = DECL_LOCAL_INDEX (exp);
+ if (index <= 3)
+ {
+ RESERVE (1);
+ OP1 (26 + 4 * kind + index); /* [ilfda]load_[0123] */
+ }
+ else
+ maybe_wide (21 + kind, index); /* [ilfda]load */
+ }
+ break;
+ case INDIRECT_REF:
+ generate_bytecode_insns (method, TREE_OPERAND (exp, 0), target);
+ break;
+ case ARRAY_REF:
+ generate_bytecode_insns (method, TREE_OPERAND (exp, 0), target);
+ generate_bytecode_insns (method, TREE_OPERAND (exp, 1), target);
+ if (target != IGNORE_TARGET)
+ {
+ jopcode = OPCODE_iaload + adjust_typed_op (type);
+ RESERVE(1);
+ OP1 (jopcode);
+ }
+ break;
+ case COMPONENT_REF:
+ {
+ tree obj = TREE_OPERAND (exp, 0);
+ tree field = TREE_OPERAND (exp, 1);
+ int is_static = FIELD_STATIC (field);
+ generate_bytecode_insns (method, obj,
+ is_static ? IGNORE_TARGET : target);
+ if (target != IGNORE_TARGET)
+ {
+ if (DECL_NAME (field) == length_identifier_node && !is_static
+ && TYPE_ARRAY_P (TREE_TYPE (obj)))
+ {
+ RESERVE (1);
+ OP1 (OPCODE_arraylength);
+ }
+ else
+ field_op (field, is_static ? OPCODE_getstatic : OPCODE_getfield);
+ }
+ }
+ break;
+ case RETURN_EXPR:
+ if (!TREE_OPERAND (exp, 0))
+ op = OPCODE_return;
+ else
+ {
+ exp = TREE_OPERAND (exp, 0);
+ if (TREE_CODE (exp) != MODIFY_EXPR)
+ abort ();
+ exp = TREE_OPERAND (exp, 1);
+ op = OPCODE_ireturn + adjust_typed_op (TREE_TYPE (exp));
+ generate_bytecode_insns (method, exp, STACK_TARGET);
+ }
+ RESERVE (1);
+ OP1 (op);
+ break;
+ case MODIFY_EXPR:
+ {
+ tree lhs = TREE_OPERAND (exp, 0);
+ tree rhs = TREE_OPERAND (exp, 1);
+ HOST_WIDE_INT value;
+#if 0
+ if (TREE_CODE (rhs) == PLUS_EXPR
+ && TREE_CODE (lhs) == VAR_DECL
+ /* && FIXME lhs is a local variable */
+ && TYPE_MODE (TREE)TYPE (lhs) == SImode /* ??? */
+ && TREE_OPERAND (rhs, 0) == lhs
+ && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST
+ /* or vice versa FIXME */
+ && (value = TREE_INT_CST_LOW (TREE_OPERAND (rhs, 1)),
+ (value >= -32768 && value <= 32767)))
+ {
+ emit_insn (gen_rtx (SET, SImode,
+ DECL_RTL (lhs),
+ gen_rtx (PLUS, SImode,
+ DECL_RTL (lhs),
+ gen_rtx_CONST_INT (SImode, value))));
+ return DECL_RTL (lhs);
+ }
+#endif
+ if (TREE_CODE (lhs) == COMPONENT_REF)
+ generate_bytecode_insns (method, TREE_OPERAND (lhs, 0), STACK_TARGET);
+ else if (TREE_CODE (lhs) == ARRAY_REF)
+ {
+ generate_bytecode_insns (method,
+ TREE_OPERAND (lhs, 0), STACK_TARGET);
+ generate_bytecode_insns (method,
+ TREE_OPERAND (lhs, 1), STACK_TARGET);
+ }
+ generate_bytecode_insns (method, rhs, STACK_TARGET);
+ if (target != IGNORE_TARGET)
+ {
+ RESERVE (1);
+ OP1 (TYPE_IS_WIDE (type) ? OPCODE_dup2_x1 : OPCODE_dup_x1);
+ }
+ if (TREE_CODE (lhs) == COMPONENT_REF)
+ {
+ tree field = TREE_OPERAND (lhs, 1);
+ field_op (field,
+ FIELD_STATIC (field) ? OPCODE_putstatic
+ : OPCODE_putfield);
+ }
+ else if (TREE_CODE (lhs) == VAR_DECL
+ || TREE_CODE (lhs) == PARM_DECL)
+ {
+ if (FIELD_STATIC (lhs))
+ {
+ field_op (lhs, OPCODE_putstatic);
+ }
+ else
+ {
+ int index = DECL_LOCAL_INDEX (lhs);
+ int opcode = adjust_typed_op (TREE_TYPE (lhs));
+ if (index <= 3)
+ {
+ RESERVE (1);
+ opcode = 59 + 4 * opcode + index;
+ OP1 (opcode); /* [ilfda]store_[0123] */
+ }
+ else
+ {
+ maybe_wide (54 + opcode, index); /* [ilfda]store */
+ }
+ }
+ }
+ else if (TREE_CODE (lhs) == ARRAY_REF)
+ {
+ jopcode = OPCODE_iastore + adjust_typed_op (TREE_TYPE (lhs));
+ RESERVE(1);
+ OP1 (jopcode);
+ }
+ else
+ fatal ("internal error (bad lhs to MODIFY_EXPR)");
+ }
+ break;
+ case PLUS_EXPR:
+ jopcode = OPCODE_iadd + adjust_typed_op (type);
+ goto binop;
+ case MINUS_EXPR:
+ jopcode = OPCODE_isub + adjust_typed_op (type);
+ goto binop;
+ case MULT_EXPR:
+ jopcode = OPCODE_imul + adjust_typed_op (type);
+ goto binop;
+ case TRUNC_DIV_EXPR:
+ case RDIV_EXPR:
+ jopcode = OPCODE_idiv + adjust_typed_op (type);
+ goto binop;
+ binop:
+ generate_bytecode_insns (method, TREE_OPERAND (exp, 0), target);
+ generate_bytecode_insns (method, TREE_OPERAND (exp, 1), target);
+ if (target == STACK_TARGET)
+ {
+ RESERVE(1);
+ OP1 (jopcode);
+ }
+ break;
+ case CALL_EXPR:
+ {
+ tree t;
+ for (t = TREE_OPERAND (exp, 1); t != NULL_TREE; t = TREE_CHAIN (t))
+ {
+ generate_bytecode_insns (method, TREE_VALUE (t), STACK_TARGET);
+ }
+ t = TREE_OPERAND (exp, 0);
+ if (TREE_CODE (t) == FUNCTION_DECL)
+ {
+ int index = find_methodref_index (code_cpool, t);
+ RESERVE (3);
+ if (DECL_CONSTRUCTOR_P (t))
+ OP1 (OPCODE_invokespecial);
+ else if (METHOD_STATIC (t))
+ OP1 (OPCODE_invokestatic);
+ else
+ OP1 (OPCODE_invokevirtual);
+ OP2 (index);
+ break;
+ }
+ }
+ /* fall through */
+ default:
+ error("internal error - tree code not implemented: ", TREE_CODE (exp));
+ }
+}
+
+/* Generate and return a list of chunks containing the class CLAS
+ in the .class file representation. The list can be written to a
+ .class file using write_chunks. Allocate chunks from obstack WORK. */
+
+/* Currently does not write any attributes i.e. no code. */
+
+struct chunk *
+generate_classfile (clas, work)
+ tree clas;
+ struct obstack *work;
+{
+ CPool cpool;
+ struct chunk head;
+ struct chunk *chunk;
+ struct chunk *cpool_chunk;
+ char *ptr;
+ int i;
+ char *fields_count_ptr;
+ int fields_count = 0;
+ char *methods_count_ptr;
+ int methods_count = 0;
+ tree part;
+ int total_supers
+ = clas == object_type_node ? 0
+ : TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (clas));
+
+ chunk = alloc_chunk (&head, NULL, 8, work);
+ ptr = chunk->data;
+ PUT4 (0xCafeBabe); /* Magic number */
+ PUT2 (3); /* Minor version */
+ PUT2 (45); /* Major version */
+
+ CPOOL_INIT(&cpool);
+ cpool_chunk = chunk = alloc_chunk (chunk, NULL, 0, work);
+
+ /* Next allocate the chunk containing acces_flags through fields_counr. */
+ if (clas == object_type_node)
+ i = 10;
+ else
+ i = 8 + 2 * total_supers;
+ chunk = alloc_chunk (chunk, NULL, i, work);
+ ptr = chunk->data;
+ i = get_access_flags (TYPE_NAME (clas)); PUT2 (i); /* acces_flags */
+ i = find_class_constant (&cpool, clas); PUT2 (i); /* this_class */
+ if (clas == object_type_node)
+ {
+ PUT2(0); /* super_class */
+ PUT2(0); /* interfaces_count */
+ }
+ else
+ {
+ tree basetypes = TYPE_BINFO_BASETYPES (clas);
+ tree base = BINFO_TYPE (TREE_VEC_ELT (basetypes, 0));
+ int j = find_class_constant (&cpool, base); PUT2 (j); /* super_class */
+ PUT2 (total_supers - 1); /* interfaces_count */
+ for (i = 1; i < total_supers; i++)
+ {
+ base = BINFO_TYPE (TREE_VEC_ELT (basetypes, i));
+ j = find_class_constant (&cpool, base);
+ PUT2 (j);
+ }
+ }
+ fields_count_ptr = ptr;
+
+ for (part = TYPE_FIELDS (clas); part; part = TREE_CHAIN (part))
+ {
+ if (DECL_NAME (part) == NULL_TREE)
+ continue;
+ chunk = alloc_chunk (chunk, NULL, 8, work);
+ ptr = chunk->data;
+ i = get_access_flags (part); PUT2 (i);
+ i = find_utf8_constant (&cpool, DECL_NAME (part)); PUT2 (i);
+ i = find_utf8_constant (&cpool, build_java_signature (TREE_TYPE (part)));
+ PUT2(i);
+ PUT2 (0); /* attributes_count */
+ /* FIXME - emit ConstantValue attribute when appropriate */
+ fields_count++;
+ }
+ ptr = fields_count_ptr; PUT2 (fields_count);
+
+ chunk = alloc_chunk (chunk, NULL, 2, work);
+ ptr = methods_count_ptr = chunk->data;
+ PUT2 (0);
+
+ for (part = TYPE_METHODS (clas); part; part = TREE_CHAIN (part))
+ {
+ tree body = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (part));
+ int linenumber_size; /* 4 * number of line number entries */
+ chunk = alloc_chunk (chunk, NULL, 8, work);
+ ptr = chunk->data;
+ i = get_access_flags (part); PUT2 (i);
+ i = find_utf8_constant (&cpool, DECL_NAME (part)); PUT2 (i);
+ i = find_utf8_constant (&cpool, build_java_signature (TREE_TYPE (part)));
+ PUT2 (i);
+ PUT2 (body != NULL_TREE ? 1 : 0); /* attributes_count */
+ if (body != NULL_TREE)
+ {
+ int code_attributes_count = 0;
+ int linenumber_size; /* 4 * number of line number entries */
+ int localvartable_size; /* 10 * number of local variable entries */
+ static tree Code_node = NULL_TREE;
+ tree t;
+ char *attr_len_ptr;
+ int code_length;
+ if (Code_node == NULL_TREE)
+ Code_node = get_identifier ("Code");
+ chunk = alloc_chunk (chunk, NULL, 14, work);
+ ptr = chunk->data;
+ i = find_utf8_constant (&cpool, Code_node); PUT2 (i);
+ attr_len_ptr = ptr;
+ BUFFER_RESET (&bytecode);
+ BUFFER_RESET (&localvartable);
+ BUFFER_RESET (&linenumbers);
+ BUFFER_RESET (&localvars);
+ code_SP = 0;
+ code_SP_max = 0;
+ code_cpool = &cpool;
+ for (t = DECL_ARGUMENTS (part); t != NULL_TREE; t = TREE_CHAIN (t))
+ localvar_alloc (t, 0);
+ generate_bytecode_insns (part, body, IGNORE_TARGET);
+ code_length = PC;
+ for (t = DECL_ARGUMENTS (part); t != NULL_TREE; t = TREE_CHAIN (t))
+ localvar_free (t, code_length);
+ linenumber_size = BUFFER_LENGTH (&linenumbers);
+ localvartable_size = BUFFER_LENGTH (&localvartable);
+ chunk = alloc_chunk (chunk, NULL, code_length, work);
+ bcopy (bytecode.data, chunk->data, code_length);
+ ptr = attr_len_ptr;
+ i = 8 + code_length + 4;
+ if (linenumber_size > 0)
+ {
+ code_attributes_count++;
+ i += 8 + linenumber_size;
+ }
+ if (localvartable_size > 0)
+ {
+ code_attributes_count++;
+ i += 8 + localvartable_size;
+ }
+ PUT4 (i); /* attribute_length */
+ PUT2 (code_SP_max); /* max_stack */
+ PUT2 (localvar_max); /* max_locals */
+ PUT4 (code_length);
+ chunk = alloc_chunk (chunk, NULL, 4, work);
+ ptr = chunk->data;
+ PUT2 (0); /* exception_table_length */
+ PUT2 (code_attributes_count);
+
+ /* Write the LineNumberTable attribute. */
+ if (linenumber_size > 0)
+ {
+ static tree LineNumberTable_node = NULL_TREE;
+ chunk = alloc_chunk (chunk, NULL, 8 + linenumber_size, work);
+ ptr = chunk->data;
+ if (LineNumberTable_node == NULL_TREE)
+ LineNumberTable_node = get_identifier ("LineNumberTable");
+ i = find_utf8_constant (&cpool, LineNumberTable_node);
+ PUT2 (i); /* attribute_name_index */
+ i = 2 + linenumber_size; PUT4 (i); /* attribute_length */
+ i = linenumber_size >> 2; PUT2 (i);
+ PUTN (linenumbers.data, linenumber_size);
+ }
+
+ /* Write the LocalVariableTable attribute. */
+ if (localvartable_size > 0)
+ {
+ static tree LocalVariableTable_node = NULL_TREE;
+ chunk = alloc_chunk (chunk, NULL, 8 + localvartable_size, work);
+ ptr = chunk->data;
+ if (LocalVariableTable_node == NULL_TREE)
+ LocalVariableTable_node = get_identifier("LocalVariableTable");
+ i = find_utf8_constant (&cpool, LocalVariableTable_node);
+ PUT2 (i); /* attribute_name_index */
+ i = 2 + localvartable_size; PUT4 (i); /* attribute_length */
+ i = localvartable_size / 10; PUT2 (i);
+ PUTN (localvartable.data, localvartable_size);
+ }
+ }
+ methods_count++;
+ }
+ ptr = methods_count_ptr; PUT2 (methods_count);
+
+ chunk = alloc_chunk (chunk, NULL, 2, work);
+ ptr = chunk->data;
+ PUT2 (0); /* attributes_count */
+
+ /* New finally generate the contents of the constant pool chunk. */
+ i = count_constant_pool_bytes (&cpool);
+ ptr = obstack_alloc (work, i);
+ cpool_chunk->data = ptr;
+ cpool_chunk->size = i;
+ write_constant_pool (&cpool, ptr, i);
+ CPOOL_FINISH (&cpool);
+ return head.next;
+}
+
+char*
+make_class_file_name (clas)
+ tree clas;
+{
+ /* Should prepend an output directly, but need an option to specify it. */
+ return IDENTIFIER_POINTER (identifier_subst (DECL_NAME (TYPE_NAME (clas)),
+ "", '.', '/', ".class"));
+}
+
+/* Write out the contens of a class (RECORD_TYPE) CLAS, as a .class file.
+ The output .class file name is make_class_file_name(CLAS). */
+
+void
+write_classfile (clas)
+ tree clas;
+{
+ struct obstack *work = &temporary_obstack;
+ char *class_file_name = make_class_file_name (clas);
+ struct chunk *chunks;
+ FILE* stream = fopen (class_file_name, "wb");
+ if (stream == NULL)
+ fatal ("failed to open `%s' for writing", class_file_name);
+ chunks = generate_classfile (clas, work);
+ write_chunks (stream, chunks);
+ if (fclose (stream))
+ fatal ("failed to close after writing `%s'", class_file_name);
+ obstack_free (work, chunks);
+}
--- /dev/null
+/* Utility macros to read Java(TM) .class files and byte codes.
+
+ Copyright (C) 1996 Free Software Foundation, Inc.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
+
+#ifndef JCF_H
+#define JCF_H
+#include "javaop.h"
+#ifndef DEFUN
+#if defined (__STDC__)
+#define AND ,
+#define PTR void *
+#define DEFUN(name, arglist, args) name(args)
+#else
+#define PTR char *
+#define AND ;
+#define DEFUN(name, arglist, args) name arglist args;
+#define inline static
+#endif
+#endif /* !DEFUN */
+
+#ifndef PROTO
+#if defined (__STDC__)
+#define PROTO(paramlist) paramlist
+#else
+#define PROTO(paramlist) ()
+#endif
+#endif
+
+#ifndef JCF_u4
+#define JCF_u4 unsigned long
+#endif
+#ifndef JCF_u2
+#define JCF_u2 unsigned short
+#endif
+
+#define ALLOC (void*)malloc
+#define REALLOC (void*)realloc
+#ifndef FREE
+#define FREE(PTR) free(PTR)
+#endif
+
+#ifdef JCF_word
+#define JCF_word JCF_u4
+#endif
+
+#define JCF_ZIP 1
+#define JCF_CLASS 2
+#define JCF_SOURCE 3
+
+struct JCF;
+typedef int (*jcf_filbuf_t) PROTO ((struct JCF*, int needed));
+
+typedef struct CPool {
+ /* Available number of elements in the constants array, before it
+ must be re-allocated. */
+ int capacity;
+
+ /* The constant_pool_count. */
+ int count;
+
+ uint8* tags;
+
+ jword* data;
+} CPool;
+
+/* JCF encapsulates the state of reading a Java Class File. */
+
+typedef struct JCF {
+ unsigned char *buffer;
+ unsigned char *buffer_end;
+ unsigned char *read_ptr;
+ unsigned char *read_end;
+ int seen_in_zip;
+ int java_source;
+ int outofsynch; /* Found a class file out of synch
+ with the matching source file. */
+ long zip_offset;
+ jcf_filbuf_t filbuf;
+ void *read_state;
+ char *filename;
+ char *classname;
+ void *zipd; /* Directory entry where it was found */
+ JCF_u2 access_flags, this_class, super_class;
+ CPool cpool;
+} JCF;
+/*typedef JCF* JCF_FILE;*/
+
+/* The CPOOL macros take a (pointer to a) CPool.
+ The JPOOL macros take a (pointer to a) JCF.
+ Some of the latter should perhaps be deprecated or removed. */
+
+#define CPOOL_COUNT(CPOOL) ((CPOOL)->count)
+#define JPOOL_SIZE(JCF) CPOOL_COUNT(&(JCF)->cpool)
+#define JPOOL_TAG(JCF, INDEX) ((JCF)->cpool.tags[INDEX])
+/* The INDEX'th constant pool entry as a JCF_u4. */
+#define CPOOL_UINT(CPOOL, INDEX) ((CPOOL)->data[INDEX])
+#define JPOOL_UINT(JCF, INDEX) CPOOL_UINT(&(JCF)->cpool, INDEX) /*deprecated*/
+/* The first uint16 of the INDEX'th constant pool entry. */
+#define CPOOL_USHORT1(CPOOL, INDEX) ((CPOOL)->data[INDEX] & 0xFFFF)
+#define JPOOL_USHORT1(JCF, INDEX) CPOOL_USHORT1(&(JCF)->cpool, INDEX)
+/* The second uint16 of the INDEX'th constant pool entry. */
+#define CPOOL_USHORT2(CPOOL, INDEX) ((CPOOL)->data[INDEX] >> 16)
+#define JPOOL_USHORT2(JCF, INDEX) CPOOL_USHORT2(&(JCF)->cpool, INDEX)
+#define JPOOL_LONG(JCF, INDEX) \
+ WORDS_TO_LONG (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
+#define JPOOL_DOUBLE(JCF, INDEX) \
+ WORDS_TO_DOUBLE (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
+#ifndef JPOOL_UTF_LENGTH
+#define JPOOL_UTF_LENGTH(JCF, INDEX) \
+ GET_u2 ((JCF)->buffer+JPOOL_UINT(JCF, INDEX))
+#endif
+#ifndef JPOOL_UTF_DATA
+#define JPOOL_UTF_DATA(JCF, INDEX) \
+ ((JCF)->buffer+JPOOL_UINT(JCF, INDEX)+2)
+#endif
+#define JPOOL_INT(JCF, INDEX) ((jint) JPOOL_UINT (JCF, INDEX))
+#define JPOOL_FLOAT(JCF, INDEX) WORD_TO_FLOAT (JPOOL_UINT (JCF, INDEX))
+
+#define CPOOL_INDEX_IN_RANGE(CPOOL, INDEX) \
+ ((INDEX) > 0 && (INDEX) < CPOOL_COUNT(CPOOL))
+
+#define CPOOL_FINISH(CPOOL) { \
+ if ((CPOOL)->tags) FREE ((CPOOL)->tags); \
+ if ((CPOOL)->data) FREE ((CPOOL)->data); }
+
+#define JCF_FINISH(JCF) { \
+ CPOOL_FINISH(&(JCF)->cpool); \
+ if ((JCF)->buffer) FREE ((JCF)->buffer); \
+ if ((JCF)->filename) FREE ((JCF)->filename); \
+ if ((JCF)->classname) FREE ((JCF)->classname); }
+
+#define CPOOL_INIT(CPOOL) \
+ ((CPOOL)->capacity = 0, (CPOOL)->count = 0, (CPOOL)->tags = 0, (CPOOL)->data = 0)
+
+#define CPOOL_REINIT(CPOOL) ((CPOOL)->count = 0)
+
+#define JCF_ZERO(JCF) \
+ ((JCF)->buffer = (JCF)->buffer_end = (JCF)->read_ptr = (JCF)->read_end = 0,\
+ (JCF)->read_state = 0, (JCF)->filename = (JCF)->classname = 0, \
+ CPOOL_INIT(&(JCF)->cpool), (JCF)->java_source = 0)
+
+/* Given that PTR points to a 2-byte unsigned integer in network
+ (big-endian) byte-order, return that integer. */
+#define GET_u2(PTR) (((PTR)[0] << 8) | ((PTR)[1]))
+/* Like GET_u2, but for little-endian format. */
+#define GET_u2_le(PTR) (((PTR)[1] << 8) | ((PTR)[0]))
+
+/* Given that PTR points to a 4-byte unsigned integer in network
+ (big-endian) byte-order, return that integer. */
+#define GET_u4(PTR) (((JCF_u4)(PTR)[0] << 24) | ((JCF_u4)(PTR)[1] << 16) \
+ | ((JCF_u4)(PTR)[2] << 8) | ((JCF_u4)(PTR)[3]))
+/* Like GET_u4, but for little-endian order. */
+#define GET_u4_le(PTR) (((JCF_u4)(PTR)[3] << 24) | ((JCF_u4)(PTR)[2] << 16) \
+ | ((JCF_u4)(PTR)[1] << 8) | ((JCF_u4)(PTR)[0]))
+
+/* Make sure there are COUNT bytes readable. */
+#define JCF_FILL(JCF, COUNT) \
+ ((JCF)->read_end-(JCF)->read_ptr >= (COUNT) ? 0 : (*(JCF)->filbuf)(JCF, COUNT))
+#define JCF_GETC(JCF) (JCF_FILL(JCF, 1) ? -1 : *(JCF)->read_ptr++)
+#define JCF_READ(JCF, BUFFER, N) \
+ (memcpy (BUFFER, (JCF)->read_ptr, N), (JCF)->read_ptr += (N))
+#define JCF_SKIP(JCF,N) ((JCF)->read_ptr += (N))
+#define JCF_readu(JCF) (*(JCF)->read_ptr++)
+
+/* Reads an unsigned 2-byte integer in network (big-endian) byte-order
+ from JCF. Returns that integer.
+ Does not check for EOF (make sure to call JCF_FILL before-hand). */
+#define JCF_readu2(JCF) ((JCF)->read_ptr += 2, GET_u2 ((JCF)->read_ptr-2))
+#define JCF_readu2_le(JCF) ((JCF)->read_ptr += 2, GET_u2_le((JCF)->read_ptr-2))
+
+/* Like JCF_readu2, but read a 4-byte unsigned integer. */
+#define JCF_readu4(JCF) ((JCF)->read_ptr += 4, GET_u4 ((JCF)->read_ptr-4))
+#define JCF_readu4_le(JCF) ((JCF)->read_ptr += 4, GET_u4_le((JCF)->read_ptr-4))
+
+#define JCF_TELL(JCF) ((JCF)->read_ptr - (JCF)->buffer)
+#define JCF_SEEK(JCF, POS) ((JCF)->read_ptr = (JCF)->buffer + (POS))
+
+#define ACC_PUBLIC 0x0001
+#define ACC_PRIVATE 0x0002
+#define ACC_PROTECTED 0x0004
+#define ACC_STATIC 0x0008
+#define ACC_FINAL 0x0010
+#define ACC_SYNCHRONIZED 0x0020
+#define ACC_SUPER 0x0020
+#define ACC_VOLATILE 0x0040
+#define ACC_TRANSIENT 0x0080
+#define ACC_NATIVE 0x0100
+#define ACC_INTERFACE 0x0200
+#define ACC_ABSTRACT 0x0400
+
+#define CONSTANT_Class 7
+#define CONSTANT_Fieldref 9
+#define CONSTANT_Methodref 10
+#define CONSTANT_InterfaceMethodref 11
+#define CONSTANT_String 8
+#define CONSTANT_Integer 3
+#define CONSTANT_Float 4
+#define CONSTANT_Long 5
+#define CONSTANT_Double 6
+#define CONSTANT_NameAndType 12
+#define CONSTANT_Utf8 1
+#define CONSTANT_Unicode 2
+
+extern char *classpath;
+#define DEFAULT_CLASS_PATH "."
+
+extern char *find_class PROTO ((const char *, int, JCF*, int));
+extern char *find_classfile PROTO ((char *, JCF*));
+extern int jcf_filbuf_from_stdio PROTO ((JCF *jcf, int count));
+extern void jcf_out_of_synch PROTO((JCF *));
+extern int jcf_unexpected_eof PROTO ((JCF*, int));
+
+/* Extract a character from a Java-style Utf8 string.
+ * PTR points to the current character.
+ * LIMIT points to the end of the Utf8 string.
+ * PTR is incremented to point after the character thta gets returns.
+ * On an error, -1 is returned. */
+#define UTF8_GET(PTR, LIMIT) \
+ ((PTR) >= (LIMIT) ? -1 \
+ : *(PTR) < 128 ? *(PTR)++ \
+ : (*(PTR)&0xE0) == 0xC0 && ((PTR)+=2)<=(LIMIT) && ((PTR)[-1]&0xC0) == 0x80 \
+ ? (((PTR)[-2] & 0x1F) << 6) + ((PTR)[-1] & 0x3F) \
+ : (*(PTR) & 0xF0) == 0xE0 && ((PTR) += 3) <= (LIMIT) \
+ && ((PTR)[-2] & 0xC0) == 0x80 && ((PTR)[-1] & 0xC0) == 0x80 \
+ ? (((PTR)[-3]&0x1F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \
+ : ((PTR)++, -1))
+
+/* Debug macros, for the front end */
+
+extern int quiet_flag;
+#ifdef SOURCE_FRONTEND_DEBUG
+#undef SOURCE_FRONTEND_DEBUG
+#define SOURCE_FRONTEND_DEBUG(X) \
+ {if (!quiet_flag) {printf ("* "); printf X; putchar ('\n');} }
+#else
+#define SOURCE_FRONTEND_DEBUG(X)
+#endif
+
+#endif
--- /dev/null
+/* Main for jv-scan
+ Copyright (C) 1998 Free Software Foundation, Inc.
+ Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __STDC__
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+#include "gansidecl.h" /* Definitions of PROTO and VPROTO */
+#include "obstack.h" /* We use obstacks in lex.c */
+
+void fatal VPROTO((char *s, ...));
+void warning VPROTO((char *s, ...));
+void gcc_obstack_init PROTO ((struct obstack *obstack));
+extern void reset_report PROTO ((void));
+
+#define JC1_LITE
+#include "parse.h"
+
+/* Current input file and output file IO streams. */
+FILE *finput, *out;
+
+/* Current input filename. */
+char *input_filename;
+
+/* Executable name. */
+char *exec_name;
+
+/* Flags matching command line options. */
+int flag_find_main = 0;
+int flag_dump_class = 0;
+int flag_list_filename = 0;
+
+/* jc1-lite main entry point */
+int
+main (argc, argv, envp)
+ int argc;
+ char **argv;
+ char **envp;
+{
+ int i = 1;
+ char *output_file = NULL;
+ long ft;
+
+ exec_name = argv[0];
+
+ /* Default for output */
+ out = stdout;
+
+ /* Process options first */
+ while (argv [i])
+ {
+ if (argv [i][0] == '-')
+ {
+ /* Dump result into a file */
+ if (!strcmp (argv [i], "-o") && i+1 < argc)
+ {
+ argv [i] = NULL;
+ output_file = argv [++i];
+ argv [i] = NULL;
+ }
+
+ /* Print the name of the class that contains main */
+ else if (!strcmp (argv [i], "--print-main"))
+ flag_find_main = 1;
+
+ else if (!strcmp (argv [i], "--list-filename"))
+ flag_list_filename = 1;
+
+ /* List all the classes found in a source file */
+ else if (!strcmp (argv [i], "--list-class"))
+ flag_dump_class = 1;
+
+ else
+ warning ("Unrecognized argument `%s'", argv[i]);
+
+ /* non recognized argument ignored silently */
+ argv [i] = NULL; /* Nullify so it's not considered a file */
+ }
+ i++;
+ }
+
+ /* No flags? Do nothing */
+ if (!flag_find_main && !flag_dump_class)
+ exit (0);
+
+ /* Check on bad usage */
+ if (flag_find_main && flag_dump_class)
+ fatal ("Options `--print-main' and `--list-class' can't be turned on "
+ "at the same time", argv [0]);
+
+ if (output_file && !(out = fopen (output_file, "w")))
+ fatal ("Can't open output file `%s'", argv [0], output_file);
+
+ ft = ftell (out);
+
+ gcc_obstack_init (&temporary_obstack);
+ java_push_parser_context ();
+
+ for ( i = 1; i < argc; i++ )
+ if (argv [i])
+ {
+ input_filename = argv [i];
+ if ( (finput = fopen (argv [i], "r")) )
+ {
+ java_init_lex ();
+ yyparse ();
+ if (ftell (out) != ft)
+ fputc ('\n', out);
+ ft = ftell (out);
+ fclose (finput);
+ reset_report ();
+ }
+ else
+ fatal ("File not found `%s'", argv [0], argv [i]);
+ }
+
+ /* Flush and close */
+ if (ftell (out) != ft)
+ fputc ('\n', out);
+ if (!output_file)
+ fclose (out);
+
+ exit (0);
+}
+
+/* Error report, memory, obstack initialization and other utility
+ functions */
+
+void
+fatal VPROTO((char *s, ...))
+{
+#ifndef __STDC__
+ char *s;
+#endif
+ va_list ap;
+
+ VA_START (ap, s);
+
+#ifndef __STDC__
+ s = va_arg (ap, char *);
+#endif
+
+ fprintf (stderr, "%s: error: ", exec_name);
+ vfprintf (stderr, s, ap);
+ fputc ('\n', stderr);
+ va_end (ap);
+ exit (1);
+}
+
+char *
+xmalloc (size)
+ unsigned size;
+{
+ register char *value;
+
+ if (size == 0)
+ size = 1;
+
+ value = (char *) malloc (size);
+ if (value == 0)
+ fatal ("virtual memory exhausted");
+ return value;
+}
+
+char *
+xstrdup (string)
+ char *string;
+{
+ int length = strlen (string)+1;
+ char *to_return = xmalloc (length);
+ strcpy (to_return, string);
+ return to_return;
+}
+
+void
+warning VPROTO((char *s, ...))
+{
+#ifndef __STDC__
+ char *s;
+#endif
+ va_list ap;
+
+ VA_START (ap, s);
+
+#ifndef __STDC__
+ s = va_arg (ap, char *);
+#endif
+
+ fprintf (stderr, "%s: warning: ", exec_name);
+ vfprintf (stderr, s, ap);
+ fputc ('\n', stderr);
+ va_end (ap);
+}
+
+void
+gcc_obstack_init (obstack)
+ struct obstack *obstack;
+{
+ /* Let particular systems override the size of a chunk. */
+#ifndef OBSTACK_CHUNK_SIZE
+#define OBSTACK_CHUNK_SIZE 0
+#endif
+ /* Let them override the alloc and free routines too. */
+#ifndef OBSTACK_CHUNK_ALLOC
+#define OBSTACK_CHUNK_ALLOC xmalloc
+#endif
+#ifndef OBSTACK_CHUNK_FREE
+#define OBSTACK_CHUNK_FREE free
+#endif
+ _obstack_begin (obstack, OBSTACK_CHUNK_SIZE, 0,
+ (void *(*) ()) OBSTACK_CHUNK_ALLOC,
+ (void (*) ()) OBSTACK_CHUNK_FREE);
+}
--- /dev/null
+/* Program to generate "main" a Java(TM) class containing a main method.
+ Copyright (C) 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Written by Per Bothner <bothner@cygnus.com> */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "config.h"
+#include "obstack.h"
+
+const char main_method_prefix[] = "main__";
+const char main_method_suffix[] = "Pt6JArray1ZPQ34java4lang6String";
+const char class_mangling_prefix[] = "_CL_";
+
+struct obstack name_obstack;
+
+void
+error (const char *str)
+{
+ fprintf (stderr, "%s\n", str);
+ exit (-1);
+}
+
+void *
+xmalloc (size)
+ size_t size;
+{
+ void *ptr = malloc (size);
+ if (ptr == NULL)
+ {
+ fprintf (stderr, "Not enough memory!\n");
+ exit (-1);
+ }
+ return ptr;
+}
+
+void
+gcc_obstack_init (obstack)
+ struct obstack *obstack;
+{
+ /* Let particular systems override the size of a chunk. */
+#ifndef OBSTACK_CHUNK_SIZE
+#define OBSTACK_CHUNK_SIZE 0
+#endif
+ /* Let them override the alloc and free routines too. */
+#ifndef OBSTACK_CHUNK_ALLOC
+#define OBSTACK_CHUNK_ALLOC xmalloc
+#endif
+#ifndef OBSTACK_CHUNK_FREE
+#define OBSTACK_CHUNK_FREE free
+#endif
+ _obstack_begin (obstack, OBSTACK_CHUNK_SIZE, 0,
+ (void *(*) ()) OBSTACK_CHUNK_ALLOC,
+ (void (*) ()) OBSTACK_CHUNK_FREE);
+}
+
+int
+main (int argc, const char **argv)
+{
+ const char *classname;
+ FILE *stream;
+ char *mangled_classname;
+
+ if (argc < 2 || argc > 3)
+ {
+ fprintf (stderr, "Usage: %s CLASSNAME [OUTFILE]\n", argv[0]);
+ exit(-1);
+ }
+
+ classname = argv[1];
+
+ gcc_obstack_init (&name_obstack);
+ append_gpp_mangled_classtype (&name_obstack, classname);
+ mangled_classname = obstack_finish (&name_obstack);
+
+ if (argc > 2 && strcmp (argv[2], "-") != 0)
+ {
+ const char *outfile = argv[2];
+ stream = fopen (outfile, "w");
+ if (stream == NULL)
+ {
+ fprintf (stderr, "%s: Cannot open output file: %s\n",
+ argv[0], outfile);
+ exit (-1);
+ }
+ }
+ else
+ stream = stdout;
+ fprintf (stream, "extern struct Class %s%s;\n",
+ class_mangling_prefix, mangled_classname);
+ fprintf (stream, "int main (int argc, const char **argv)\n");
+ fprintf (stream, "{\n");
+ fprintf (stream, " JvRunMain (&%s%s, argc, argv);\n",
+ class_mangling_prefix, mangled_classname);
+ fprintf (stream, "}\n");
+ if (stream != stdout && fclose (stream) != 0)
+ {
+ fprintf (stderr, "%s: Failed to close output file %s\n",
+ argv[0], argv[2]);
+ exit (-1);
+ }
+ return 0;
+}
--- /dev/null
+/* Specific flags and argument handling of the front-end of the
+ GNU compiler for the Java(TM) language.
+ Copyright (C) 1996, 1997, 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+#include "config.h"
+
+#include "system.h"
+
+#include "gansidecl.h"
+
+#if defined (WITH_THREAD_posix) || defined (WITH_THREAD_pthreads)
+#define THREAD_NAME "-lpthread"
+#elif defined (WITH_THREAD_qt)
+#define THREAD_NAME "-lqthreads"
+#endif
+
+/* This bit is set if we saw a `-xfoo' language specification. */
+#define LANGSPEC (1<<1)
+/* This bit is set if they did `-lm' or `-lmath'. */
+#define MATHLIB (1<<2)
+/* This bit is set if they did `-lc'. */
+#define WITHLIBC (1<<3)
+/* This bit is set if they did `-lgc'. */
+#define GCLIB (1<<4)
+/* This bit is set if they did `-lpthread' (or added some other thread
+ library). */
+#define THREADLIB (1<<5)
+
+#ifndef MATH_LIBRARY
+#define MATH_LIBRARY "-lm"
+#endif
+
+extern char *xmalloc PROTO((size_t));
+extern int do_spec PROTO((char *));
+extern char *input_filename;
+extern size_t input_filename_length;
+
+char *main_class_name = NULL;
+int lang_specific_extra_outfiles = 0;
+
+char jvgenmain_spec[] =
+ "jvgenmain %i %{!pipe:%g.i} |\n\
+ cc1 %{!pipe:%g.i} %1 \
+ %{!Q:-quiet} -dumpbase %b.c %{d*} %{m*} %{a*}\
+ %{g*} %{O*} \
+ %{v:-version} %{pg:-p} %{p} %{f*}\
+ %{aux-info*}\
+ %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
+ %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
+ %{!S:as %a %Y -o %w%b%O %{!pipe:%g.s} %A\n }";
+
+void
+lang_specific_driver (fn, in_argc, in_argv, in_added_libraries)
+ void (*fn)();
+ int *in_argc;
+ char ***in_argv;
+ int *in_added_libraries;
+{
+ int i, j;
+
+ /* If non-zero, the user gave us the `-v' flag. */
+ int saw_verbose_flag = 0;
+
+ /* This will be 0 if we encounter a situation where we should not
+ link in libjava. */
+ int library = 1;
+
+ /* The number of arguments being added to what's in argv, other than
+ libraries. We use this to track the number of times we've inserted
+ -xc++/-xnone. */
+ int added = 2;
+
+ /* Used to track options that take arguments, so we don't go wrapping
+ those with -xc++/-xnone. */
+ char *quote = NULL;
+
+ /* The new argument list will be contained in this. */
+ char **arglist;
+
+ /* Non-zero if we saw a `-xfoo' language specification on the
+ command line. Used to avoid adding our own -xc++ if the user
+ already gave a language for the file. */
+ int saw_speclang = 0;
+
+ /* "-lm" or "-lmath" if it appears on the command line. */
+ char *saw_math = 0;
+
+ /* "-lc" if it appears on the command line. */
+ char *saw_libc = 0;
+
+ /* "-lgc" if it appears on the command line. */
+ char *saw_gc = 0;
+
+ /* Saw `-l' option for the thread library. */
+ char *saw_threadlib = 0;
+
+ /* Saw `-ljava' on command line. */
+ int saw_libjava = 0;
+
+ /* An array used to flag each argument that needs a bit set for
+ LANGSPEC, MATHLIB, WITHLIBC, or GCLIB. */
+ int *args;
+
+ /* By default, we throw on the math library. */
+ int need_math = 1;
+
+ /* By default, we throw in the thread library (if one is required).
+ */
+ int need_thread = 1;
+
+ /* The total number of arguments with the new stuff. */
+ int argc;
+
+ /* The argument list. */
+ char **argv;
+
+ /* The number of libraries added in. */
+ int added_libraries;
+
+ /* The total number of arguments with the new stuff. */
+ int num_args = 1;
+
+ argc = *in_argc;
+ argv = *in_argv;
+ added_libraries = *in_added_libraries;
+
+ args = (int *) xmalloc (argc * sizeof (int));
+ bzero ((char *) args, argc * sizeof (int));
+
+ for (i = 1; i < argc; i++)
+ {
+ /* If the previous option took an argument, we swallow it here. */
+ if (quote)
+ {
+ quote = NULL;
+ continue;
+ }
+
+ /* We don't do this anymore, since we don't get them with minus
+ signs on them. */
+ if (argv[i][0] == '\0' || argv[i][1] == '\0')
+ continue;
+
+ if (argv[i][0] == '-')
+ {
+ if (library != 0 && (strcmp (argv[i], "-nostdlib") == 0
+ || strcmp (argv[i], "-nodefaultlibs") == 0))
+ {
+ library = 0;
+ }
+ else if (strcmp (argv[i], "-lm") == 0
+ || strcmp (argv[i], "-lmath") == 0
+#ifdef ALT_LIBM
+ || strcmp (argv[i], ALT_LIBM) == 0
+#endif
+ )
+ {
+ args[i] |= MATHLIB;
+ need_math = 0;
+ }
+ else if (strncmp (argv[i], "-fmain=", 7) == 0)
+ main_class_name = argv[i] + 7;
+ else if (strcmp (argv[i], "-ljava") == 0)
+ saw_libjava = 1;
+ else if (strcmp (argv[i], "-lc") == 0)
+ args[i] |= WITHLIBC;
+ else if (strcmp (argv[i], "-lgc") == 0)
+ args[i] |= GCLIB;
+#ifdef THREAD_NAME
+ else if (strcmp (argv[i], THREAD_NAME) == 0)
+ {
+ args[i] |= THREADLIB;
+ need_thread = 0;
+ }
+#endif
+ else if (strcmp (argv[i], "-v") == 0)
+ {
+ saw_verbose_flag = 1;
+ if (argc == 2)
+ {
+ /* If they only gave us `-v', don't try to link
+ in libjava. */
+ library = 0;
+ }
+ }
+ else if (strncmp (argv[i], "-x", 2) == 0)
+ saw_speclang = 1;
+ else if (((argv[i][2] == '\0'
+ && (char *)strchr ("bBVDUoeTuIYmLiA", argv[i][1]) != NULL)
+ || strcmp (argv[i], "-Tdata") == 0))
+ quote = argv[i];
+ else if (library != 0 && ((argv[i][2] == '\0'
+ && (char *) strchr ("cSEM", argv[i][1]) != NULL)
+ || strcmp (argv[i], "-MM") == 0))
+ {
+ /* Don't specify libraries if we won't link, since that would
+ cause a warning. */
+ library = 0;
+ added -= 2;
+ }
+ else
+ /* Pass other options through. */
+ continue;
+ }
+ else
+ {
+ int len;
+
+ if (saw_speclang)
+ {
+ saw_speclang = 0;
+ continue;
+ }
+
+ /* If the filename ends in .c or .i, put options around it.
+ But not if a specified -x option is currently active. */
+ len = strlen (argv[i]);
+ if (len > 2
+ && (argv[i][len - 1] == 'c' || argv[i][len - 1] == 'i')
+ && argv[i][len - 2] == '.')
+ {
+ args[i] |= LANGSPEC;
+ added += 2;
+ }
+ }
+ }
+
+ if (quote)
+ (*fn) ("argument to `%s' missing\n", quote);
+
+ /* If we know we don't have to do anything, bail now. */
+ if (! added && ! library && main_class_name == NULL)
+ {
+ free (args);
+ return;
+ }
+
+ num_args = argc + added + need_math + need_thread;
+ if (main_class_name)
+ {
+ lang_specific_extra_outfiles++;
+ }
+ arglist = (char **) xmalloc (num_args * sizeof (char *));
+
+ /* NOTE: We start at 1 now, not 0. */
+ for (i = 0, j = 0; i < argc; i++, j++)
+ {
+ arglist[j] = argv[i];
+
+ if (strncmp (argv[i], "-fmain=", 7) == 0)
+ {
+ --j;
+ continue;
+ }
+
+ /* Make sure -ljava is before the math library, since libjava
+ itself uses those math routines. */
+ if (!saw_math && (args[i] & MATHLIB) && library)
+ {
+ --j;
+ saw_math = argv[i];
+ }
+
+ /* Likewise -ljava must come before -lc. */
+ if (!saw_libc && (args[i] & WITHLIBC) && library)
+ {
+ --j;
+ saw_libc = argv[i];
+ }
+
+ /* And -ljava must come before -lgc. */
+ if (!saw_gc && (args[i] & GCLIB) && library)
+ {
+ --j;
+ saw_gc = argv[i];
+ }
+
+ /* And -ljava must come before thread library. */
+ if (!saw_threadlib && (args[i] & THREADLIB) && library)
+ {
+ --j;
+ saw_threadlib = argv[i];
+ }
+ }
+
+ /* Add `-ljava' if we haven't already done so. */
+ if (library && ! saw_libjava)
+ {
+ arglist[j++] = "-ljava";
+ added_libraries++;
+ }
+
+ if (saw_math)
+ arglist[j++] = saw_math;
+ else if (library)
+ {
+ arglist[j++] = MATH_LIBRARY;
+ added_libraries++;
+ }
+
+ /* FIXME: we need a way to know when the GC library should be
+ added. Then we can add it if the user hasn't already. */
+ if (saw_gc)
+ arglist[j++] = saw_gc;
+
+ /* Thread library must come after GC library as well as after
+ -ljava. */
+ if (saw_threadlib)
+ arglist[j++] = saw_threadlib;
+#ifdef THREAD_NAME
+ else if (library)
+ {
+ arglist[j++] = THREAD_NAME;
+ added_libraries++;
+ }
+#endif
+
+ if (saw_libc)
+ arglist[j++] = saw_libc;
+
+ arglist[j] = NULL;
+
+ *in_argc = j;
+ *in_argv = arglist;
+ *in_added_libraries = added_libraries;
+}
+
+int
+lang_specific_pre_link ()
+{
+ if (main_class_name == NULL)
+ return 0;
+ input_filename = main_class_name;
+ input_filename_length = strlen (main_class_name);
+ return do_spec (jvgenmain_spec);
+}
--- /dev/null
+%{
+/* Keyword definition for the GNU compiler for the Java(TM) language.
+ Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+ Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+%}
+struct java_keyword { char *name; int token; };
+%%
+abstract, ABSTRACT_TK
+default, DEFAULT_TK
+if, IF_TK
+private, PRIVATE_TK
+throw, THROW_TK
+boolean, BOOLEAN_TK
+do, DO_TK
+implements, IMPLEMENTS_TK
+protected, PROTECTED_TK
+throws, THROWS_TK
+break, BREAK_TK
+double, DOUBLE_TK
+import, IMPORT_TK
+public, PUBLIC_TK
+transient, TRANSIENT_TK
+byte, BYTE_TK
+else, ELSE_TK
+instanceof, INSTANCEOF_TK
+return, RETURN_TK
+try, TRY_TK
+case, CASE_TK
+extends, EXTENDS_TK
+int, INT_TK
+short, SHORT_TK
+void, VOID_TK
+catch, CATCH_TK
+final, FINAL_TK
+interface, INTERFACE_TK
+static, STATIC_TK
+volatile, VOLATILE_TK
+char, CHAR_TK
+finally, FINALLY_TK
+long, LONG_TK
+super, SUPER_TK
+while, WHILE_TK
+class, CLASS_TK
+float, FLOAT_TK
+native, NATIVE_TK
+switch, SWITCH_TK
+const, CONST_TK
+for, FOR_TK
+new, NEW_TK
+synchronized, SYNCHRONIZED_TK
+continue, CONTINUE_TK
+goto, GOTO_TK
+package, PACKAGE_TK
+this, THIS_TK
+# true, false and null aren't keyword. But we match them easily this way
+true, TRUE_TK
+false, FALSE_TK
+null, NULL_TK
--- /dev/null
+/* C code produced by gperf version 2.5 (GNU C++ version) */
+/* Command-line: gperf -p -t -j1 -i 1 -g -o -N java_keyword -k1,3,$ keyword.gperf */
+/* Keyword definitions for the GNU compiler for the Java(TM) language.
+ Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+ Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+struct java_keyword { char *name; int token; };
+
+#define TOTAL_KEYWORDS 50
+#define MIN_WORD_LENGTH 2
+#define MAX_WORD_LENGTH 12
+#define MIN_HASH_VALUE 6
+#define MAX_HASH_VALUE 86
+/* maximum key range = 81, duplicates = 0 */
+
+#ifdef __GNUC__
+inline
+#endif
+static unsigned int
+hash (str, len)
+ register char *str;
+ register int unsigned len;
+{
+ static unsigned char asso_values[] =
+ {
+ 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
+ 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
+ 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
+ 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
+ 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
+ 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
+ 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
+ 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
+ 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
+ 87, 87, 87, 87, 87, 87, 87, 18, 37, 38,
+ 27, 1, 30, 3, 12, 8, 87, 2, 11, 87,
+ 8, 1, 5, 87, 24, 1, 1, 30, 2, 36,
+ 87, 1, 87, 87, 87, 87, 87, 87,
+ };
+ register int hval = len;
+
+ switch (hval)
+ {
+ default:
+ case 3:
+ hval += asso_values[str[2]];
+ case 2:
+ case 1:
+ hval += asso_values[str[0]];
+ break;
+ }
+ return hval + asso_values[str[len - 1]];
+}
+
+#ifdef __GNUC__
+inline
+#endif
+struct java_keyword *
+java_keyword (str, len)
+ register char *str;
+ register unsigned int len;
+{
+ static struct java_keyword wordlist[] =
+ {
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"try", TRY_TK},
+ {"else", ELSE_TK},
+ {"short", SHORT_TK},
+ {"goto", GOTO_TK},
+ {"extends", EXTENDS_TK},
+ {"",}, {"",},
+ {"int", INT_TK},
+ {"this", THIS_TK},
+ {"",},
+ {"native", NATIVE_TK},
+ {"",}, {"",},
+ {"interface", INTERFACE_TK},
+ {"import", IMPORT_TK},
+ {"private", PRIVATE_TK},
+ {"volatile", VOLATILE_TK},
+ {"",},
+ {"implements", IMPLEMENTS_TK},
+ {"",},
+ {"long", LONG_TK},
+ {"switch", SWITCH_TK},
+ {"abstract", ABSTRACT_TK},
+ {"transient", TRANSIENT_TK},
+ {"do", DO_TK},
+ {"",},
+ {"throws", THROWS_TK},
+ {"",},
+ {"null", NULL_TK},
+ {"super", SUPER_TK},
+ {"true", TRUE_TK},
+ {"float", FLOAT_TK},
+ {"",},
+ {"return", RETURN_TK},
+ {"if", IF_TK},
+ {"void", VOID_TK},
+ {"protected", PROTECTED_TK},
+ {"byte", BYTE_TK},
+ {"case", CASE_TK},
+ {"break", BREAK_TK},
+ {"finally", FINALLY_TK},
+ {"false", FALSE_TK},
+ {"synchronized", SYNCHRONIZED_TK},
+ {"instanceof", INSTANCEOF_TK},
+ {"while", WHILE_TK},
+ {"package", PACKAGE_TK},
+ {"const", CONST_TK},
+ {"boolean", BOOLEAN_TK},
+ {"final", FINAL_TK},
+ {"continue", CONTINUE_TK},
+ {"catch", CATCH_TK},
+ {"",}, {"",}, {"",}, {"",}, {"",},
+ {"class", CLASS_TK},
+ {"static", STATIC_TK},
+ {"double", DOUBLE_TK},
+ {"default", DEFAULT_TK},
+ {"throw", THROW_TK},
+ {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+ {"",}, {"",}, {"",}, {"",}, {"",},
+ {"for", FOR_TK},
+ {"",},
+ {"new", NEW_TK},
+ {"char", CHAR_TK},
+ {"",},
+ {"public", PUBLIC_TK},
+ };
+
+ 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
+/* Switch definitions for the GNU compiler for the Java(TM) language.
+ Copyright (C) 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* This is the contribution to the `lang_options' array in gcc.c for
+ java. */
+
+DEFINE_LANG_NAME ("Java")
+
+ { "-fbounds-check", "" },
+ { "-fno-bounds-check", "Disable automatic array bounds checking" },
+ { "-fassume-compiled", "Make is_compiled_class return 1"},
+ { "-fno-assume-compiled", "" },
+ { "-femit-class-file", "" },
+ { "-femit-class-files", "Dump class files to <name>.class" },
--- /dev/null
+/* Definitions for specs for the GNU compiler for the Java(TM) language.
+ Copyright (C) 1996 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.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* This is the contribution to the `default_compilers' array in gcc.c for
+ Java. */
+
+ {".java", "@java" },
+ {".class", "@java" },
+ {"@java",
+ "%{!M:%{!MM:%{!E:jc1 %i %1 %2 %{!Q:-quiet} %{d*} %{m*} %{a}\
+ %{g*} %{O*} %{W*} %{w} %{pedantic*} %{ansi}\
+ %{traditional} %{v:-version} %{pg:-p} %{p}\
+ %{f*} %{+e*} %{aux-info*}\
+ %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
+ %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
+ %{!S:as %a %Y\
+ %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}\
+ %{!pipe:%g.s} %A\n }}}}"},
--- /dev/null
+/* Java(TM) language-specific utility routines.
+ Copyright (C) 1996, 1997, 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
+
+#include <stdio.h>
+#include "config.h"
+#include "tree.h"
+#include "input.h"
+#include "java-tree.h"
+#include "jcf.h"
+
+int compiling_from_source;
+
+char *language_string = "GNU Java";
+
+/* Nonzero if we want to automatically do array bounds checking;
+ on by default. Use -fno-bounds-check to disable. */
+
+int flag_bounds_check = 1;
+
+/* Nonzero if we should make is_compiled_class always return 1 for
+ appropriate classes that we're referencing. */
+
+int flag_assume_compiled = 1;
+
+int flag_emit_class_files = 0;
+
+/* From gcc/flags.h, and idicates if exceptions are turned on or not. */
+
+extern int flag_new_exceptions;
+extern int flag_exceptions;
+
+/* 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[] =
+{
+ {"bounds-check", &flag_bounds_check, 1},
+ {"assume-compiled", &flag_assume_compiled, 1},
+ {"emit-class-file", &flag_emit_class_files, 1},
+ {"emit-class-files", &flag_emit_class_files, 1},
+};
+
+JCF main_jcf[1];
+JCF *current_jcf;
+
+/*
+ * process java-specific compiler command-line options
+ */
+int
+lang_decode_option (argc, argv)
+ int argc;
+ char **argv;
+{
+ char *p = argv[0];
+ 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;
+
+ 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;
+ }
+
+ return 0;
+}
+
+FILE *finput;
+char *
+init_parse (filename)
+ char *filename;
+{
+ /* Open input file. */
+
+ if (filename == 0 || !strcmp (filename, "-"))
+ {
+ finput = stdin;
+ filename = "stdin";
+ }
+ else
+ finput = fopen (filename, "r");
+ if (finput == 0)
+ pfatal_with_name (filename);
+
+#ifdef IO_BUFFER_SIZE
+ setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
+#endif
+ init_lex ();
+
+ return filename;
+}
+
+void
+finish_parse ()
+{
+ fclose (finput);
+}
+
+/* Buffer used by lang_printable_name. */
+static char *decl_buf = NULL;
+
+/* Allocated size of decl_buf. */
+static int decl_buflen = 0;
+
+/* Length of used part of decl_buf; position for next character. */
+static int decl_bufpos = 0;
+
+/* Append the string STR to decl_buf.
+ It length is given by LEN; -1 means the string is nul-terminated. */
+
+static void
+put_decl_string (str, len)
+ char *str;
+ int len;
+{
+ if (len < 0)
+ len = strlen (str);
+ if (decl_bufpos + len >= decl_buflen)
+ {
+ if (decl_buf == NULL)
+ {
+ decl_buflen = len + 100;
+ decl_buf = (char *) xmalloc (decl_buflen);
+ }
+ else
+ {
+ decl_buflen *= 2;
+ decl_buf = (char *) xrealloc (decl_buf, decl_buflen);
+ }
+ }
+ strcpy (decl_buf + decl_bufpos, str);
+ decl_bufpos += len;
+}
+
+/* Append to decl_buf a printable name for NODE. */
+
+static void
+put_decl_node (node)
+ tree node;
+{
+ int was_pointer = 0;
+ if (TREE_CODE (node) == POINTER_TYPE)
+ {
+ node = TREE_TYPE (node);
+ was_pointer = 1;
+ }
+ if (TREE_CODE_CLASS (TREE_CODE (node)) == 'd'
+ && DECL_NAME (node) != NULL_TREE)
+ {
+#if 0
+ if (DECL_CONTEXT (node) != NULL_TREE)
+ {
+ put_decl_node (DECL_CONTEXT (node));
+ put_decl_string (".", 1);
+ }
+#endif
+ put_decl_node (DECL_NAME (node));
+ if (TREE_CODE (node) == FUNCTION_DECL && TREE_TYPE (node) != NULL_TREE)
+ {
+ int i = 0;
+ tree args = TYPE_ARG_TYPES (TREE_TYPE (node));
+ if (TREE_CODE (TREE_TYPE (node)) == METHOD_TYPE)
+ args = TREE_CHAIN (args);
+ put_decl_string ("(", 1);
+ for ( ; args != NULL_TREE; args = TREE_CHAIN (args), i++)
+ {
+ if (i > 0)
+ put_decl_string (",", 1);
+ put_decl_node (TREE_VALUE (args));
+ }
+ put_decl_string (")", 1);
+ }
+ }
+ else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't'
+ && TYPE_NAME (node) != NULL_TREE)
+ {
+ if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node))
+ {
+ put_decl_node (TYPE_ARRAY_ELEMENT (node));
+ put_decl_string("[]", 2);
+ }
+ else if (node == promoted_byte_type_node)
+ put_decl_string ("byte", 4);
+ else if (node == promoted_short_type_node)
+ put_decl_string ("short", 5);
+ else if (node == promoted_char_type_node)
+ put_decl_string ("char", 4);
+ else if (node == promoted_boolean_type_node)
+ put_decl_string ("boolean", 7);
+ else if (node == void_type_node && was_pointer)
+ put_decl_string ("null", 4);
+ else
+ put_decl_node (TYPE_NAME (node));
+ }
+ else if (TREE_CODE (node) == IDENTIFIER_NODE)
+ put_decl_string (IDENTIFIER_POINTER (node), IDENTIFIER_LENGTH (node));
+ else
+ put_decl_string ("<unknown>", -1);
+}
+
+/* Return a user-friendly name for DECL.
+ The resulting string is only valid until the next call.
+ The value of the hook decl_printable_name is this function,
+ which is also called directly by lang_print_error. */
+
+char *
+lang_printable_name (decl, v)
+ tree decl;
+ int v;
+{
+ decl_bufpos = 0;
+ put_decl_node (decl);
+ put_decl_string ("", 1);
+ return decl_buf;
+}
+
+/* Print on stderr the current class and method context. This function
+ is the value of the hook print_error_function, called from toplev.c. */
+
+void
+lang_print_error (file)
+ char *file;
+{
+ static tree last_error_function_context = NULL_TREE;
+ static tree last_error_function = NULL;
+
+ if (current_function_decl != NULL
+ && DECL_CONTEXT (current_function_decl) != last_error_function_context)
+ {
+ if (file)
+ fprintf (stderr, "%s: ", file);
+
+ last_error_function_context = DECL_CONTEXT (current_function_decl);
+ fprintf (stderr, "In class `%s':\n",
+ lang_printable_name (last_error_function_context));
+ }
+ if (last_error_function != current_function_decl)
+ {
+ if (file)
+ fprintf (stderr, "%s: ", file);
+
+ if (current_function_decl == NULL)
+ fprintf (stderr, "At top level:\n");
+ else
+ {
+ char *name = lang_printable_name (current_function_decl, 2);
+ fprintf (stderr, "In method `%s':\n", name);
+ }
+
+ last_error_function = current_function_decl;
+ }
+
+}
+
+void
+lang_init ()
+{
+ extern struct rtx_def * java_lang_expand_expr ();
+ extern struct rtx_def * (*lang_expand_expr) ();
+ extern void (*print_error_function) PROTO((char *));
+#if 0
+ extern int flag_minimal_debug;
+ flag_minimal_debug = 0;
+#endif
+
+ decl_printable_name = lang_printable_name;
+ print_error_function = lang_print_error;
+ lang_expand_expr = java_lang_expand_expr;
+
+ JCF_ZERO (main_jcf);
+ main_jcf->read_state = finput;
+ main_jcf->filbuf = jcf_filbuf_from_stdio;
+ current_jcf = main_jcf;
+
+ flag_exceptions = 1;
+}
+
+/* This doesn't do anything on purpose. It's used to satisfy the
+ print_error_function hook we don't print error messages with bogus
+ function prototypes. */
+
+void java_dummy_print (s)
+ char *s;
+{
+}
+
+/* Called to install the PRINT_ERROR_FUNCTION hook differently
+ according to LEVEL. LEVEL is 1 during early parsing, when function
+ prototypes aren't fully resolved. print_error_function is set so it
+ doesn't print incomplete function prototypes. When LEVEL is 2,
+ function prototypes are fully resolved and can be printed when
+ reporting errors. */
+
+void lang_init_source (level)
+ int level;
+{
+ extern void (*print_error_function) PROTO((char *));
+ if (level == 1)
+ print_error_function = java_dummy_print;
+ else
+ print_error_function = lang_print_error;
+}
+
+void
+lang_init_options ()
+{
+ flag_new_exceptions = 1;
+}
+
+void
+lang_finish ()
+{
+}
+
+char*
+lang_identify ()
+{
+ return "Java";
+}
+
+/* Hooks for print_node. */
+
+void
+print_lang_decl (file, node, indent)
+ FILE *file;
+ tree node;
+ int indent;
+{
+}
+
+void
+print_lang_type (file, node, indent)
+ FILE *file;
+ tree node;
+ int indent;
+{
+}
+
+void
+print_lang_identifier (file, node, indent)
+ FILE *file;
+ tree node;
+ int indent;
+{
+}
+
+void
+print_lang_statistics ()
+{
+}
+
+/* used by print-tree.c */
+
+void
+lang_print_xnode (file, node, indent)
+ FILE *file;
+ tree node;
+ int indent;
+{
+}
--- /dev/null
+/* Language lexer for the GNU compiler for the Java(TM) language.
+ Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+ Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* It defines java_lex (yylex) that reads a Java ASCII source file
+possibly containing Unicode escape sequence or utf8 encoded characters
+and returns a token for everything found but comments, white spaces
+and line terminators. When necessary, it also fills the java_lval
+(yylval) union. It's implemented to be called by a re-entrant parser
+generated by Bison.
+
+The lexical analysis conforms to the Java grammar described in "The
+Java(TM) Language Specification. J. Gosling, B. Joy, G. Steele.
+Addison Wesley 1996" (http://java.sun.com/docs/books/jls/html/3.doc.html) */
+
+#include <stdio.h>
+#include <string.h>
+#include <setjmp.h>
+
+#ifdef JAVA_LEX_DEBUG
+#include <ctype.h>
+#endif
+
+#ifdef inline /* javaop.h redefines inline as static */
+#undef inline
+#endif
+#include "keyword.h"
+
+#ifndef SEEK_SET
+#include <unistd.h>
+#endif
+
+void
+java_init_lex ()
+{
+ int java_lang_imported = 0;
+
+#ifndef JC1_LITE
+ if (!java_lang_imported)
+ {
+ tree node = build_tree_list
+ (build_expr_wfl (get_identifier ("java.lang"), NULL, 0, 0), NULL_TREE);
+ read_import_dir (TREE_PURPOSE (node));
+ TREE_CHAIN (node) = ctxp->import_demand_list;
+ ctxp->import_demand_list = node;
+ java_lang_imported = 1;
+ }
+
+ if (!wfl_operator)
+ wfl_operator = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
+ if (!label_id)
+ label_id = get_identifier ("$L");
+
+ ctxp->static_initialized = ctxp->non_static_initialized =
+ ctxp->incomplete_class = NULL_TREE;
+
+ bzero (ctxp->modifier_ctx, 11*sizeof (ctxp->modifier_ctx[0]));
+ classpath = NULL;
+ bzero (current_jcf, sizeof (JCF));
+ ctxp->current_parsed_class = NULL;
+ ctxp->package = NULL_TREE;
+#endif
+
+ ctxp->filename = input_filename;
+ ctxp->lineno = lineno = 0;
+ ctxp->p_line = NULL;
+ ctxp->c_line = NULL;
+ ctxp->unget_utf8_value = 0;
+ ctxp->minus_seen = 0;
+ ctxp->java_error_flag = 0;
+}
+
+static char *
+java_sprint_unicode (line, i)
+ struct java_line *line;
+ int i;
+{
+ static char buffer [10];
+ if (line->unicode_escape_p [i] || line->line [i] > 128)
+ sprintf (buffer, "\\u%04x", line->line [i]);
+ else
+ {
+ buffer [0] = line->line [i];
+ buffer [1] = '\0';
+ }
+ return buffer;
+}
+
+static unicode_t
+java_sneak_unicode ()
+{
+ return (ctxp->c_line->line [ctxp->c_line->current]);
+}
+
+static void
+java_unget_unicode (c)
+ unicode_t c;
+{
+ if (!ctxp->c_line->current)
+ fatal ("can't unget unicode - java_unget_unicode");
+ ctxp->c_line->current--;
+ ctxp->c_line->char_col -= JAVA_COLUMN_DELTA (0);
+}
+
+void
+java_allocate_new_line ()
+{
+ int i;
+ unicode_t ahead = (ctxp->c_line ? ctxp->c_line->ahead[0] : '\0');
+ char ahead_escape_p = (ctxp->c_line ?
+ ctxp->c_line->unicode_escape_ahead_p : 0);
+
+ if (ctxp->c_line && !ctxp->c_line->white_space_only)
+ {
+ if (ctxp->p_line)
+ {
+ free (ctxp->p_line->unicode_escape_p);
+ free (ctxp->p_line->line);
+ free (ctxp->p_line);
+ }
+ ctxp->p_line = ctxp->c_line;
+ ctxp->c_line = NULL; /* Reallocated */
+ }
+
+ if (!ctxp->c_line)
+ {
+ ctxp->c_line = (struct java_line *)malloc (sizeof (struct java_line));
+ ctxp->c_line->max = JAVA_LINE_MAX;
+ ctxp->c_line->line = (unicode_t *)malloc
+ (sizeof (unicode_t)*ctxp->c_line->max);
+ ctxp->c_line->unicode_escape_p =
+ (char *)malloc (sizeof (char)*ctxp->c_line->max);
+ ctxp->c_line->white_space_only = 0;
+ }
+
+ ctxp->c_line->line [0] = ctxp->c_line->size = 0;
+ ctxp->c_line->char_col = ctxp->c_line->current = 0;
+ if (ahead)
+ {
+ ctxp->c_line->line [ctxp->c_line->size] = ahead;
+ ctxp->c_line->unicode_escape_p [ctxp->c_line->size] = ahead_escape_p;
+ ctxp->c_line->size++;
+ }
+ ctxp->c_line->ahead [0] = 0;
+ ctxp->c_line->unicode_escape_ahead_p = 0;
+ ctxp->c_line->lineno = ++lineno;
+ ctxp->c_line->white_space_only = 1;
+}
+
+static unicode_t
+java_read_char ()
+{
+ int c;
+ int c1, c2;
+
+ if (ctxp->unget_utf8_value)
+ {
+ int to_return = ctxp->unget_utf8_value;
+ ctxp->unget_utf8_value = 0;
+ return (to_return);
+ }
+
+ c = GETC ();
+
+ if (c < 128)
+ return (unicode_t)c;
+ if (c == EOF)
+ return UEOF;
+ else
+ {
+ if (c & 0xe0 == 0xc0)
+ {
+ c1 = GETC ();
+ if (c1 & 0xc0 == 0x80)
+ return (unicode_t)(((c &0x1f) << 6) + (c1 & 0x3f));
+ }
+ else if (c & 0xf0 == 0xe0)
+ {
+ c1 = GETC ();
+ if (c1 & 0xc0 == 0x80)
+ {
+ c2 = GETC ();
+ if (c2 & 0xc0 == 0x80)
+ return (unicode_t)(((c & 0xf) << 12) +
+ (( c1 & 0x3f) << 6) + (c2 & 0x3f));
+ }
+ }
+ java_lex_error ("Bad utf8 encoding", 0);
+ }
+}
+
+static void
+java_store_unicode (l, c, unicode_escape_p)
+ struct java_line *l;
+ unicode_t c;
+ int unicode_escape_p;
+{
+ if (l->size == l->max)
+ {
+ l->max += JAVA_LINE_MAX;
+ l->line = (unicode_t *)realloc (l->line, sizeof (unicode_t)*l->max);
+ l->unicode_escape_p = (char *)realloc (l->unicode_escape_p,
+ sizeof (char)*l->max);
+ }
+ l->line [l->size] = c;
+ l->unicode_escape_p [l->size++] = unicode_escape_p;
+}
+
+static unicode_t
+java_read_unicode (term_context, unicode_escape_p)
+ int term_context;
+ int *unicode_escape_p;
+{
+ unicode_t c;
+ long i, base;
+
+ c = java_read_char ();
+ *unicode_escape_p = 0;
+
+ if (c != '\\')
+ return ((term_context ? c :
+ java_lineterminator (c) ? '\n' : (unicode_t)c));
+
+ /* Count the number of preceeding '\' */
+ for (base = ftell (finput), i = base-2; c == '\\';)
+ {
+ fseek (finput, i--, SEEK_SET);
+ c = java_read_char (); /* Will fail if reading utf8 stream. FIXME */
+ }
+ fseek (finput, base, SEEK_SET);
+ if ((base-i-3)%2 == 0) /* If odd number of \ seen */
+ {
+ c = java_read_char ();
+ if (c == 'u')
+ {
+ unsigned short unicode = 0;
+ int shift = 12;
+ /* Next should be 4 hex digits, otherwise it's an error.
+ The hex value is converted into the unicode, pushed into
+ the Unicode stream. */
+ for (shift = 12; shift >= 0; shift -= 4)
+ {
+ if ((c = java_read_char ()) == UEOF)
+ return UEOF;
+ if (c >= '0' && c <= '9')
+ unicode |= (unicode_t)((c-'0') << shift);
+ else if ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
+ unicode |= (unicode_t)(10+(c | 0x20)-'a' << shift);
+ else
+ java_lex_error
+ ("Non hex digit in Unicode escape sequence", 0);
+ }
+ *unicode_escape_p = 1;
+ return (term_context ? unicode :
+ (java_lineterminator (c) ? '\n' : unicode));
+ }
+ UNGETC (c);
+ }
+ return (unicode_t)'\\';
+}
+
+static unicode_t
+java_get_unicode ()
+{
+ /* It's time to read a line when... */
+ if (!ctxp->c_line || ctxp->c_line->current == ctxp->c_line->size)
+ {
+ unicode_t c;
+ java_allocate_new_line ();
+ if (ctxp->c_line->line[0] != '\n')
+ for (;;)
+ {
+ int unicode_escape_p;
+ c = java_read_unicode (0, &unicode_escape_p);
+ java_store_unicode (ctxp->c_line, c, unicode_escape_p);
+ if (ctxp->c_line->white_space_only
+ && !JAVA_WHITE_SPACE_P (c) && c!='\n')
+ ctxp->c_line->white_space_only = 0;
+ if ((c == '\n') || (c == UEOF))
+ break;
+ }
+ }
+ ctxp->c_line->char_col += JAVA_COLUMN_DELTA (0);
+ JAVA_LEX_CHAR (ctxp->c_line->line [ctxp->c_line->current]);
+ return ctxp->c_line->line [ctxp->c_line->current++];
+}
+
+static int
+java_lineterminator (c)
+ unicode_t c;
+{
+ int unicode_escape_p;
+ if (c == '\n') /* CR */
+ {
+ if ((c = java_read_unicode (1, &unicode_escape_p)) != '\r')
+ {
+ ctxp->c_line->ahead [0] = c;
+ ctxp->c_line->unicode_escape_ahead_p = unicode_escape_p;
+ }
+ return 1;
+ }
+ else if (c == '\r') /* LF */
+ {
+ if ((c = java_read_unicode (1, &unicode_escape_p)) != '\n')
+ {
+ ctxp->c_line->ahead [0] = c;
+ ctxp->c_line->unicode_escape_ahead_p = unicode_escape_p;
+ }
+ return 1;
+ }
+ else
+ return 0;
+}
+
+/* Parse the end of a C style comment */
+static void
+java_parse_end_comment ()
+{
+ unicode_t c;
+
+ for (c = java_get_unicode ();; c = java_get_unicode ())
+ {
+ switch (c)
+ {
+ case UEOF:
+ java_lex_error ("Comment not terminated at end of input", 0);
+ case '*':
+ switch (c = java_get_unicode ())
+ {
+ case UEOF:
+ java_lex_error ("Comment not terminated at end of input", 0);
+ case '/':
+ return;
+ case '*': /* reparse only '*' */
+ java_unget_unicode (c);
+ }
+ }
+ }
+}
+
+/* This function to be used only by JAVA_ID_CHAR_P (), otherwise it
+ will return a wrong result. */
+static int
+java_letter_or_digit_p (c)
+ unicode_t c;
+{
+ return _JAVA_LETTER_OR_DIGIT_P (c);
+}
+
+static unicode_t
+java_parse_escape_sequence ()
+{
+ unicode_t char_lit;
+ unicode_t c;
+
+ switch (c = java_get_unicode ())
+ {
+ case 'b':
+ return (unicode_t)0x8;
+ case 't':
+ return (unicode_t)0x9;
+ case 'n':
+ return (unicode_t)0xa;
+ case 'f':
+ return (unicode_t)0xc;
+ case 'r':
+ return (unicode_t)0xd;
+ case '"':
+ return (unicode_t)0x22;
+ case '\'':
+ return (unicode_t)0x27;
+ case '\\':
+ return (unicode_t)0x5c;
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ {
+ int octal_escape[3];
+ int octal_escape_index = 0;
+
+ for (; octal_escape_index < 3 && RANGE (c, '0', '9');
+ c = java_get_unicode ())
+ octal_escape [octal_escape_index++] = c;
+
+ java_unget_unicode (c);
+
+ if ((octal_escape_index == 3) && (octal_escape [0] > '3'))
+ {
+ java_lex_error ("Literal octal escape out of range", 0);
+ return JAVA_CHAR_ERROR;
+ }
+ else
+ {
+ int i, shift;
+ for (char_lit=0, i = 0, shift = 3*(octal_escape_index-1);
+ i < octal_escape_index; i++, shift -= 3)
+ char_lit |= (octal_escape [i] - '0') << shift;
+
+ return (char_lit);
+ }
+ break;
+ }
+ case '\n':
+ return '\n'; /* ULT, caught latter as a specific error */
+ default:
+ java_lex_error ("Illegal character in escape sequence", 0);
+ return JAVA_CHAR_ERROR;
+ }
+}
+
+int
+#ifdef JC1_LITE
+yylex (java_lval)
+#else
+java_lex (java_lval)
+#endif
+ YYSTYPE *java_lval;
+{
+ unicode_t c, first_unicode;
+ int line_terminator;
+ int ascii_index, all_ascii;
+ char *string;
+
+ /* Translation of the Unicode escape in the raw stream of Unicode
+ characters. Takes care of line terminator. */
+ step1:
+ /* Skip white spaces: SP, TAB and FF or ULT */
+ for (c = java_get_unicode ();
+ c == '\n' || JAVA_WHITE_SPACE_P (c); c = java_get_unicode ())
+ if (c == '\n')
+ {
+ ctxp->elc.line = ctxp->c_line->lineno;
+ ctxp->elc.col = ctxp->c_line->char_col-2;
+ }
+
+ ctxp->elc.col = (ctxp->elc.col < 0 ? 0 : ctxp->elc.col);
+
+ if (c == 0x1a) /* CTRL-Z */
+ {
+ if ((c = java_get_unicode ()) == UEOF)
+ return 0; /* Ok here */
+ else
+ java_unget_unicode (c); /* Caught latter at the end the function */
+ }
+ /* Handle EOF here */
+ if (c == UEOF) /* Should probably do something here... */
+ return 0;
+
+ /* Take care of eventual comments. */
+ if (c == '/')
+ {
+ switch (c = java_get_unicode ())
+ {
+ case '/':
+ for (c = java_get_unicode ();;c = java_get_unicode ())
+ {
+ if (c == UEOF)
+ java_lex_error ("Comment not terminated at end of input", 0);
+ if (c == '\n') /* ULT */
+ goto step1;
+ }
+ break;
+
+ case '*':
+ if ((c = java_get_unicode ()) == '*')
+ {
+ if ((c = java_get_unicode ()) == '/')
+ goto step1; /* Empy documentation comment */
+
+ else
+ /* Parsing the documentation section. We're looking
+ for the @depracated pseudo keyword. the @deprecated
+ tag must be at the beginning of a doc comment line
+ (ignoring white space and any * character) */
+
+ {
+ int valid_tag = 0, seen_star;
+
+ while (JAVA_WHITE_SPACE_P (c) || (c == '*') || c == '\n')
+ {
+ switch (c)
+ {
+ case '*':
+ seen_star = 1;
+ break;
+ case '\n': /* ULT */
+ valid_tag = 1;
+ break;
+ default:
+ seen_star = 0;
+ }
+ c = java_get_unicode();
+ }
+
+ if (c == UEOF)
+ java_lex_error
+ ("Comment not terminated at end of input", 0);
+
+ if (seen_star && (c == '/'))
+ goto step1; /* End of documentation */
+
+ if (valid_tag && (c == '@'))
+ {
+ char deprecated [10];
+ int deprecated_index = 0;
+
+ for (deprecated_index = 0, c = java_get_unicode ();
+ deprecated_index < 10 && c != UEOF;
+ c = java_get_unicode ())
+ deprecated [deprecated_index++] = c;
+
+ if (c == UEOF)
+ java_lex_error
+ ("Comment not terminated at end of input", 0);
+
+ java_unget_unicode (c);
+ deprecated [deprecated_index] = '\0';
+ if (!strcmp (deprecated, "deprecated"))
+ {
+ /* Set global flag to be checked by class. FIXME */
+ warning ("deprecated implementation found");
+ }
+ }
+ }
+ }
+ else
+ java_unget_unicode (c);
+
+ java_parse_end_comment ();
+ goto step1;
+ break;
+ default:
+ java_unget_unicode (c);
+ c = '/';
+ break;
+ }
+ }
+
+ ctxp->elc.line = ctxp->c_line->lineno;
+ ctxp->elc.col = ctxp->c_line->char_col - JAVA_COLUMN_DELTA (-1);
+ if (ctxp->elc.col < 0)
+ fatal ("ctxp->elc.col < 0 - java_lex");
+
+ /* Numeric literals */
+ if (JAVA_ASCII_DIGIT (c) || (c == '.'))
+ {
+ unicode_t peep;
+ /* This section of code is borrowed from gcc/c-lex.c */
+#define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
+ int parts[TOTAL_PARTS];
+ HOST_WIDE_INT high, low;
+ /* End borrowed section */
+ char literal_token [256];
+ int literal_index = 0, radix = 10, long_suffix = 0, overflow = 0, bytes;
+ int i;
+ int number_beginning = ctxp->c_line->current;
+
+ /* We might have a . separator instead of a FP like .[0-9]* */
+ if (c == '.')
+ {
+ unicode_t peep = java_sneak_unicode ();
+
+ if (!JAVA_ASCII_DIGIT (peep))
+ {
+ JAVA_LEX_SEP('.');
+ BUILD_OPERATOR (DOT_TK);
+ }
+ }
+
+ for (i = 0; i < TOTAL_PARTS; i++)
+ parts [i] = 0;
+
+ if (c == '0')
+ {
+ c = java_get_unicode ();
+ if (c == 'x' || c == 'X')
+ {
+ radix = 16;
+ c = java_get_unicode ();
+ }
+ else if (JAVA_ASCII_DIGIT (c))
+ radix = 8;
+ else if (c == '.')
+ {
+ /* Push the '.' back and prepare for a FP parsing... */
+ java_unget_unicode (c);
+ c = '0';
+ }
+ else
+ {
+ /* We have a zero literal: 0, 0{f,F}, 0{d,D} */
+ JAVA_LEX_LIT ("0", 10);
+ switch (c)
+ {
+ case 'L': case 'l':
+ SET_LVAL_NODE_TYPE (integer_zero_node, long_type_node);
+ return (INT_LIT_TK);
+ case 'f': case 'F':
+ SET_LVAL_NODE_TYPE (build_real (float_type_node, dconst0),
+ float_type_node);
+ return (FP_LIT_TK);
+ case 'd': case 'D':
+ SET_LVAL_NODE_TYPE (build_real (double_type_node, dconst0),
+ double_type_node);
+ return (FP_LIT_TK);
+ default:
+ java_unget_unicode (c);
+ SET_LVAL_NODE_TYPE (integer_zero_node, int_type_node);
+ return (INT_LIT_TK);
+ }
+ }
+ }
+ /* Parse the first part of the literal, until we find something
+ which is not a number. */
+ while ((radix == 10 && JAVA_ASCII_DIGIT (c)) ||
+ (radix == 16 && JAVA_ASCII_HEXDIGIT (c)) ||
+ (radix == 8 && JAVA_ASCII_OCTDIGIT (c)))
+ {
+ /* We store in a string (in case it turns out to be a FP) and in
+ PARTS if we have to process a integer literal. */
+ int numeric = (RANGE (c, '0', '9') ? c-'0' : 10 +(c|0x20)-'a');
+ int count;
+
+ literal_token [literal_index++] = c;
+ /* This section of code if borrowed from gcc/c-lex.c */
+ for (count = 0; count < TOTAL_PARTS; count++)
+ {
+ parts[count] *= radix;
+ if (count)
+ {
+ parts[count] += (parts[count-1] >> HOST_BITS_PER_CHAR);
+ parts[count-1] &= (1 << HOST_BITS_PER_CHAR) - 1;
+ }
+ else
+ parts[0] += numeric;
+ }
+ if (parts [TOTAL_PARTS-1] != 0)
+ overflow = 1;
+ /* End borrowed section. */
+ c = java_get_unicode ();
+ }
+
+ /* If we have something from the FP char set but not a digit, parse
+ a FP literal. */
+ if (JAVA_ASCII_FPCHAR (c) && !JAVA_ASCII_DIGIT (c))
+ {
+ int stage = 0;
+ int seen_digit = (literal_index ? 1 : 0);
+ int seen_exponent = 0;
+ int fflag = 0; /* 1 for {f,F}, 0 for {d,D}. FP literal are
+ double unless specified. */
+ if (radix != 10)
+ java_lex_error ("Can't express non-decimal FP literal", 0);
+
+ for (;;)
+ {
+ if (c == '.')
+ {
+ if (stage < 1)
+ {
+ stage = 1;
+ literal_token [literal_index++ ] = c;
+ c = java_get_unicode ();
+ }
+ else
+ java_lex_error ("Invalid character in FP literal", 0);
+ }
+
+ if (c == 'e' || c == 'E')
+ {
+ if (stage < 2)
+ {
+ /* {E,e} must have seen at list a digit */
+ if (!seen_digit)
+ java_lex_error ("Invalid FP literal", 0);
+ seen_digit = 0;
+ seen_exponent = 1;
+ stage = 2;
+ literal_token [literal_index++] = c;
+ c = java_get_unicode ();
+ }
+ else
+ java_lex_error ("Invalid character in FP literal", 0);
+ }
+ if ( c == 'f' || c == 'F' || c == 'd' || c == 'D')
+ {
+ fflag = ((c == 'd') || (c == 'D')) ? 0 : 1;
+ stage = 4; /* So we fall through */
+ }
+
+ if ((c=='-' || c =='+') && stage < 3)
+ {
+ stage = 3;
+ literal_token [literal_index++] = c;
+ c = java_get_unicode ();
+ }
+
+ if ((stage == 0 && JAVA_ASCII_FPCHAR (c)) ||
+ (stage == 1 && JAVA_ASCII_FPCHAR (c) && !(c == '.')) ||
+ (stage == 2 && (JAVA_ASCII_DIGIT (c) || JAVA_FP_PM (c))) ||
+ (stage == 3 && JAVA_ASCII_DIGIT (c)))
+ {
+ if (JAVA_ASCII_DIGIT (c))
+ seen_digit = 1;
+ literal_token [literal_index++ ] = c;
+ c = java_get_unicode ();
+ }
+ else
+ {
+ jmp_buf handler;
+ REAL_VALUE_TYPE value;
+#ifndef JC1_LITE
+ tree type = (fflag ? FLOAT_TYPE_NODE : DOUBLE_TYPE_NODE);
+#endif
+
+ if (stage != 4) /* Don't push back fF/dD */
+ java_unget_unicode (c);
+
+ /* An exponent (if any) must have seen a digit. */
+ if (seen_exponent && !seen_digit)
+ java_lex_error ("Invalid FP literal", 0);
+
+ literal_token [literal_index] = '\0';
+ JAVA_LEX_LIT (literal_token, radix);
+
+ if (setjmp (handler))
+ {
+ JAVA_FLOAT_RANGE_ERROR ((fflag ? "float" : "double"));
+ value = DCONST0;
+ }
+ else
+ {
+ SET_FLOAT_HANDLER (handler);
+ SET_REAL_VALUE_ATOF
+ (value, REAL_VALUE_ATOF (literal_token,
+ TYPE_MODE (type)));
+
+ if (REAL_VALUE_ISINF (value))
+ JAVA_FLOAT_RANGE_ERROR ((fflag ? "float" : "double"));
+
+ if (REAL_VALUE_ISNAN (value))
+ JAVA_FLOAT_RANGE_ERROR ((fflag ? "float" : "double"));
+
+ SET_LVAL_NODE_TYPE (build_real (type, value), type);
+ SET_FLOAT_HANDLER (NULL_PTR);
+ return FP_LIT_TK;
+ }
+ }
+ }
+ } /* JAVA_ASCCI_FPCHAR (c) */
+
+ /* Here we get back to converting the integral literal. */
+ if (c == 'L' || c == 'l')
+ long_suffix = 1;
+ else if (radix == 16 && JAVA_ASCII_LETTER (c))
+ java_lex_error ("Digit out of range in hexadecimal literal", 0);
+ else if (radix == 8 && JAVA_ASCII_DIGIT (c))
+ java_lex_error ("Digit out of range in octal literal", 0);
+ else if (radix == 16 && !literal_index)
+ java_lex_error ("No digit specified for hexadecimal literal", 0);
+ else
+ java_unget_unicode (c);
+
+#ifdef JAVA_LEX_DEBUG
+ literal_token [literal_index] = '\0'; /* So JAVA_LEX_LIT is safe. */
+ JAVA_LEX_LIT (literal_token, radix);
+#endif
+ /* This section of code is borrowed from gcc/c-lex.c */
+ if (!overflow)
+ {
+ bytes = GET_TYPE_PRECISION (long_type_node);
+ for (i = bytes; i < TOTAL_PARTS; i++)
+ if (parts [i])
+ {
+ overflow = 1;
+ break;
+ }
+ }
+ 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);
+ }
+ /* End borrowed section. */
+
+ /* Range checking */
+ if (long_suffix)
+ {
+ /* 9223372036854775808L is valid if operand of a '-'. Otherwise
+ 9223372036854775807L is the biggest `long' literal that can be
+ expressed using a 10 radix. For other radixes, everything that
+ fits withing 64 bits is OK. */
+ int hb = (high >> 31);
+ if (overflow || (hb && low && radix == 10) ||
+ (hb && high & 0x7fffffff && radix == 10) ||
+ (hb && !(high & 0x7fffffff) && !ctxp->minus_seen && radix == 10))
+ JAVA_INTEGRAL_RANGE_ERROR ("Numeric overflow for `long' literal");
+ }
+ else
+ {
+ /* 2147483648 is valid if operand of a '-'. Otherwise,
+ 2147483647 is the biggest `int' literal that can be
+ expressed using a 10 radix. For other radixes, everything
+ that fits within 32 bits is OK. */
+ int hb = (low >> 31) & 0x1;
+ if (overflow || high || (hb && low & 0x7fffffff && radix == 10) ||
+ (hb && !(low & 0x7fffffff) && !ctxp->minus_seen && radix == 10))
+ JAVA_INTEGRAL_RANGE_ERROR ("Numeric overflow for `int' literal");
+ }
+ ctxp->minus_seen = 0;
+ SET_LVAL_NODE_TYPE (build_int_2 (low, high),
+ (long_suffix ? long_type_node : int_type_node));
+ return INT_LIT_TK;
+ }
+
+ ctxp->minus_seen = 0;
+ /* Character literals */
+ if (c == '\'')
+ {
+ unicode_t char_lit;
+ if ((c = java_get_unicode ()) == '\\')
+ char_lit = java_parse_escape_sequence ();
+ else
+ char_lit = c;
+
+ c = java_get_unicode ();
+
+ if ((c == '\n') || (c == UEOF))
+ java_lex_error ("Character literal not terminated at end of line", 0);
+ if (c != '\'')
+ java_lex_error ("Syntax error in character literal", 0);
+
+ if (c == JAVA_CHAR_ERROR)
+ char_lit = 0; /* We silently convert it to zero */
+
+ JAVA_LEX_CHAR_LIT (char_lit);
+ SET_LVAL_NODE_TYPE (build_int_2 (char_lit, 0), char_type_node);
+ return CHAR_LIT_TK;
+ }
+
+ /* String literals */
+ if (c == '"')
+ {
+ int no_error;
+ char *string;
+
+ for (no_error = 1, c = java_get_unicode ();
+ c != '"' && c != '\n'; c = java_get_unicode ())
+ {
+ if (c == '\\')
+ c = java_parse_escape_sequence ();
+ no_error &= (c != JAVA_CHAR_ERROR ? 1 : 0);
+ if (c)
+ java_unicode_2_utf8 (c);
+ }
+ if (c == '\n' || c == UEOF) /* ULT */
+ {
+ lineno--; /* Refer to the line the terminator was seen */
+ java_lex_error ("String not terminated at end of line.", 0);
+ lineno++;
+ }
+
+ obstack_1grow (&temporary_obstack, '\0');
+ string = obstack_finish (&temporary_obstack);
+ if (!no_error || (c != '"'))
+ *string = '\0'; /* Silently turns the string to an empty one */
+
+ JAVA_LEX_STR_LIT (string)
+
+#ifndef JC1_LITE
+ if (*string)
+ {
+ extern struct obstack *expression_obstack;
+ tree s = make_node (STRING_CST);
+ TREE_STRING_LENGTH (s) = strlen (string);
+ TREE_STRING_POINTER (s) =
+ obstack_alloc (expression_obstack, strlen (string));
+ strcpy (TREE_STRING_POINTER (s), string);
+ java_lval->node = s;
+ }
+ else
+ java_lval->node = error_mark_node;
+#endif
+ return STRING_LIT_TK;
+
+ }
+
+ /* Separator */
+ switch (c)
+ {
+ case '(':
+ JAVA_LEX_SEP (c);
+ BUILD_OPERATOR (OP_TK);
+ case ')':
+ JAVA_LEX_SEP (c);
+ return CP_TK;
+ case '{':
+ JAVA_LEX_SEP (c);
+ if (ctxp->ccb_indent == 1)
+ ctxp->first_ccb_indent1 = lineno;
+ ctxp->ccb_indent++;
+ return OCB_TK;
+ case '}':
+ JAVA_LEX_SEP (c);
+ ctxp->ccb_indent--;
+ if (ctxp->ccb_indent == 1)
+ ctxp->last_ccb_indent1 = lineno;
+ return CCB_TK;
+ case '[':
+ JAVA_LEX_SEP (c);
+ BUILD_OPERATOR (OSB_TK);
+ case ']':
+ JAVA_LEX_SEP (c);
+ return CSB_TK;
+ case ';':
+ JAVA_LEX_SEP (c);
+ return SC_TK;
+ case ',':
+ JAVA_LEX_SEP (c);
+ return C_TK;
+ case '.':
+ JAVA_LEX_SEP (c);
+ BUILD_OPERATOR (DOT_TK);
+ /* return DOT_TK; */
+ }
+
+ /* Operators */
+ switch (c)
+ {
+ case '=':
+ if ((c = java_get_unicode ()) == '=')
+ {
+ BUILD_OPERATOR (EQ_TK);
+ }
+ else
+ {
+ /* Equals is used in two different locations. In the
+ variable_declarator: rule, it has to be seen as '=' as opposed
+ to being seen as an ordinary assignment operator in
+ assignment_operators: rule. */
+ java_unget_unicode (c);
+ BUILD_OPERATOR (ASSIGN_TK);
+ }
+
+ case '>':
+ switch ((c = java_get_unicode ()))
+ {
+ case '=':
+ BUILD_OPERATOR (GTE_TK);
+ case '>':
+ switch ((c = java_get_unicode ()))
+ {
+ case '>':
+ if ((c = java_get_unicode ()) == '=')
+ {
+ BUILD_OPERATOR2 (ZRS_ASSIGN_TK);
+ }
+ else
+ {
+ java_unget_unicode (c);
+ BUILD_OPERATOR (ZRS_TK);
+ }
+ case '=':
+ BUILD_OPERATOR2 (SRS_ASSIGN_TK);
+ default:
+ java_unget_unicode (c);
+ BUILD_OPERATOR (SRS_TK);
+ }
+ default:
+ java_unget_unicode (c);
+ BUILD_OPERATOR (GT_TK);
+ }
+
+ case '<':
+ switch ((c = java_get_unicode ()))
+ {
+ case '=':
+ BUILD_OPERATOR (LTE_TK);
+ case '<':
+ if ((c = java_get_unicode ()) == '=')
+ {
+ BUILD_OPERATOR2 (LS_ASSIGN_TK);
+ }
+ else
+ {
+ java_unget_unicode (c);
+ BUILD_OPERATOR (LS_TK);
+ }
+ default:
+ java_unget_unicode (c);
+ BUILD_OPERATOR (LT_TK);
+ }
+
+ case '&':
+ switch ((c = java_get_unicode ()))
+ {
+ case '&':
+ BUILD_OPERATOR (BOOL_AND_TK);
+ case '=':
+ BUILD_OPERATOR2 (AND_ASSIGN_TK);
+ default:
+ java_unget_unicode (c);
+ BUILD_OPERATOR (AND_TK);
+ }
+
+ case '|':
+ switch ((c = java_get_unicode ()))
+ {
+ case '|':
+ BUILD_OPERATOR (BOOL_OR_TK);
+ case '=':
+ BUILD_OPERATOR2 (OR_ASSIGN_TK);
+ default:
+ java_unget_unicode (c);
+ BUILD_OPERATOR (OR_TK);
+ }
+
+ case '+':
+ switch ((c = java_get_unicode ()))
+ {
+ case '+':
+ BUILD_OPERATOR (INCR_TK);
+ case '=':
+ BUILD_OPERATOR2 (PLUS_ASSIGN_TK);
+ default:
+ java_unget_unicode (c);
+ BUILD_OPERATOR (PLUS_TK);
+ }
+
+ case '-':
+ switch ((c = java_get_unicode ()))
+ {
+ case '-':
+ BUILD_OPERATOR (DECR_TK);
+ case '=':
+ BUILD_OPERATOR2 (MINUS_ASSIGN_TK);
+ default:
+ java_unget_unicode (c);
+ ctxp->minus_seen = 1;
+ BUILD_OPERATOR (MINUS_TK);
+ }
+
+ case '*':
+ if ((c = java_get_unicode ()) == '=')
+ {
+ BUILD_OPERATOR2 (MULT_ASSIGN_TK);
+ }
+ else
+ {
+ java_unget_unicode (c);
+ BUILD_OPERATOR (MULT_TK);
+ }
+
+ case '/':
+ if ((c = java_get_unicode ()) == '=')
+ {
+ BUILD_OPERATOR2 (DIV_ASSIGN_TK);
+ }
+ else
+ {
+ java_unget_unicode (c);
+ BUILD_OPERATOR (DIV_TK);
+ }
+
+ case '^':
+ if ((c = java_get_unicode ()) == '=')
+ {
+ BUILD_OPERATOR2 (XOR_ASSIGN_TK);
+ }
+ else
+ {
+ java_unget_unicode (c);
+ BUILD_OPERATOR (XOR_TK);
+ }
+
+ case '%':
+ if ((c = java_get_unicode ()) == '=')
+ {
+ BUILD_OPERATOR2 (REM_ASSIGN_TK);
+ }
+ else
+ {
+ java_unget_unicode (c);
+ BUILD_OPERATOR (REM_TK);
+ }
+
+ case '!':
+ if ((c = java_get_unicode()) == '=')
+ {
+ BUILD_OPERATOR (NEQ_TK);
+ }
+ else
+ {
+ java_unget_unicode (c);
+ BUILD_OPERATOR (NEG_TK);
+ }
+
+ case '?':
+ JAVA_LEX_OP ("?");
+ BUILD_OPERATOR (REL_QM_TK);
+ case ':':
+ JAVA_LEX_OP (":");
+ BUILD_OPERATOR (REL_CL_TK);
+ case '~':
+ BUILD_OPERATOR (NOT_TK);
+ }
+
+ /* Keyword, boolean literal or null literal */
+ for (first_unicode = c, all_ascii = 1, ascii_index = 0;
+ JAVA_ID_CHAR_P (c); c = java_get_unicode ())
+ {
+ java_unicode_2_utf8 (c);
+ if (all_ascii && c >= 128)
+ all_ascii = 0;
+ ascii_index++;
+ }
+
+ obstack_1grow (&temporary_obstack, '\0');
+ string = obstack_finish (&temporary_obstack);
+ java_unget_unicode (c);
+
+ /* If we have something all ascii, we consider a keyword, a boolean
+ literal, a null literal or an all ASCII identifier. Otherwise,
+ this is an identifier (possibly not respecting formation rule). */
+ if (all_ascii)
+ {
+ struct java_keyword *kw;
+ if ((kw=java_keyword (string, ascii_index)))
+ {
+ JAVA_LEX_KW (string);
+ switch (kw->token)
+ {
+ case PUBLIC_TK: case PROTECTED_TK: case STATIC_TK:
+ case ABSTRACT_TK: case FINAL_TK: case NATIVE_TK:
+ case SYNCHRONIZED_TK: case TRANSIENT_TK: case VOLATILE_TK:
+ case PRIVATE_TK:
+ SET_MODIFIER_CTX (kw->token);
+ return MODIFIER_TK;
+ case FLOAT_TK:
+ SET_LVAL_NODE (float_type_node);
+ return FP_TK;
+ case DOUBLE_TK:
+ SET_LVAL_NODE (double_type_node);
+ return FP_TK;
+ case BOOLEAN_TK:
+ SET_LVAL_NODE (boolean_type_node);
+ return BOOLEAN_TK;
+ case BYTE_TK:
+ SET_LVAL_NODE (byte_type_node);
+ return INTEGRAL_TK;
+ case SHORT_TK:
+ SET_LVAL_NODE (short_type_node);
+ return INTEGRAL_TK;
+ case INT_TK:
+ SET_LVAL_NODE (int_type_node);
+ return INTEGRAL_TK;
+ case LONG_TK:
+ SET_LVAL_NODE (long_type_node);
+ return INTEGRAL_TK;
+ case CHAR_TK:
+ SET_LVAL_NODE (char_type_node);
+ return INTEGRAL_TK;
+
+ /* Keyword based literals */
+ case TRUE_TK:
+ case FALSE_TK:
+ SET_LVAL_NODE ((kw->token == TRUE_TK ?
+ boolean_true_node : boolean_false_node));
+ return BOOL_LIT_TK;
+ case NULL_TK:
+ SET_LVAL_NODE (null_pointer_node);
+ return NULL_TK;
+
+ /* We build an operator for SUPER, so we can keep its position */
+ case SUPER_TK:
+ case THIS_TK:
+ case RETURN_TK:
+ case BREAK_TK:
+ case CONTINUE_TK:
+ BUILD_OPERATOR (kw->token);
+
+ default:
+ return kw->token;
+ }
+ }
+ }
+
+ /* We may have and ID here */
+ if (JAVA_ID_CHAR_P(first_unicode) && !JAVA_DIGIT_P (first_unicode))
+ {
+ JAVA_LEX_ID (string);
+ java_lval->node = BUILD_ID_WFL (GET_IDENTIFIER (string));
+ return ID_TK;
+ }
+
+ /* Everything else is an invalid character in the input */
+ {
+ char lex_error_buffer [128];
+ sprintf (lex_error_buffer, "Invalid character '%s' in input",
+ java_sprint_unicode (ctxp->c_line, ctxp->c_line->current));
+ java_lex_error (lex_error_buffer, 1);
+ }
+ return 0;
+}
+
+static void
+java_unicode_2_utf8 (unicode)
+ unicode_t unicode;
+{
+ if (RANGE (unicode, 0x01, 0x7f))
+ obstack_1grow (&temporary_obstack, (char)unicode);
+ else if (RANGE (unicode, 0x80, 0x7ff) || unicode == 0)
+ {
+ obstack_1grow (&temporary_obstack,
+ (unsigned char)(0xc0 | ((0x7c0 & unicode) >> 6)));
+ obstack_1grow (&temporary_obstack,
+ (unsigned char)(0x80 | (unicode & 0x3f)));
+ }
+ else /* Range 0x800-0xffff */
+ {
+ obstack_1grow (&temporary_obstack,
+ (unsigned char)(0xe0 | (unicode & 0xf000) >> 12));
+ obstack_1grow (&temporary_obstack,
+ (unsigned char)(0x80 | (unicode & 0x0fc0) >> 6));
+ obstack_1grow (&temporary_obstack,
+ (unsigned char)(0x80 | (unicode & 0x003f) >> 12));
+ }
+}
+
+#ifndef JC1_LITE
+static tree
+build_wfl_node (node)
+ tree node;
+{
+ return build_expr_wfl (node, ctxp->filename, ctxp->elc.line, ctxp->elc.col);
+}
+#endif
+
+static void
+java_lex_error (msg, forward)
+ char *msg;
+ int forward;
+{
+#ifndef JC1_LITE
+ ctxp->elc.line = ctxp->c_line->lineno;
+ ctxp->elc.col = ctxp->c_line->char_col-1+forward;
+
+ /* Might be caught in the middle of some error report */
+ ctxp->java_error_flag = 0;
+ java_error (NULL);
+ java_error (msg);
+#endif
+}
+
+static int
+java_is_eol (fp, c)
+ FILE *fp;
+ int c;
+{
+ int next;
+ switch (c)
+ {
+ case '\n':
+ next = getc (fp);
+ if (next != '\r' && next != EOF)
+ ungetc (next, fp);
+ return 1;
+ case '\r':
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+char *
+java_get_line_col (filename, line, col)
+ char *filename;
+ int line, col;
+{
+#ifdef JC1_LITE
+ return 0;
+#else
+ /* Dumb implementation. Doesn't try to cache or optimize things. */
+ /* First line of the file is line 1, first column is 1 */
+
+ /* COL <= 0 means, at the CR/LF in LINE */
+
+ FILE *fp;
+ int c, ccol, cline = 1;
+ int current_line_col = 0;
+
+ if (!(fp = fopen (filename, "r")))
+ fatal ("Can't open file - java_display_line_col");
+
+ while (cline != line)
+ {
+ c = getc (fp);
+ if (c < 0)
+ {
+ static char msg[] = "<<file too short - unexpected EOF>>";
+ obstack_grow (&temporary_obstack, msg, sizeof(msg)-1);
+ goto have_line;
+ }
+ if (java_is_eol (fp, c))
+ cline++;
+ }
+
+ /* Gather the chars of the current line in a buffer */
+ for (;;)
+ {
+ c = getc (fp);
+ if (c < 0 || java_is_eol (fp, c))
+ break;
+ obstack_1grow (&temporary_obstack, c);
+ current_line_col++;
+ }
+ have_line:
+
+ obstack_1grow (&temporary_obstack, '\n');
+
+ if (col < 0)
+ col = current_line_col;
+
+ /* Place the '^' a the right position */
+ for (ccol = 1; ccol <= col; ccol++)
+ obstack_1grow (&temporary_obstack, ' ');
+ obstack_grow0 (&temporary_obstack, "^", 1);
+
+ fclose (fp);
+ return obstack_finish (&temporary_obstack);
+#endif
+}
--- /dev/null
+/* Language lexer definitions for the GNU compiler for the Java(TM) language.
+ Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+ Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+#ifndef JV_LEX_H
+#define JV_LEX_H
+
+/* Extern global variables declarations */
+extern FILE *finput;
+extern int lineno;
+extern char *classpath;
+
+/* A Unicode character, as read from the input file */
+typedef unsigned short unicode_t;
+
+/* Function declaration */
+static int java_lineterminator ();
+static char *java_sprint_unicode ();
+static void java_unicode_2_utf8 ();
+static void java_lex_error ();
+static void java_store_unicode ();
+
+/* Debug macro to print-out what we match */
+#ifdef JAVA_LEX_DEBUG
+#ifdef JAVA_LEX_DEBUG_CHAR
+#define JAVA_LEX_CHAR(c) printf ("java_lex:%d: char '%c'.%d\n", \
+ lineno, (c < 128 ? c : '.'), c);
+#else
+#define JAVA_LEX_CHAR(c)
+#endif
+#define JAVA_LEX_KW(c) printf ("java_lex:%d: keyword: '%s'\n", lineno,c)
+#define JAVA_LEX_ID(s) printf ("java_lex:%d: ID: '%s'\n", \
+ lineno, \
+ (all_ascii ? s : "<U>"))
+#define JAVA_LEX_LIT(s, r) printf ("java_lex:%d: literal '%s'_%d\n", \
+ lineno, s, r)
+#define JAVA_LEX_CHAR_LIT(s) printf ("java_lex:%d: literal '%d'\n", lineno, s)
+#define JAVA_LEX_STR_LIT(s) { \
+ int i; \
+ printf ("java_lex:%d: literal '%s'\n", \
+ lineno, s); \
+ }
+#define JAVA_LEX_SEP(c) printf ("java_lex:%d: separator '%c'\n",lineno,c)
+#define JAVA_LEX_OP(c) printf ("java_lex:%d: operator '%s'\n", lineno,c)
+#else
+#define JAVA_LEX_CHAR(c)
+#define JAVA_LEX_KW(c)
+#define JAVA_LEX_ID(s)
+#define JAVA_LEX_LIT(s,r)
+#define JAVA_LEX_CHAR_LIT(s)
+#define JAVA_LEX_STR_LIT(s)
+#define JAVA_LEX_SEP(c)
+#define JAVA_LEX_OP(s)
+#endif
+
+/* Line information containers */
+struct java_line {
+ unicode_t *line; /* The line's unicode */
+ char *unicode_escape_p; /* The maching char was a unicode escape */
+ unicode_t ahead[1]; /* Character ahead */
+ char unicode_escape_ahead_p; /* Character ahead is a unicode escape */
+ int max; /* buffer's max size */
+ int size; /* number of unicodes */
+ int current; /* Current position, unicode based */
+ int char_col; /* Current position, input char based */
+ int lineno; /* Its line number */
+ int white_space_only; /* If it contains only white spaces */
+};
+#define JAVA_COLUMN_DELTA(p) \
+ (ctxp->c_line->unicode_escape_p [ctxp->c_line->current+(p)] ? 6 : \
+ (ctxp->c_line->line [ctxp->c_line->current+(p)] == '\t' ? 8 : 1))
+
+struct java_error {
+ struct java_line *line;
+ int error;
+};
+
+typedef struct _java_lc {
+ int line;
+ int col;
+} java_lc;
+
+
+#define JAVA_LINE_MAX 80
+
+/* Macro to read and unread chars */
+#define UNGETC(c) ctxp->unget_utf8_value = (c);
+#define GETC() getc(finput)
+
+/* Build a location compound integer */
+#define BUILD_LOCATION() ((ctxp->elc.line << 12) | (ctxp->elc.col & 0xfff))
+
+/* Those macros are defined differently if we compile jc1-lite
+ (JC1_LITE defined) or jc1. */
+#ifdef JC1_LITE
+
+#define DCONST0 0
+#define HOST_WIDE_INT long
+#define HOST_BITS_PER_WIDE_INT 64
+#define HOST_BITS_PER_CHAR 8
+#define REAL_VALUE_TYPE int
+#define SET_FLOAT_HANDLER(H)
+#define GET_IDENTIFIER(S) xstrdup ((S))
+#define REAL_VALUE_ATOF(LIT,MODE) 0
+#define REAL_VALUE_ISINF(VALUE) 0
+#define REAL_VALUE_ISNAN(VALUE) 0
+#define SET_REAL_VALUE_ATOF(TARGET,SOURCE)
+#define FLOAT_TYPE_NODE 0
+#define DOUBLE_TYPE_NODE 0
+#define SET_MODIFIER_CTX(TOKEN) java_lval->value = (TOKEN)
+#define GET_TYPE_PRECISION(NODE) 4
+#define BUILD_OPERATOR(TOKEN) return TOKEN
+#define BUILD_OPERATOR2(TOKEN) return TOKEN
+#define SET_LVAL_NODE(NODE)
+#define SET_LVAL_NODE_TYPE(NODE, TYPE)
+#define BUILD_ID_WFL(EXP) (EXP)
+#define JAVA_FLOAT_RANGE_ERROR(S) {}
+#define JAVA_INTEGRAL_RANGE_ERROR(S) {}
+
+#else
+
+static tree build_wfl_node ();
+#define SET_FLOAT_HANDLER(H) set_float_handler ((H))
+#define DCONST0 dconst0
+#define GET_IDENTIFIER(S) get_identifier ((S))
+#define SET_REAL_VALUE_ATOF(TARGET,SOURCE) (TARGET) = (SOURCE)
+#define FLOAT_TYPE_NODE float_type_node
+#define DOUBLE_TYPE_NODE double_type_node
+/* Set modifier_ctx according to TOKEN */
+#define SET_MODIFIER_CTX(TOKEN) \
+ { \
+ ctxp->modifier_ctx [(TOKEN)-PUBLIC_TK] = build_wfl_node (NULL_TREE); \
+ java_lval->value = (TOKEN)-PUBLIC_TK; \
+ }
+/* Type precision for long */
+#define GET_TYPE_PRECISION(NODE) TYPE_PRECISION (long_type_node) / 8;
+/* Build an operator tree node and return TOKEN */
+#define BUILD_OPERATOR(TOKEN) \
+ { \
+ java_lval->operator.token = (TOKEN); \
+ java_lval->operator.location = BUILD_LOCATION(); \
+ return (TOKEN); \
+ }
+
+/* Build an operator tree node but return ASSIGN_ANY_TK */
+#define BUILD_OPERATOR2(TOKEN) \
+ { \
+ java_lval->operator.token = (TOKEN); \
+ java_lval->operator.location = BUILD_LOCATION(); \
+ return ASSIGN_ANY_TK; \
+ }
+/* Set java_lval->node and TREE_TYPE(java_lval->node) in macros */
+#define SET_LVAL_NODE(NODE) java_lval->node = (NODE)
+#define SET_LVAL_NODE_TYPE(NODE,TYPE) \
+ { \
+ java_lval->node = (NODE); \
+ TREE_TYPE (java_lval->node) = (TYPE); \
+ }
+/* Wrap identifier around a wfl */
+#define BUILD_ID_WFL(EXP) build_wfl_node ((EXP))
+/* Special ways to report error on numeric literals */
+#define JAVA_FLOAT_RANGE_ERROR(m) \
+ { \
+ char msg [1024]; \
+ int i = ctxp->c_line->current; \
+ ctxp->c_line->current = number_beginning; \
+ sprintf (msg, "Floating pointer literal exceeds range of `%s'", (m)); \
+ java_lex_error (msg, 0); \
+ ctxp->c_line->current = i; \
+ value = dconst0; \
+ }
+#define JAVA_INTEGRAL_RANGE_ERROR(m) \
+ { \
+ int i = ctxp->c_line->current; \
+ ctxp->c_line->current = number_beginning; \
+ java_lex_error (m, 0); \
+ ctxp->c_line->current = i; \
+ }
+
+#endif /* Definitions for jc1 compilation only */
+
+/* Macros to decode character ranges */
+#define RANGE(c, l, h) (((c) >= l && (c) <= h))
+#define JAVA_WHITE_SPACE_P(c) (c == ' ' || c == '\t' || c == '\f')
+#define JAVA_ID_CHAR_P(c) ((c < 128 && (RANGE (c, 'A', 'Z') || \
+ RANGE (c, 'a', 'z') || \
+ RANGE (c, '0', '9') || \
+ c == '_' || \
+ c == '$')) || \
+ (c > 127 && java_letter_or_digit_p (c)))
+#define JAVA_ASCII_DIGIT(c) RANGE(c,'0', '9')
+#define JAVA_ASCII_OCTDIGIT(c) RANGE(c,'0', '7')
+#define JAVA_ASCII_HEXDIGIT(c) (RANGE(c,'0', '9') || \
+ RANGE(c,'a', 'f') || \
+ RANGE(c,'A', 'F'))
+#define JAVA_ASCII_FPCHAR(c) (RANGE(c,'d', 'f') || RANGE(c,'D', 'F') || \
+ c == '.' || JAVA_ASCII_DIGIT (c))
+#define JAVA_FP_SUFFIX(c) (c == 'D' || c == 'd' || c == 'f' || c == 'F')
+#define JAVA_FP_EXP(c) (c == 'E' || c == 'F')
+#define JAVA_FP_PM(c) (c == '-' || c == '+')
+#define JAVA_ASCII_LETTER(c) (RANGE(c,'a', 'z') || RANGE(c,'A', 'Z'))
+#define JAVA_DIGIT_P(c) \
+ (RANGE (c, 0x030, 0x039) || /* ISO-Latin-1 (and ASCII) digits ('0'-'9') */ \
+ RANGE (c, 0x660, 0x669) || /* Arabic-Indic digits */ \
+ RANGE (c, 0x6F0, 0x6F9) || /* Eastern Arabic-Indic digits */ \
+ RANGE (c, 0x966, 0x96F) || /* Devanagari digits */ \
+ RANGE (c, 0x9E6, 0x9EF) || /* Bengali digits */ \
+ RANGE (c, 0xA66, 0xA6F) || /* Gurmukhi digits */ \
+ RANGE (c, 0xAE6, 0xAEF) || /* Gujarati digits */ \
+ RANGE (c, 0xB66, 0xB6F) || /* Oriya digits */ \
+ RANGE (c, 0xBE7, 0xBEF) || /* Tamil digits */ \
+ RANGE (c, 0xC66, 0xC6F) || /* Telugu digits */ \
+ RANGE (c, 0xCE6, 0xCEF) || /* Kannada digits */ \
+ RANGE (c, 0xD66, 0xD6F) || /* Malayalam digits */ \
+ RANGE (c, 0xE50, 0xE59) || /* Thai digits */ \
+ RANGE (c, 0xED0, 0xED9)) /* Lao digits */
+
+/* This is not to be used as a stand alone macro. Use JAVA_ID_CHAR_P()
+ or the forcoming JAVA_LETTER_OR_DIGIT_P() instead.
+ It need to be split by region. FIXME. */
+#define _JAVA_LETTER_OR_DIGIT_P(c) \
+ (RANGE (c, 0x00C0, 0x00D6) || \
+ RANGE (c, 0x00D8, 0x00F6) || \
+ RANGE (c, 0x00F8, 0x01F5) || \
+ RANGE (c, 0x01FA, 0x0217) || \
+ RANGE (c, 0x0250, 0x02A8) || \
+ RANGE (c, 0x02B0, 0x02DE) || \
+ RANGE (c, 0x02E0, 0x02E9) || \
+ RANGE (c, 0x0300, 0x0345) || \
+ RANGE (c, 0x0360, 0x0361) || \
+ RANGE (c, 0x0374, 0x0375) || \
+ c == 0x037A || \
+ c == 0x037E || \
+ RANGE (c, 0x0384, 0x038A) || \
+ c == 0x038C || \
+ c == 0x038E || \
+ RANGE (c, 0x038F, 0x03A1) || \
+ RANGE (c, 0x03A3, 0x03CE) || \
+ RANGE (c, 0x03D0, 0x03D6) || \
+ RANGE (c, 0x03DA, 0x03E2) || \
+ c == 0x03DA || \
+ c == 0x03DC || \
+ c == 0x03DE || \
+ c == 0x03E0 || \
+ RANGE (c, 0x03E2, 0x03F3) || \
+ RANGE (c, 0x0401, 0x040C) || \
+ RANGE (c, 0x040E, 0x044F) || \
+ RANGE (c, 0x0451, 0x045C) || \
+ RANGE (c, 0x045E, 0x0486) || \
+ RANGE (c, 0x0490, 0x04C4) || \
+ RANGE (c, 0x04C7, 0x04C8) || \
+ RANGE (c, 0x04CB, 0x04CC) || \
+ RANGE (c, 0x04D0, 0x04EB) || \
+ RANGE (c, 0x04EE, 0x04F5) || \
+ RANGE (c, 0x04F8, 0x04F9) || \
+ RANGE (c, 0x0531, 0x0556) || \
+ RANGE (c, 0x0559, 0x055F) || \
+ RANGE (c, 0x0561, 0x0587) || \
+ c == 0x0589 || \
+ RANGE (c, 0x05B0, 0x05B9) || \
+ RANGE (c, 0x05BB, 0x05C3) || \
+ RANGE (c, 0x05D0, 0x05EA) || \
+ RANGE (c, 0x05F0, 0x05F4) || \
+ c == 0x060C || \
+ c == 0x061B || \
+ c == 0x061F || \
+ c == 0x0621 || \
+ RANGE (c, 0x0622, 0x063A) || \
+ RANGE (c, 0x0640, 0x0652) || \
+ RANGE (c, 0x0660, 0x066D) || \
+ RANGE (c, 0x0670, 0x06B7) || \
+ RANGE (c, 0x06BA, 0x06BE) || \
+ RANGE (c, 0x06C0, 0x06CE) || \
+ RANGE (c, 0x06D0, 0x06ED) || \
+ RANGE (c, 0x06F0, 0x06F9) || \
+ RANGE (c, 0x0901, 0x0903) || \
+ RANGE (c, 0x0905, 0x0939) || \
+ RANGE (c, 0x093C, 0x094D) || \
+ RANGE (c, 0x0950, 0x0954) || \
+ RANGE (c, 0x0958, 0x0970) || \
+ RANGE (c, 0x0981, 0x0983) || \
+ RANGE (c, 0x0985, 0x098C) || \
+ RANGE (c, 0x098F, 0x0990) || \
+ RANGE (c, 0x0993, 0x09A8) || \
+ RANGE (c, 0x09AA, 0x09B0) || \
+ c == 0x09B2 || \
+ RANGE (c, 0x09B6, 0x09B9) || \
+ c == 0x09BC || \
+ c == 0x09BE || \
+ RANGE (c, 0x09BF, 0x09C4) || \
+ RANGE (c, 0x09C7, 0x09C8) || \
+ RANGE (c, 0x09CB, 0x09CD) || \
+ c == 0x09D7 || \
+ RANGE (c, 0x09DC, 0x09DD) || \
+ RANGE (c, 0x09DF, 0x09E3) || \
+ RANGE (c, 0x09E6, 0x09FA) || \
+ c == 0x0A02 || \
+ RANGE (c, 0x0A05, 0x0A0A) || \
+ RANGE (c, 0x0A0F, 0x0A10) || \
+ RANGE (c, 0x0A13, 0x0A28) || \
+ RANGE (c, 0x0A2A, 0x0A30) || \
+ RANGE (c, 0x0A32, 0x0A33) || \
+ RANGE (c, 0x0A35, 0x0A36) || \
+ RANGE (c, 0x0A38, 0x0A39) || \
+ c == 0x0A3C || \
+ c == 0x0A3E || \
+ RANGE (c, 0x0A3F, 0x0A42) || \
+ RANGE (c, 0x0A47, 0x0A48) || \
+ RANGE (c, 0x0A4B, 0x0A4D) || \
+ RANGE (c, 0x0A59, 0x0A5C) || \
+ c == 0x0A5E || \
+ RANGE (c, 0x0A66, 0x0A74) || \
+ RANGE (c, 0x0A81, 0x0A83) || \
+ RANGE (c, 0x0A85, 0x0A8B) || \
+ c == 0x0A8D || \
+ c == 0x0A8F || \
+ RANGE (c, 0x0A90, 0x0A91) || \
+ RANGE (c, 0x0A93, 0x0AA8) || \
+ RANGE (c, 0x0AAA, 0x0AB0) || \
+ RANGE (c, 0x0AB2, 0x0AB3) || \
+ RANGE (c, 0x0AB5, 0x0AB9) || \
+ RANGE (c, 0x0ABC, 0x0AC5) || \
+ RANGE (c, 0x0AC7, 0x0AC9) || \
+ RANGE (c, 0x0ACB, 0x0ACD) || \
+ c == 0x0AD0 || \
+ c == 0x0AE0 || \
+ RANGE (c, 0x0AE6, 0x0AEF) || \
+ RANGE (c, 0x0B01, 0x0B03) || \
+ RANGE (c, 0x0B05, 0x0B0C) || \
+ RANGE (c, 0x0B0F, 0x0B10) || \
+ RANGE (c, 0x0B13, 0x0B28) || \
+ RANGE (c, 0x0B2A, 0x0B30) || \
+ RANGE (c, 0x0B32, 0x0B33) || \
+ RANGE (c, 0x0B36, 0x0B39) || \
+ RANGE (c, 0x0B3C, 0x0B43) || \
+ RANGE (c, 0x0B47, 0x0B48) || \
+ RANGE (c, 0x0B4B, 0x0B4D) || \
+ RANGE (c, 0x0B56, 0x0B57) || \
+ RANGE (c, 0x0B5C, 0x0B5D) || \
+ RANGE (c, 0x0B5F, 0x0B61) || \
+ RANGE (c, 0x0B66, 0x0B70) || \
+ RANGE (c, 0x0B82, 0x0B83) || \
+ RANGE (c, 0x0B85, 0x0B8A) || \
+ RANGE (c, 0x0B8E, 0x0B90) || \
+ RANGE (c, 0x0B92, 0x0B95) || \
+ RANGE (c, 0x0B99, 0x0B9A) || \
+ c == 0x0B9C || \
+ c == 0x0B9E || \
+ c == 0x0B9F || \
+ RANGE (c, 0x0BA3, 0x0BA4) || \
+ RANGE (c, 0x0BA8, 0x0BAA) || \
+ RANGE (c, 0x0BAE, 0x0BB5) || \
+ RANGE (c, 0x0BB7, 0x0BB9) || \
+ RANGE (c, 0x0BBE, 0x0BC2) || \
+ RANGE (c, 0x0BC6, 0x0BC8) || \
+ RANGE (c, 0x0BCA, 0x0BCD) || \
+ c == 0x0BD7 || \
+ RANGE (c, 0x0BE7, 0x0BF2) || \
+ RANGE (c, 0x0C01, 0x0C03) || \
+ RANGE (c, 0x0C05, 0x0C0C) || \
+ RANGE (c, 0x0C0E, 0x0C10) || \
+ RANGE (c, 0x0C12, 0x0C28) || \
+ RANGE (c, 0x0C2A, 0x0C33) || \
+ RANGE (c, 0x0C35, 0x0C39) || \
+ RANGE (c, 0x0C3E, 0x0C44) || \
+ RANGE (c, 0x0C46, 0x0C48) || \
+ RANGE (c, 0x0C4A, 0x0C4D) || \
+ RANGE (c, 0x0C55, 0x0C56) || \
+ RANGE (c, 0x0C60, 0x0C61) || \
+ RANGE (c, 0x0C66, 0x0C6F) || \
+ RANGE (c, 0x0C82, 0x0C83) || \
+ RANGE (c, 0x0C85, 0x0C8C) || \
+ RANGE (c, 0x0C8E, 0x0C90) || \
+ RANGE (c, 0x0C92, 0x0CA8) || \
+ RANGE (c, 0x0CAA, 0x0CB3) || \
+ RANGE (c, 0x0CB5, 0x0CB9) || \
+ RANGE (c, 0x0CBE, 0x0CC4) || \
+ RANGE (c, 0x0CC6, 0x0CC8) || \
+ RANGE (c, 0x0CCA, 0x0CCD) || \
+ RANGE (c, 0x0CD5, 0x0CD6) || \
+ c == 0x0CDE || \
+ c == 0x0CE0 || \
+ c == 0x0CE1 || \
+ RANGE (c, 0x0CE6, 0x0CEF) || \
+ RANGE (c, 0x0D02, 0x0D03) || \
+ RANGE (c, 0x0D05, 0x0D0C) || \
+ RANGE (c, 0x0D0E, 0x0D10) || \
+ RANGE (c, 0x0D12, 0x0D28) || \
+ RANGE (c, 0x0D2A, 0x0D39) || \
+ RANGE (c, 0x0D3E, 0x0D43) || \
+ RANGE (c, 0x0D46, 0x0D48) || \
+ RANGE (c, 0x0D4A, 0x0D4D) || \
+ c == 0x0D57 || \
+ RANGE (c, 0x0D60, 0x0D61) || \
+ RANGE (c, 0x0D66, 0x0D6F) || \
+ RANGE (c, 0x0E01, 0x0E3A) || \
+ RANGE (c, 0x0E3F, 0x0E5B) || \
+ RANGE (c, 0x0E81, 0x0E82) || \
+ c == 0x0E84 || \
+ RANGE (c, 0x0E87, 0x0E88) || \
+ c == 0x0E8A || \
+ c == 0x0E8D || \
+ RANGE (c, 0x0E94, 0x0E97) || \
+ RANGE (c, 0x0E99, 0x0E9F) || \
+ RANGE (c, 0x0EA1, 0x0EA3) || \
+ c == 0x0EA5 || \
+ c == 0x0EA7 || \
+ RANGE (c, 0x0EAA, 0x0EAB) || \
+ RANGE (c, 0x0EAD, 0x0EB9) || \
+ RANGE (c, 0x0EBB, 0x0EBD) || \
+ RANGE (c, 0x0EC0, 0x0EC4) || \
+ c == 0x0EC6 || \
+ c == 0x0EC8 || \
+ RANGE (c, 0x0EC9, 0x0ECD) || \
+ RANGE (c, 0x0ED0, 0x0ED9) || \
+ RANGE (c, 0x0EDC, 0x0EDD) || \
+ RANGE (c, 0x10A0, 0x10C5) || \
+ RANGE (c, 0x10D0, 0x10F6) || \
+ c == 0x10FB || \
+ RANGE (c, 0x1100, 0x1159) || \
+ RANGE (c, 0x115F, 0x11A2) || \
+ RANGE (c, 0x11A8, 0x11F9) || \
+ RANGE (c, 0x1E00, 0x1E9A) || \
+ RANGE (c, 0x1EA0, 0x1EF9) || \
+ RANGE (c, 0x1F00, 0x1F15) || \
+ RANGE (c, 0x1F18, 0x1F1D) || \
+ RANGE (c, 0x1F20, 0x1F45) || \
+ RANGE (c, 0x1F48, 0x1F4D) || \
+ RANGE (c, 0x1F50, 0x1F57) || \
+ c == 0x1F59 || \
+ c == 0x1F5B || \
+ c == 0x1F5D || \
+ RANGE (c, 0x1F5F, 0x1F7D) || \
+ RANGE (c, 0x1F80, 0x1FB4) || \
+ RANGE (c, 0x1FB6, 0x1FC4) || \
+ RANGE (c, 0x1FC6, 0x1FD3) || \
+ RANGE (c, 0x1FD6, 0x1FDB) || \
+ RANGE (c, 0x1FDD, 0x1FEF) || \
+ RANGE (c, 0x1FF2, 0x1FF4) || \
+ RANGE (c, 0x1FF6, 0x1FFE) || \
+ RANGE (c, 0x3041, 0x3094) || \
+ RANGE (c, 0x3099, 0x309E) || \
+ RANGE (c, 0x30A1, 0x30FE) || \
+ RANGE (c, 0x3105, 0x312C) || \
+ RANGE (c, 0x3131, 0x318E) || \
+ RANGE (c, 0x3190, 0x319F) || \
+ RANGE (c, 0x3200, 0x321C) || \
+ RANGE (c, 0x3220, 0x3243) || \
+ RANGE (c, 0x3260, 0x327B) || \
+ RANGE (c, 0x327F, 0x32B0) || \
+ RANGE (c, 0x32C0, 0x32CB) || \
+ RANGE (c, 0x32D0, 0x32FE) || \
+ RANGE (c, 0x3300, 0x3376) || \
+ RANGE (c, 0x337B, 0x33DD) || \
+ RANGE (c, 0x33E0, 0x33FE) || \
+ RANGE (c, 0x3400, 0x9FA5) || \
+ RANGE (c, 0xF900, 0xFA2D) || \
+ RANGE (c, 0xFB00, 0xFB06) || \
+ RANGE (c, 0xFB13, 0xFB17) || \
+ RANGE (c, 0xFB1E, 0xFB36) || \
+ RANGE (c, 0xFB38, 0xFB3C) || \
+ c == 0xFB3E || \
+ c == 0xFB40 || \
+ c == 0xFB41 || \
+ c == 0xFB43 || \
+ c == 0xFB44 || \
+ c == 0xFB46 || \
+ RANGE (c, 0xFB47, 0xFBB1) || \
+ RANGE (c, 0xFBD3, 0xFD3F) || \
+ RANGE (c, 0xFD50, 0xFD8F) || \
+ RANGE (c, 0xFD92, 0xFDC7) || \
+ RANGE (c, 0xFDF0, 0xFDFB) || \
+ RANGE (c, 0xFE70, 0xFE72) || \
+ c == 0xFE74 || \
+ c == 0xFE76 || \
+ RANGE (c, 0xFE77, 0xFEFC) || \
+ RANGE (c, 0xFF10, 0xFF19) || \
+ RANGE (c, 0xFF21, 0xFF3A) || \
+ RANGE (c, 0xFF41, 0xFF5A) || \
+ RANGE (c, 0xFF66, 0xFFBE) || \
+ RANGE (c, 0xFFC2, 0xFFC7) || \
+ RANGE (c, 0xFFCA, 0xFFCF) || \
+ RANGE (c, 0xFFD2, 0xFFD7) || \
+ RANGE (c, 0xFFDA, 0xFFDC))
+
+/* Constants */
+#define JAVA_CHAR_ERROR 0xFFC1 /* This is an illegal unicode!?! FIXME */
+#define JAVA_READ_BUFFER 256
+#define UEOF (unicode_t)0xffff
+
+#endif
--- /dev/null
+/* Functions related to mangling class names for the GNU compiler
+ for the Java(TM) language.
+ Copyright (C) 1998 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Written by Per Bothner <bothner@cygnus.com> */
+
+#include <stdio.h>
+#include <string.h>
+#include "config.h"
+#include "jcf.h"
+#include "obstack.h"
+
+/* Assuming (NAME, LEN) is a Utf8-encoding string, calculate
+ the length of the string as mangled (a la g++) including Unicode escapes.
+ If no escapes are needed, return 0. */
+
+int
+unicode_mangling_length (name, len)
+ char *name;
+ int len;
+{
+ unsigned char *ptr;
+ unsigned char *limit = (unsigned char *)name + len;
+ int need_escapes = 0;
+ int num_chars = 0;
+ int underscores = 0;
+ for (ptr = (unsigned char *) name; ptr < limit; )
+ {
+ int ch = UTF8_GET(ptr, limit);
+ if (ch < 0)
+ error ("internal error - invalid Utf8 name");
+ if (ch >= '0' && ch <= '9')
+ need_escapes += num_chars == 0;
+ else if (ch == '_')
+ underscores++;
+ else if ((ch < 'a' || ch > 'z') && (ch < 'A' || ch > 'Z'))
+ need_escapes++;
+ num_chars++;
+ }
+ if (need_escapes)
+ return num_chars + 4 * (need_escapes + underscores);
+ else
+ return 0;
+}
+
+/* Assuming (NAME, LEN) is a Utf8-encoding string, emit the string
+ appropriately mangled (with Unicode escapes) to OBSTACK. */
+
+void
+emit_unicode_mangled_name (obstack, name, len)
+ struct obstack *obstack;
+ char *name;
+{
+ unsigned char *ptr;
+ unsigned char *limit = (unsigned char *)name + len;
+ for (ptr = (unsigned char *) name; ptr < limit; )
+ {
+ int ch = UTF8_GET(ptr, limit);
+ int emit_escape;
+ if (ch < 0)
+ {
+ error ("internal error - bad Utf8 string");
+ break;
+ }
+ if (ch >= '0' && ch <= '9')
+ emit_escape = (ptr == (unsigned char*) name);
+ else
+ emit_escape = (ch < 'a' || ch > 'z') && (ch < 'A' || ch > 'Z');
+ if (emit_escape)
+ {
+ char buf[6];
+ sprintf (buf, "_%04x", ch);
+ obstack_grow (obstack, buf, 5);
+ }
+ else
+ {
+ obstack_1grow (obstack, ch);
+ }
+ }
+}
+
+/* Assuming (NAME, LEN) is a Utf8-encoding string, emit the string
+ appropriately mangled (with Unicode escapes if needed) to OBSTACK. */
+
+void
+append_gpp_mangled_name (obstack, name, len)
+ struct obstack *obstack;
+ char *name;
+ int len;
+{
+ int encoded_len = unicode_mangling_length (name, len);
+ int needs_escapes = encoded_len > 0;
+ char buf[6];
+ if (needs_escapes)
+ {
+ sprintf (buf, "U%d", encoded_len);
+ obstack_grow (obstack, buf, strlen(buf));
+ emit_unicode_mangled_name (obstack, name, len);
+ }
+ else
+ {
+ sprintf (buf, "%d", len);
+ obstack_grow (obstack, buf, strlen(buf));
+ obstack_grow (obstack, name, len);
+ }
+}
+
+/* Append the mangled name of a class named CLASSNAME onto OBSTACK. */
+
+void
+append_gpp_mangled_classtype (obstack, class_name)
+ struct obstack *obstack;
+ char *class_name;
+{
+ char *ptr;
+ int qualifications = 0;
+
+ for (ptr = class_name; *ptr != '\0'; ptr++)
+ {
+ if (*ptr == '.')
+ qualifications++;
+ }
+ if (qualifications)
+ {
+ char buf[8];
+ if (qualifications >= 9)
+ sprintf (buf, "Q_%d_", qualifications + 1);
+ else
+ sprintf (buf, "Q%d", qualifications + 1);
+ obstack_grow (obstack, buf, strlen (buf));
+ }
+ for (ptr = class_name; ; ptr++)
+ {
+ if (ptr[0] == '.' || ptr[0] == '\0')
+ {
+ append_gpp_mangled_name (obstack, class_name, ptr - class_name);
+ if (ptr[0] == '\0')
+ break;
+ class_name = ptr + 1;
+ }
+ }
+}
--- /dev/null
+/* Parser grammar for quick source code scan of Java(TM) language programs.
+ Copyright (C) 1998 Free Software Foundation, Inc.
+ Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* This file parses Java source code. Action can be further completed
+to achieve a desired behavior. This file isn't part of the Java
+language gcc front end.
+
+The grammar conforms to the Java grammar described in "The Java(TM)
+Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
+1996, ISBN 0-201-63451-1"
+
+Some rules have been modified to support JDK1.1 inner classes
+definitions and other extensions. */
+
+%{
+#define JC1_LITE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Definitions for PROTO and VPROTO macros */
+#include "gansidecl.h"
+#include "obstack.h"
+
+extern char *input_filename;
+extern FILE *finput, *out;
+
+/* Obstack for the lexer. */
+struct obstack temporary_obstack;
+
+/* The current parser context. */
+static struct parser_ctxt *ctxp;
+
+/* Error and warning counts, current line number, because they're used
+ elsewhere */
+int java_error_count;
+int java_warning_count;
+int lineno;
+
+/* Tweak default rules when necessary. */
+static int absorber;
+#define USE_ABSORBER absorber = 0
+
+/* Keep track of the current class name and package name. */
+static char *current_class;
+static char *package_name;
+
+/* Keep track of whether things have be listed before. */
+static int previous_output;
+
+/* Record modifier uses */
+static int modifier_value;
+
+/* Record a method declaration */
+struct method_declarator {
+ char *method_name;
+ char *args;
+};
+#define NEW_METHOD_DECLARATOR(D,N,A) \
+{ \
+ (D) = \
+ (struct method_declarator *)xmalloc (sizeof (struct method_declarator)); \
+ (D)->method_name = (N); \
+ (D)->args = (A); \
+}
+
+/* Two actions for this grammar */
+static void report_class_declaration PROTO ((char *));
+static void report_main_declaration PROTO ((struct method_declarator *));
+
+/* Other extern functions */
+char *xmalloc PROTO ((unsigned));
+char *xstrdup PROTO ((char *));
+
+#include "lex.h"
+#include "parse.h"
+%}
+
+%union {
+ char *node;
+ struct method_declarator *declarator;
+ int value; /* For modifiers */
+}
+
+%pure_parser
+
+/* Things defined here have to match the order of what's in the
+ binop_lookup table. */
+
+%token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
+%token LS_TK SRS_TK ZRS_TK
+%token AND_TK XOR_TK OR_TK
+%token BOOL_AND_TK BOOL_OR_TK
+%token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
+
+/* This maps to the same binop_lookup entry than the token above */
+
+%token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
+%token REM_ASSIGN_TK
+%token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
+%token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
+
+
+/* Modifier TOKEN have to be kept in this order. Don't scramble it */
+
+%token PUBLIC_TK PRIVATE_TK PROTECTED_TK
+%token STATIC_TK FINAL_TK SYNCHRONIZED_TK
+%token VOLATILE_TK TRANSIENT_TK NATIVE_TK
+%token PAD_TK ABSTRACT_TK MODIFIER_TK
+
+/* Keep those two in order, too */
+%token DECR_TK INCR_TK
+
+/* From now one, things can be in any order */
+
+%token DEFAULT_TK IF_TK THROW_TK
+%token BOOLEAN_TK DO_TK IMPLEMENTS_TK
+%token THROWS_TK BREAK_TK IMPORT_TK
+%token ELSE_TK INSTANCEOF_TK RETURN_TK
+%token VOID_TK CATCH_TK INTERFACE_TK
+%token CASE_TK EXTENDS_TK FINALLY_TK
+%token SUPER_TK WHILE_TK CLASS_TK
+%token SWITCH_TK CONST_TK TRY_TK
+%token FOR_TK NEW_TK CONTINUE_TK
+%token GOTO_TK PACKAGE_TK THIS_TK
+
+%token BYTE_TK SHORT_TK INT_TK LONG_TK
+%token CHAR_TK INTEGRAL_TK
+
+%token FLOAT_TK DOUBLE_TK FP_TK
+
+%token ID_TK
+
+%token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
+
+%token ASSIGN_ANY_TK ASSIGN_TK
+%token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
+
+%token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
+%token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
+
+%type <node> ID_TK identifier name simple_name qualified_name type
+ primitive_type reference_type array_type formal_parameter_list
+ formal_parameter class_or_interface_type class_type interface_type
+%type <declarator> method_declarator
+%type <value> MODIFIER_TK
+
+%%
+/* 19.2 Production from 2.3: The Syntactic Grammar */
+goal:
+ compilation_unit
+;
+
+/* 19.3 Productions from 3: Lexical structure */
+literal:
+ INT_LIT_TK
+| FP_LIT_TK
+| BOOL_LIT_TK
+| CHAR_LIT_TK
+| STRING_LIT_TK
+| NULL_TK
+;
+
+/* 19.4 Productions from 4: Types, Values and Variables */
+type:
+ primitive_type
+| reference_type
+;
+
+primitive_type:
+ INTEGRAL_TK
+ {
+ /* use preset global here. FIXME */
+ $$ = xstrdup ("int");
+ }
+| FP_TK
+ {
+ /* use preset global here. FIXME */
+ $$ = xstrdup ("double");
+ }
+| BOOLEAN_TK
+ {
+ /* use preset global here. FIXME */
+ $$ = xstrdup ("boolean");
+ }
+;
+
+reference_type:
+ class_or_interface_type
+| array_type
+;
+
+class_or_interface_type:
+ name
+;
+
+class_type:
+ class_or_interface_type /* Default rule */
+;
+
+interface_type:
+ class_or_interface_type
+;
+
+array_type:
+ primitive_type OSB_TK CSB_TK
+| name OSB_TK CSB_TK
+ {
+ char *n = xmalloc (strlen ($1)+2);
+ n [0] = '[';
+ strcpy (n+1, $1);
+ $$ = n;
+ }
+| array_type OSB_TK CSB_TK
+ {
+ char *n = xmalloc (strlen ($1)+2);
+ n [0] = '[';
+ strcpy (n+1, $1);
+ $$ = n;
+ }
+;
+
+/* 19.5 Productions from 6: Names */
+name:
+ simple_name /* Default rule */
+| qualified_name /* Default rule */
+;
+
+simple_name:
+ identifier /* Default rule */
+;
+
+qualified_name:
+ name DOT_TK identifier
+ {
+ char *n = xmalloc (strlen ($1)+strlen ($3)+2);
+ sprintf (n, "%s.s", $1, $3);
+ $$ = n;
+ }
+;
+
+identifier:
+ ID_TK
+;
+
+/* 19.6: Production from 7: Packages */
+compilation_unit:
+| package_declaration
+| import_declarations
+| type_declarations
+| package_declaration import_declarations
+| package_declaration type_declarations
+| import_declarations type_declarations
+| package_declaration import_declarations type_declarations
+;
+
+import_declarations:
+ import_declaration
+| import_declarations import_declaration
+;
+
+type_declarations:
+ type_declaration
+| type_declarations type_declaration
+;
+
+package_declaration:
+ PACKAGE_TK name SC_TK
+ { package_name = $2; }
+;
+
+import_declaration:
+ single_type_import_declaration
+| type_import_on_demand_declaration
+;
+
+single_type_import_declaration:
+ IMPORT_TK name SC_TK
+;
+
+type_import_on_demand_declaration:
+ IMPORT_TK name DOT_TK MULT_TK SC_TK
+;
+
+type_declaration:
+ class_declaration
+| interface_declaration
+| SC_TK
+;
+
+/* 19.7 Shortened from the original:
+ modifiers: modifier | modifiers modifier
+ modifier: any of public... */
+modifiers:
+ MODIFIER_TK
+ {
+ if ($1 == PUBLIC_TK)
+ modifier_value++;
+ if ($1 == STATIC_TK)
+ modifier_value++;
+ USE_ABSORBER;
+ }
+| modifiers MODIFIER_TK
+ {
+ if ($2 == PUBLIC_TK)
+ modifier_value++;
+ if ($2 == STATIC_TK)
+ modifier_value++;
+ USE_ABSORBER;
+ }
+;
+
+/* 19.8.1 Production from $8.1: Class Declaration */
+class_declaration:
+ modifiers CLASS_TK identifier super interfaces
+ {
+ report_class_declaration($3);
+ modifier_value = 0;
+ }
+ class_body
+| CLASS_TK identifier super interfaces
+ { report_class_declaration($2); }
+ class_body
+;
+
+super:
+| EXTENDS_TK class_type
+;
+
+interfaces:
+| IMPLEMENTS_TK interface_type_list
+;
+
+interface_type_list:
+ interface_type
+ { USE_ABSORBER; }
+| interface_type_list C_TK interface_type
+ { USE_ABSORBER; }
+;
+
+class_body:
+ OCB_TK CCB_TK
+| OCB_TK class_body_declarations CCB_TK
+;
+
+class_body_declarations:
+ class_body_declaration
+| class_body_declarations class_body_declaration
+;
+
+class_body_declaration:
+ class_member_declaration
+| static_initializer
+| constructor_declaration
+| block /* Added, JDK1.1, instance initializer */
+;
+
+class_member_declaration:
+ field_declaration
+| method_declaration
+| class_declaration /* Added, JDK1.1 inner classes */
+| interface_declaration /* Added, JDK1.1 inner classes */
+;
+
+/* 19.8.2 Productions from 8.3: Field Declarations */
+field_declaration:
+ type variable_declarators SC_TK
+ { USE_ABSORBER; }
+| modifiers type variable_declarators SC_TK
+ { modifier_value = 0; }
+;
+
+variable_declarators:
+ /* Should we use build_decl_list () instead ? FIXME */
+ variable_declarator /* Default rule */
+| variable_declarators C_TK variable_declarator
+;
+
+variable_declarator:
+ variable_declarator_id
+| variable_declarator_id ASSIGN_TK variable_initializer
+;
+
+variable_declarator_id:
+ identifier
+ { USE_ABSORBER; }
+| variable_declarator_id OSB_TK CSB_TK
+;
+
+variable_initializer:
+ expression
+| array_initializer
+;
+
+/* 19.8.3 Productions from 8.4: Method Declarations */
+method_declaration:
+ method_header method_body
+;
+
+method_header:
+ type method_declarator throws
+ { USE_ABSORBER; }
+| VOID_TK method_declarator throws
+| modifiers type method_declarator throws
+ { modifier_value = 0; }
+| modifiers VOID_TK method_declarator throws
+ {
+ report_main_declaration ($3);
+ modifier_value = 0;
+ }
+;
+
+method_declarator:
+ identifier OP_TK CP_TK
+ {
+ struct method_declarator *d;
+ NEW_METHOD_DECLARATOR (d, $1, NULL);
+ $$ = d;
+ }
+| identifier OP_TK formal_parameter_list CP_TK
+ {
+ struct method_declarator *d;
+ NEW_METHOD_DECLARATOR (d, $1, $3);
+ $$ = d;
+ }
+| method_declarator OSB_TK CSB_TK
+;
+
+formal_parameter_list:
+ formal_parameter
+| formal_parameter_list C_TK formal_parameter
+ {
+ char *n = xmalloc (strlen ($1)+strlen($3)+2);
+ sprintf (n, "%s,%s", $1, $3);
+ $$ = n;
+ }
+;
+
+formal_parameter:
+ type variable_declarator_id
+ {
+ USE_ABSORBER;
+ $$ = $1;
+ }
+| modifiers type variable_declarator_id /* Added, JDK1.1 final locals */
+ { $$ = $2; }
+;
+
+throws:
+| THROWS_TK class_type_list
+;
+
+class_type_list:
+ class_type
+ { USE_ABSORBER; }
+| class_type_list C_TK class_type
+ { USE_ABSORBER; }
+;
+
+method_body:
+ block
+| block SC_TK
+| SC_TK
+;
+
+/* 19.8.4 Productions from 8.5: Static Initializers */
+static_initializer:
+ static block
+| static block SC_TK /* Shouldn't be here. FIXME */
+;
+
+static: /* Test lval.sub_token here */
+ MODIFIER_TK
+ { USE_ABSORBER; }
+;
+
+/* 19.8.5 Productions from 8.6: Constructor Declarations */
+/* NOTE FOR FURTHER WORK ON CONSTRUCTORS:
+ - If a forbidded modifier is found, the the error is either the use of
+ a forbidded modifier for a constructor OR bogus attempt to declare a
+ method without having specified the return type. FIXME */
+constructor_declaration:
+ constructor_declarator throws constructor_body
+| modifiers constructor_declarator throws constructor_body
+ { modifier_value = 0; }
+/* extra SC_TK, FIXME */
+| constructor_declarator throws constructor_body SC_TK
+/* extra SC_TK, FIXME */
+| modifiers constructor_declarator throws constructor_body SC_TK
+ { modifier_value = 0; }
+/* I'm not happy with the SC_TK addition. It isn't in the grammer and should
+ probably be matched by and empty statement. But it doesn't work. FIXME */
+;
+
+constructor_declarator:
+ simple_name OP_TK CP_TK
+ { USE_ABSORBER; }
+| simple_name OP_TK formal_parameter_list CP_TK
+ { USE_ABSORBER; }
+;
+
+constructor_body:
+ OCB_TK CCB_TK
+| OCB_TK explicit_constructor_invocation CCB_TK
+| OCB_TK block_statements CCB_TK
+| OCB_TK explicit_constructor_invocation block_statements CCB_TK
+;
+
+/* Error recovery for that rule moved down expression_statement: rule. */
+explicit_constructor_invocation:
+ this_or_super OP_TK CP_TK SC_TK
+| this_or_super OP_TK argument_list CP_TK SC_TK
+ /* Added, JDK1.1 inner classes. Modified because the rule
+ 'primary' couldn't work. */
+| name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
+ { USE_ABSORBER; }
+| name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
+ { USE_ABSORBER; }
+;
+
+this_or_super: /* Added, simplifies error diagnostics */
+ THIS_TK
+| SUPER_TK
+;
+
+/* 19.9 Productions from 9: Interfaces */
+/* 19.9.1 Productions from 9.1: Interfaces Declarations */
+interface_declaration:
+ INTERFACE_TK identifier interface_body
+| modifiers INTERFACE_TK identifier interface_body
+ { modifier_value = 0; }
+| INTERFACE_TK identifier extends_interfaces interface_body
+| modifiers INTERFACE_TK identifier extends_interfaces interface_body
+ { modifier_value = 0; }
+;
+
+extends_interfaces:
+ EXTENDS_TK interface_type
+| extends_interfaces C_TK interface_type
+;
+
+interface_body:
+ OCB_TK CCB_TK
+| OCB_TK interface_member_declarations CCB_TK
+;
+
+interface_member_declarations:
+ interface_member_declaration
+| interface_member_declarations interface_member_declaration
+;
+
+interface_member_declaration:
+ constant_declaration
+| abstract_method_declaration
+| class_declaration /* Added, JDK1.1 inner classes */
+| interface_declaration /* Added, JDK1.1 inner classes */
+;
+
+constant_declaration:
+ field_declaration
+;
+
+abstract_method_declaration:
+ method_header SC_TK
+;
+
+/* 19.10 Productions from 10: Arrays */
+array_initializer:
+ OCB_TK CCB_TK
+| OCB_TK variable_initializers CCB_TK
+| OCB_TK C_TK CCB_TK
+| OCB_TK variable_initializers C_TK CCB_TK
+;
+
+variable_initializers:
+ variable_initializer
+| variable_initializers C_TK variable_initializer
+;
+
+/* 19.11 Production from 14: Blocks and Statements */
+block:
+ OCB_TK CCB_TK
+| OCB_TK block_statements CCB_TK
+;
+
+block_statements:
+ block_statement
+| block_statements block_statement
+;
+
+block_statement:
+ local_variable_declaration_statement
+| statement
+| class_declaration /* Added, JDK1.1 inner classes */
+;
+
+local_variable_declaration_statement:
+ local_variable_declaration SC_TK /* Can't catch missing ';' here */
+;
+
+local_variable_declaration:
+ type variable_declarators
+ { USE_ABSORBER; }
+| modifiers type variable_declarators /* Added, JDK1.1 final locals */
+ { modifier_value = 0; }
+;
+
+statement:
+ statement_without_trailing_substatement
+| labeled_statement
+| if_then_statement
+| if_then_else_statement
+| while_statement
+| for_statement
+;
+
+statement_nsi:
+ statement_without_trailing_substatement
+| labeled_statement_nsi
+| if_then_else_statement_nsi
+| while_statement_nsi
+| for_statement_nsi
+;
+
+statement_without_trailing_substatement:
+ block
+| empty_statement
+| expression_statement
+| switch_statement
+| do_statement
+| break_statement
+| continue_statement
+| return_statement
+| synchronized_statement
+| throw_statement
+| try_statement
+;
+
+empty_statement:
+ SC_TK
+;
+
+label_decl:
+ identifier REL_CL_TK
+ { USE_ABSORBER; }
+;
+
+labeled_statement:
+ label_decl statement
+;
+
+labeled_statement_nsi:
+ label_decl statement_nsi
+;
+
+/* We concentrate here a bunch of error handling rules that we couldn't write
+ earlier, because expression_statement catches a missing ';'. */
+expression_statement:
+ statement_expression SC_TK
+;
+
+statement_expression:
+ assignment
+| pre_increment_expression
+| pre_decrement_expression
+| post_increment_expression
+| post_decrement_expression
+| method_invocation
+| class_instance_creation_expression
+;
+
+if_then_statement:
+ IF_TK OP_TK expression CP_TK statement
+;
+
+if_then_else_statement:
+ IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
+;
+
+if_then_else_statement_nsi:
+ IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
+;
+
+switch_statement:
+ SWITCH_TK OP_TK expression CP_TK switch_block
+;
+
+switch_block:
+ OCB_TK CCB_TK
+| OCB_TK switch_labels CCB_TK
+| OCB_TK switch_block_statement_groups CCB_TK
+| OCB_TK switch_block_statement_groups switch_labels CCB_TK
+;
+
+switch_block_statement_groups:
+ switch_block_statement_group
+| switch_block_statement_groups switch_block_statement_group
+;
+
+switch_block_statement_group:
+ switch_labels block_statements
+;
+
+
+switch_labels:
+ switch_label
+| switch_labels switch_label
+;
+
+switch_label:
+ CASE_TK constant_expression REL_CL_TK
+| DEFAULT_TK REL_CL_TK
+;
+
+while_expression:
+ WHILE_TK OP_TK expression CP_TK
+;
+
+while_statement:
+ while_expression statement
+;
+
+while_statement_nsi:
+ while_expression statement_nsi
+;
+
+do_statement_begin:
+ DO_TK
+;
+
+do_statement:
+ do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
+;
+
+for_statement:
+ for_begin SC_TK expression SC_TK for_update CP_TK statement
+| for_begin SC_TK SC_TK for_update CP_TK statement
+;
+
+for_statement_nsi:
+ for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
+| for_begin SC_TK SC_TK for_update CP_TK statement_nsi
+;
+
+for_header:
+ FOR_TK OP_TK
+;
+
+for_begin:
+ for_header for_init
+;
+for_init: /* Can be empty */
+| statement_expression_list
+| local_variable_declaration
+;
+
+for_update: /* Can be empty */
+| statement_expression_list
+;
+
+statement_expression_list:
+ statement_expression
+| statement_expression_list C_TK statement_expression
+;
+
+break_statement:
+ BREAK_TK SC_TK
+| BREAK_TK identifier SC_TK
+;
+
+continue_statement:
+ CONTINUE_TK SC_TK
+| CONTINUE_TK identifier SC_TK
+;
+
+return_statement:
+ RETURN_TK SC_TK
+| RETURN_TK expression SC_TK
+;
+
+throw_statement:
+ THROW_TK expression SC_TK
+;
+
+synchronized_statement:
+ synchronized OP_TK expression CP_TK block
+| synchronized OP_TK expression CP_TK error
+;
+
+synchronized: /* Test lval.sub_token here */
+ MODIFIER_TK
+ { USE_ABSORBER; }
+;
+
+try_statement:
+ TRY_TK block catches
+| TRY_TK block finally
+| TRY_TK block catches finally
+;
+
+catches:
+ catch_clause
+| catches catch_clause
+;
+
+catch_clause:
+ CATCH_TK OP_TK formal_parameter CP_TK block
+;
+
+finally:
+ FINALLY_TK block
+;
+
+/* 19.12 Production from 15: Expressions */
+primary:
+ primary_no_new_array
+| array_creation_expression
+;
+
+primary_no_new_array:
+ literal
+| THIS_TK
+| OP_TK expression CP_TK
+| class_instance_creation_expression
+| field_access
+| method_invocation
+| array_access
+ /* type DOT_TK CLASS_TK doens't work. So we split the rule
+ 'type' into its components. Missing is something for array,
+ which will complete the reference_type part. FIXME */
+| name DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
+ { USE_ABSORBER; }
+| primitive_type DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
+ { USE_ABSORBER; }
+| VOID_TK DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
+ /* Added, JDK1.1 inner classes. Documentation is wrong
+ refering to a 'ClassName' (class_name) rule that doesn't
+ exist. Used name instead. */
+| name DOT_TK THIS_TK
+ { USE_ABSORBER; }
+;
+
+class_instance_creation_expression:
+ NEW_TK class_type OP_TK argument_list CP_TK
+| NEW_TK class_type OP_TK CP_TK
+ /* Added, JDK1.1 inner classes but modified to use
+ 'class_type' instead of 'TypeName' (type_name) mentionned
+ in the documentation but doesn't exist. */
+| NEW_TK class_type OP_TK argument_list CP_TK class_body
+| NEW_TK class_type OP_TK CP_TK class_body
+ /* Added, JDK1.1 inner classes, modified to use name or
+ primary instead of primary solely which couldn't work in
+ all situations. */
+| something_dot_new identifier OP_TK CP_TK
+| something_dot_new identifier OP_TK CP_TK class_body
+| something_dot_new identifier OP_TK argument_list CP_TK
+| something_dot_new identifier OP_TK argument_list CP_TK class_body
+;
+
+something_dot_new: /* Added, not part of the specs. */
+ name DOT_TK NEW_TK
+ { USE_ABSORBER; }
+| primary DOT_TK NEW_TK
+;
+
+argument_list:
+ expression
+| argument_list C_TK expression
+| argument_list C_TK error
+;
+
+array_creation_expression:
+ NEW_TK primitive_type dim_exprs
+| NEW_TK class_or_interface_type dim_exprs
+| NEW_TK primitive_type dim_exprs dims
+| NEW_TK class_or_interface_type dim_exprs dims
+ /* Added, JDK1.1 anonymous array. Initial documentation rule
+ modified */
+| NEW_TK class_or_interface_type dims array_initializer
+| NEW_TK primitive_type dims array_initializer
+;
+
+dim_exprs:
+ dim_expr
+| dim_exprs dim_expr
+;
+
+dim_expr:
+ OSB_TK expression CSB_TK
+;
+
+dims:
+ OSB_TK CSB_TK
+| dims OSB_TK CSB_TK
+;
+
+field_access:
+ primary DOT_TK identifier
+| SUPER_TK DOT_TK identifier
+;
+
+method_invocation:
+ name OP_TK CP_TK
+ { USE_ABSORBER; }
+| name OP_TK argument_list CP_TK
+ { USE_ABSORBER; }
+| primary DOT_TK identifier OP_TK CP_TK
+| primary DOT_TK identifier OP_TK argument_list CP_TK
+| SUPER_TK DOT_TK identifier OP_TK CP_TK
+| SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
+;
+
+array_access:
+ name OSB_TK expression CSB_TK
+ { USE_ABSORBER; }
+| primary_no_new_array OSB_TK expression CSB_TK
+;
+
+postfix_expression:
+ primary
+| name
+ { USE_ABSORBER; }
+| post_increment_expression
+| post_decrement_expression
+;
+
+post_increment_expression:
+ postfix_expression INCR_TK
+;
+
+post_decrement_expression:
+ postfix_expression DECR_TK
+;
+
+unary_expression:
+ pre_increment_expression
+| pre_decrement_expression
+| PLUS_TK unary_expression
+| MINUS_TK unary_expression
+| unary_expression_not_plus_minus
+;
+
+pre_increment_expression:
+ INCR_TK unary_expression
+;
+
+pre_decrement_expression:
+ DECR_TK unary_expression
+;
+
+unary_expression_not_plus_minus:
+ postfix_expression
+| NOT_TK unary_expression
+| NEG_TK unary_expression
+| cast_expression
+;
+
+cast_expression: /* Error handling here is potentially weak */
+ OP_TK primitive_type dims CP_TK unary_expression
+| OP_TK primitive_type CP_TK unary_expression
+| OP_TK expression CP_TK unary_expression_not_plus_minus
+| OP_TK name dims CP_TK unary_expression_not_plus_minus
+;
+
+multiplicative_expression:
+ unary_expression
+| multiplicative_expression MULT_TK unary_expression
+| multiplicative_expression DIV_TK unary_expression
+| multiplicative_expression REM_TK unary_expression
+;
+
+additive_expression:
+ multiplicative_expression
+| additive_expression PLUS_TK multiplicative_expression
+| additive_expression MINUS_TK multiplicative_expression
+;
+
+shift_expression:
+ additive_expression
+| shift_expression LS_TK additive_expression
+| shift_expression SRS_TK additive_expression
+| shift_expression ZRS_TK additive_expression
+;
+
+relational_expression:
+ shift_expression
+| relational_expression LT_TK shift_expression
+| relational_expression GT_TK shift_expression
+| relational_expression LTE_TK shift_expression
+| relational_expression GTE_TK shift_expression
+| relational_expression INSTANCEOF_TK reference_type
+;
+
+equality_expression:
+ relational_expression
+| equality_expression EQ_TK relational_expression
+| equality_expression NEQ_TK relational_expression
+;
+
+and_expression:
+ equality_expression
+| and_expression AND_TK equality_expression
+;
+
+exclusive_or_expression:
+ and_expression
+| exclusive_or_expression XOR_TK and_expression
+;
+
+inclusive_or_expression:
+ exclusive_or_expression
+| inclusive_or_expression OR_TK exclusive_or_expression
+;
+
+conditional_and_expression:
+ inclusive_or_expression
+| conditional_and_expression BOOL_AND_TK inclusive_or_expression
+;
+
+conditional_or_expression:
+ conditional_and_expression
+| conditional_or_expression BOOL_OR_TK conditional_and_expression
+;
+
+conditional_expression: /* Error handling here is weak */
+ conditional_or_expression
+| conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
+;
+
+assignment_expression:
+ conditional_expression
+| assignment
+;
+
+assignment:
+ left_hand_side assignment_operator assignment_expression
+;
+
+left_hand_side:
+ name
+ { USE_ABSORBER; }
+| field_access
+| array_access
+;
+
+assignment_operator:
+ ASSIGN_ANY_TK
+| ASSIGN_TK
+;
+
+expression:
+ assignment_expression
+;
+
+constant_expression:
+ expression
+;
+
+%%
+\f
+#include "lex.c"
+
+/* Create a new parser context */
+
+void
+java_push_parser_context ()
+{
+ struct parser_ctxt *new =
+ (struct parser_ctxt *)xmalloc(sizeof (struct parser_ctxt));
+
+ bzero (new, sizeof (struct parser_ctxt));
+ new->next = ctxp;
+ ctxp = new;
+}
+
+/* Actions defined here */
+
+static void
+report_class_declaration (name)
+ char * name;
+{
+ extern int flag_dump_class, flag_list_filename;
+
+ if (flag_dump_class)
+ {
+ if (!previous_output)
+ {
+ if (flag_list_filename)
+ fprintf (out, "%s: ", input_filename);
+ previous_output = 1;
+ }
+
+ if (package_name)
+ fprintf (out, "%s.%s ", package_name, name);
+ else
+ fprintf (out, "%s ", name);
+ }
+
+ current_class = name;
+}
+
+static void
+report_main_declaration (declarator)
+ struct method_declarator *declarator;
+{
+ extern int flag_find_main;
+
+ if (flag_find_main
+ && modifier_value == 2
+ && !strcmp (declarator->method_name, "main")
+ && declarator->args
+ && declarator->args [0] == '['
+ && !strcmp( declarator->args+1, "String")
+ && current_class)
+ {
+ if (!previous_output)
+ {
+ if (package_name)
+ fprintf (out, "%s.%s ", package_name, current_class);
+ else
+ fprintf (out, current_class);
+ previous_output = 1;
+ }
+ }
+}
+
+/* Reset global status used by the report functions. */
+
+void reset_report ()
+{
+ previous_output = 0;
+ current_class = package_name = NULL;
+}
+
+void
+yyerror (msg)
+ char *msg;
+{
+}
--- /dev/null
+
+/* A Bison parser, made from /nfs/hoser/beer/java/egcs/gcc/java/parse.y
+ by GNU Bison version 1.25
+ */
+
+#define YYBISON 1 /* Identify Bison output. */
+
+#define yyparse java_parse
+#define yylex java_lex
+#define yyerror java_error
+#define yylval java_lval
+#define yychar java_char
+#define yydebug java_debug
+#define yynerrs java_nerrs
+#define PLUS_TK 258
+#define MINUS_TK 259
+#define MULT_TK 260
+#define DIV_TK 261
+#define REM_TK 262
+#define LS_TK 263
+#define SRS_TK 264
+#define ZRS_TK 265
+#define AND_TK 266
+#define XOR_TK 267
+#define OR_TK 268
+#define BOOL_AND_TK 269
+#define BOOL_OR_TK 270
+#define EQ_TK 271
+#define NEQ_TK 272
+#define GT_TK 273
+#define GTE_TK 274
+#define LT_TK 275
+#define LTE_TK 276
+#define PLUS_ASSIGN_TK 277
+#define MINUS_ASSIGN_TK 278
+#define MULT_ASSIGN_TK 279
+#define DIV_ASSIGN_TK 280
+#define REM_ASSIGN_TK 281
+#define LS_ASSIGN_TK 282
+#define SRS_ASSIGN_TK 283
+#define ZRS_ASSIGN_TK 284
+#define AND_ASSIGN_TK 285
+#define XOR_ASSIGN_TK 286
+#define OR_ASSIGN_TK 287
+#define PUBLIC_TK 288
+#define PRIVATE_TK 289
+#define PROTECTED_TK 290
+#define STATIC_TK 291
+#define FINAL_TK 292
+#define SYNCHRONIZED_TK 293
+#define VOLATILE_TK 294
+#define TRANSIENT_TK 295
+#define NATIVE_TK 296
+#define PAD_TK 297
+#define ABSTRACT_TK 298
+#define MODIFIER_TK 299
+#define DECR_TK 300
+#define INCR_TK 301
+#define DEFAULT_TK 302
+#define IF_TK 303
+#define THROW_TK 304
+#define BOOLEAN_TK 305
+#define DO_TK 306
+#define IMPLEMENTS_TK 307
+#define THROWS_TK 308
+#define BREAK_TK 309
+#define IMPORT_TK 310
+#define ELSE_TK 311
+#define INSTANCEOF_TK 312
+#define RETURN_TK 313
+#define VOID_TK 314
+#define CATCH_TK 315
+#define INTERFACE_TK 316
+#define CASE_TK 317
+#define EXTENDS_TK 318
+#define FINALLY_TK 319
+#define SUPER_TK 320
+#define WHILE_TK 321
+#define CLASS_TK 322
+#define SWITCH_TK 323
+#define CONST_TK 324
+#define TRY_TK 325
+#define FOR_TK 326
+#define NEW_TK 327
+#define CONTINUE_TK 328
+#define GOTO_TK 329
+#define PACKAGE_TK 330
+#define THIS_TK 331
+#define BYTE_TK 332
+#define SHORT_TK 333
+#define INT_TK 334
+#define LONG_TK 335
+#define CHAR_TK 336
+#define INTEGRAL_TK 337
+#define FLOAT_TK 338
+#define DOUBLE_TK 339
+#define FP_TK 340
+#define ID_TK 341
+#define REL_QM_TK 342
+#define REL_CL_TK 343
+#define NOT_TK 344
+#define NEG_TK 345
+#define ASSIGN_ANY_TK 346
+#define ASSIGN_TK 347
+#define OP_TK 348
+#define CP_TK 349
+#define OCB_TK 350
+#define CCB_TK 351
+#define OSB_TK 352
+#define CSB_TK 353
+#define SC_TK 354
+#define C_TK 355
+#define DOT_TK 356
+#define STRING_LIT_TK 357
+#define CHAR_LIT_TK 358
+#define INT_LIT_TK 359
+#define FP_LIT_TK 360
+#define TRUE_TK 361
+#define FALSE_TK 362
+#define BOOL_LIT_TK 363
+#define NULL_TK 364
+
+#line 49 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+#ifdef __STDC__
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+#include "config.h"
+#include "tree.h"
+#include "rtl.h"
+#include "obstack.h"
+#include "flags.h"
+#include "java-tree.h"
+#include "jcf.h"
+#include "lex.h"
+#include "parse.h"
+#include "zipfile.h"
+
+/* Number of error found so far. */
+int java_error_count;
+/* Number of warning found so far. */
+int java_warning_count;
+
+/* The current parser context */
+static struct parser_ctxt *ctxp;
+
+/* binop_lookup maps token to tree_code. It is used where binary
+ operations are involved and required by the parser. RDIV_EXPR
+ covers both integral/floating point division. The code is changed
+ once the type of both operator is worked out. */
+
+static enum tree_code binop_lookup[19] =
+ {
+ PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
+ LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
+ BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
+ TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
+ EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
+ };
+#define BINOP_LOOKUP(VALUE) \
+ binop_lookup [((VALUE) - PLUS_TK)% \
+ (sizeof (binop_lookup) / sizeof (binop_lookup[0]))]
+
+/* Fake WFL used to report error message. It is initialized once if
+ needed and reused with it's location information is overriden. */
+static tree wfl_operator = NULL_TREE;
+
+/* The "$L" identifier we use to create labels. */
+static tree label_id;
+
+#line 104 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+typedef union {
+ tree node;
+ int sub_token;
+ struct {
+ int token;
+ int location;
+ } operator;
+ int value;
+} YYSTYPE;
+#ifndef YYDEBUG
+#define YYDEBUG 1
+#endif
+
+#include <stdio.h>
+
+#ifndef __cplusplus
+#ifndef __STDC__
+#define const
+#endif
+#endif
+
+
+
+#define YYFINAL 772
+#define YYFLAG -32768
+#define YYNTBASE 110
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 364 ? yytranslate[x] : 259)
+
+static const char yytranslate[] = { 0,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+ 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
+ 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
+ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
+ 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
+ 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
+ 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+ 96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
+ 106, 107, 108, 109
+};
+
+#if YYDEBUG != 0
+static const short yyprhs[] = { 0,
+ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18,
+ 20, 22, 24, 26, 28, 30, 32, 34, 38, 42,
+ 46, 50, 54, 56, 58, 60, 64, 66, 67, 69,
+ 71, 73, 76, 79, 82, 86, 88, 91, 93, 96,
+ 100, 103, 107, 109, 111, 115, 118, 122, 128, 133,
+ 139, 141, 143, 145, 147, 149, 152, 153, 161, 162,
+ 169, 173, 176, 180, 185, 186, 189, 193, 196, 197,
+ 200, 203, 205, 209, 213, 216, 220, 222, 225, 227,
+ 229, 231, 233, 235, 237, 239, 241, 245, 250, 252,
+ 256, 260, 262, 266, 270, 275, 277, 281, 284, 288,
+ 292, 294, 296, 297, 301, 304, 308, 312, 317, 322,
+ 325, 329, 332, 336, 339, 343, 348, 352, 356, 360,
+ 362, 366, 370, 373, 377, 380, 384, 385, 388, 391,
+ 393, 397, 401, 403, 406, 408, 411, 415, 417, 421,
+ 426, 431, 437, 441, 446, 449, 453, 457, 462, 467,
+ 473, 481, 488, 490, 492, 493, 498, 499, 505, 506,
+ 512, 513, 520, 524, 529, 532, 536, 539, 543, 546,
+ 550, 552, 555, 557, 559, 561, 563, 565, 568, 571,
+ 574, 578, 582, 587, 589, 593, 597, 600, 601, 606,
+ 608, 611, 613, 615, 617, 620, 623, 627, 629, 631,
+ 633, 635, 637, 639, 641, 643, 645, 647, 649, 651,
+ 653, 655, 657, 659, 661, 663, 665, 667, 669, 671,
+ 673, 676, 679, 682, 685, 688, 691, 694, 697, 701,
+ 706, 711, 717, 722, 728, 735, 743, 750, 752, 754,
+ 756, 758, 760, 762, 764, 770, 773, 777, 782, 790,
+ 798, 804, 807, 811, 817, 820, 824, 828, 833, 835,
+ 838, 841, 843, 846, 850, 853, 856, 860, 863, 868,
+ 871, 874, 878, 883, 886, 888, 896, 904, 911, 915,
+ 921, 926, 934, 941, 944, 947, 951, 954, 955, 957,
+ 959, 962, 963, 965, 967, 971, 975, 978, 982, 985,
+ 989, 992, 996, 999, 1003, 1006, 1010, 1013, 1017, 1021,
+ 1024, 1028, 1034, 1040, 1043, 1048, 1052, 1054, 1058, 1062,
+ 1067, 1070, 1072, 1075, 1081, 1084, 1089, 1093, 1096, 1099,
+ 1101, 1103, 1105, 1107, 1111, 1113, 1115, 1117, 1119, 1123,
+ 1127, 1131, 1135, 1139, 1143, 1147, 1151, 1157, 1162, 1169,
+ 1175, 1180, 1186, 1192, 1199, 1203, 1207, 1212, 1218, 1221,
+ 1225, 1229, 1233, 1235, 1239, 1243, 1247, 1251, 1256, 1261,
+ 1266, 1271, 1275, 1279, 1281, 1284, 1288, 1292, 1295, 1298,
+ 1302, 1306, 1310, 1314, 1317, 1321, 1326, 1332, 1339, 1345,
+ 1352, 1357, 1362, 1367, 1372, 1376, 1381, 1385, 1390, 1392,
+ 1394, 1396, 1398, 1401, 1404, 1406, 1408, 1411, 1414, 1416,
+ 1419, 1422, 1425, 1428, 1431, 1434, 1436, 1439, 1442, 1444,
+ 1447, 1450, 1456, 1461, 1466, 1472, 1477, 1480, 1486, 1491,
+ 1497, 1499, 1503, 1507, 1511, 1515, 1519, 1523, 1525, 1529,
+ 1533, 1537, 1541, 1543, 1547, 1551, 1555, 1559, 1563, 1567,
+ 1569, 1573, 1577, 1581, 1585, 1589, 1593, 1597, 1601, 1605,
+ 1609, 1611, 1615, 1619, 1623, 1627, 1629, 1633, 1637, 1639,
+ 1643, 1647, 1649, 1653, 1657, 1659, 1663, 1667, 1669, 1673,
+ 1677, 1679, 1685, 1690, 1694, 1700, 1702, 1704, 1708, 1712,
+ 1714, 1716, 1718, 1720, 1722, 1724
+};
+
+static const short yyrhs[] = { 123,
+ 0, 104, 0, 105, 0, 108, 0, 103, 0, 102,
+ 0, 109, 0, 113, 0, 114, 0, 82, 0, 85,
+ 0, 50, 0, 115, 0, 118, 0, 119, 0, 115,
+ 0, 115, 0, 113, 97, 98, 0, 119, 97, 98,
+ 0, 118, 97, 98, 0, 113, 97, 1, 0, 118,
+ 97, 1, 0, 120, 0, 121, 0, 122, 0, 119,
+ 101, 122, 0, 86, 0, 0, 126, 0, 124, 0,
+ 125, 0, 126, 124, 0, 126, 125, 0, 124, 125,
+ 0, 126, 124, 125, 0, 127, 0, 124, 127, 0,
+ 130, 0, 125, 130, 0, 75, 119, 99, 0, 75,
+ 1, 0, 75, 119, 1, 0, 128, 0, 129, 0,
+ 55, 119, 99, 0, 55, 1, 0, 55, 119, 1,
+ 0, 55, 119, 101, 5, 99, 0, 55, 119, 101,
+ 1, 0, 55, 119, 101, 5, 1, 0, 132, 0,
+ 163, 0, 99, 0, 1, 0, 44, 0, 131, 44,
+ 0, 0, 131, 67, 122, 135, 136, 133, 138, 0,
+ 0, 67, 122, 135, 136, 134, 138, 0, 131, 67,
+ 1, 0, 67, 1, 0, 67, 122, 1, 0, 131,
+ 67, 122, 1, 0, 0, 63, 116, 0, 63, 116,
+ 1, 0, 63, 1, 0, 0, 52, 137, 0, 52,
+ 1, 0, 117, 0, 137, 100, 117, 0, 137, 100,
+ 1, 0, 95, 96, 0, 95, 139, 96, 0, 140,
+ 0, 139, 140, 0, 141, 0, 156, 0, 158, 0,
+ 176, 0, 142, 0, 147, 0, 132, 0, 163, 0,
+ 112, 143, 99, 0, 131, 112, 143, 99, 0, 144,
+ 0, 143, 100, 144, 0, 143, 100, 1, 0, 145,
+ 0, 145, 92, 146, 0, 145, 92, 1, 0, 145,
+ 92, 146, 1, 0, 122, 0, 145, 97, 98, 0,
+ 122, 1, 0, 145, 97, 1, 0, 145, 98, 1,
+ 0, 257, 0, 174, 0, 0, 149, 148, 155, 0,
+ 149, 1, 0, 112, 150, 153, 0, 59, 150, 153,
+ 0, 131, 112, 150, 153, 0, 131, 59, 150, 153,
+ 0, 112, 1, 0, 131, 112, 1, 0, 59, 1,
+ 0, 131, 59, 1, 0, 131, 1, 0, 122, 93,
+ 94, 0, 122, 93, 151, 94, 0, 150, 97, 98,
+ 0, 122, 93, 1, 0, 150, 97, 1, 0, 152,
+ 0, 151, 100, 152, 0, 151, 100, 1, 0, 112,
+ 145, 0, 131, 112, 145, 0, 112, 1, 0, 131,
+ 112, 1, 0, 0, 53, 154, 0, 53, 1, 0,
+ 116, 0, 154, 100, 116, 0, 154, 100, 1, 0,
+ 176, 0, 176, 99, 0, 99, 0, 157, 176, 0,
+ 157, 176, 99, 0, 44, 0, 159, 153, 160, 0,
+ 131, 159, 153, 160, 0, 159, 153, 160, 99, 0,
+ 131, 159, 153, 160, 99, 0, 120, 93, 94, 0,
+ 120, 93, 151, 94, 0, 95, 96, 0, 95, 161,
+ 96, 0, 95, 178, 96, 0, 95, 161, 178, 96,
+ 0, 162, 93, 94, 99, 0, 162, 93, 226, 94,
+ 99, 0, 119, 101, 65, 93, 226, 94, 99, 0,
+ 119, 101, 65, 93, 94, 99, 0, 76, 0, 65,
+ 0, 0, 61, 122, 164, 169, 0, 0, 131, 61,
+ 122, 165, 169, 0, 0, 61, 122, 168, 166, 169,
+ 0, 0, 131, 61, 122, 168, 167, 169, 0, 61,
+ 122, 1, 0, 131, 61, 122, 1, 0, 63, 117,
+ 0, 168, 100, 117, 0, 63, 1, 0, 168, 100,
+ 1, 0, 95, 96, 0, 95, 170, 96, 0, 171,
+ 0, 170, 171, 0, 172, 0, 173, 0, 132, 0,
+ 163, 0, 142, 0, 149, 99, 0, 149, 1, 0,
+ 95, 96, 0, 95, 175, 96, 0, 95, 100, 96,
+ 0, 95, 175, 100, 96, 0, 146, 0, 175, 100,
+ 146, 0, 175, 100, 1, 0, 95, 96, 0, 0,
+ 95, 177, 178, 96, 0, 179, 0, 178, 179, 0,
+ 180, 0, 182, 0, 132, 0, 181, 99, 0, 112,
+ 143, 0, 131, 112, 143, 0, 184, 0, 187, 0,
+ 191, 0, 192, 0, 201, 0, 205, 0, 184, 0,
+ 188, 0, 193, 0, 202, 0, 206, 0, 176, 0,
+ 185, 0, 189, 0, 194, 0, 204, 0, 212, 0,
+ 213, 0, 214, 0, 216, 0, 215, 0, 218, 0,
+ 99, 0, 122, 88, 0, 186, 182, 0, 122, 1,
+ 0, 186, 183, 0, 190, 99, 0, 1, 99, 0,
+ 1, 95, 0, 1, 96, 0, 162, 93, 1, 0,
+ 162, 93, 94, 1, 0, 162, 93, 226, 1, 0,
+ 162, 93, 226, 94, 1, 0, 119, 101, 65, 1,
+ 0, 119, 101, 65, 93, 1, 0, 119, 101, 65,
+ 93, 226, 1, 0, 119, 101, 65, 93, 226, 94,
+ 1, 0, 119, 101, 65, 93, 94, 1, 0, 254,
+ 0, 238, 0, 239, 0, 235, 0, 236, 0, 232,
+ 0, 224, 0, 48, 93, 257, 94, 182, 0, 48,
+ 1, 0, 48, 93, 1, 0, 48, 93, 257, 1,
+ 0, 48, 93, 257, 94, 183, 56, 182, 0, 48,
+ 93, 257, 94, 183, 56, 183, 0, 68, 93, 257,
+ 94, 195, 0, 68, 1, 0, 68, 93, 1, 0,
+ 68, 93, 257, 94, 1, 0, 95, 96, 0, 95,
+ 198, 96, 0, 95, 196, 96, 0, 95, 196, 198,
+ 96, 0, 197, 0, 196, 197, 0, 198, 178, 0,
+ 199, 0, 198, 199, 0, 62, 258, 88, 0, 47,
+ 88, 0, 62, 1, 0, 62, 258, 1, 0, 47,
+ 1, 0, 66, 93, 257, 94, 0, 200, 182, 0,
+ 66, 1, 0, 66, 93, 1, 0, 66, 93, 257,
+ 1, 0, 200, 183, 0, 51, 0, 203, 182, 66,
+ 93, 257, 94, 99, 0, 208, 99, 257, 99, 210,
+ 94, 182, 0, 208, 99, 99, 210, 94, 182, 0,
+ 208, 99, 1, 0, 208, 99, 257, 99, 1, 0,
+ 208, 99, 99, 1, 0, 208, 99, 257, 99, 210,
+ 94, 183, 0, 208, 99, 99, 210, 94, 183, 0,
+ 71, 93, 0, 71, 1, 0, 71, 93, 1, 0,
+ 207, 209, 0, 0, 211, 0, 181, 0, 211, 1,
+ 0, 0, 211, 0, 190, 0, 211, 100, 190, 0,
+ 211, 100, 1, 0, 54, 99, 0, 54, 122, 99,
+ 0, 54, 1, 0, 54, 122, 1, 0, 73, 99,
+ 0, 73, 122, 99, 0, 73, 1, 0, 73, 122,
+ 1, 0, 58, 99, 0, 58, 257, 99, 0, 58,
+ 1, 0, 58, 257, 1, 0, 49, 257, 99, 0,
+ 49, 1, 0, 49, 257, 1, 0, 217, 93, 257,
+ 94, 176, 0, 217, 93, 257, 94, 1, 0, 217,
+ 1, 0, 217, 93, 1, 94, 0, 217, 93, 1,
+ 0, 44, 0, 70, 176, 219, 0, 70, 176, 221,
+ 0, 70, 176, 219, 221, 0, 70, 1, 0, 220,
+ 0, 219, 220, 0, 60, 93, 152, 94, 176, 0,
+ 60, 1, 0, 60, 93, 1, 94, 0, 60, 93,
+ 1, 0, 64, 176, 0, 64, 1, 0, 223, 0,
+ 227, 0, 111, 0, 76, 0, 93, 257, 94, 0,
+ 224, 0, 231, 0, 232, 0, 233, 0, 119, 101,
+ 67, 0, 113, 101, 67, 0, 59, 101, 67, 0,
+ 119, 101, 76, 0, 93, 257, 1, 0, 119, 101,
+ 1, 0, 113, 101, 1, 0, 59, 101, 1, 0,
+ 72, 116, 93, 226, 94, 0, 72, 116, 93, 94,
+ 0, 72, 116, 93, 226, 94, 138, 0, 72, 116,
+ 93, 94, 138, 0, 225, 122, 93, 94, 0, 225,
+ 122, 93, 94, 138, 0, 225, 122, 93, 226, 94,
+ 0, 225, 122, 93, 226, 94, 138, 0, 72, 1,
+ 99, 0, 72, 116, 1, 0, 72, 116, 93, 1,
+ 0, 72, 116, 93, 226, 1, 0, 225, 1, 0,
+ 225, 122, 1, 0, 119, 101, 72, 0, 222, 101,
+ 72, 0, 257, 0, 226, 100, 257, 0, 226, 100,
+ 1, 0, 72, 113, 228, 0, 72, 115, 228, 0,
+ 72, 113, 228, 230, 0, 72, 115, 228, 230, 0,
+ 72, 115, 230, 174, 0, 72, 113, 230, 174, 0,
+ 72, 1, 98, 0, 72, 1, 97, 0, 229, 0,
+ 228, 229, 0, 97, 257, 98, 0, 97, 257, 1,
+ 0, 97, 1, 0, 97, 98, 0, 230, 97, 98,
+ 0, 230, 97, 1, 0, 222, 101, 122, 0, 65,
+ 101, 122, 0, 65, 1, 0, 119, 93, 94, 0,
+ 119, 93, 226, 94, 0, 222, 101, 122, 93, 94,
+ 0, 222, 101, 122, 93, 226, 94, 0, 65, 101,
+ 122, 93, 94, 0, 65, 101, 122, 93, 226, 94,
+ 0, 65, 101, 1, 94, 0, 65, 101, 1, 101,
+ 0, 119, 97, 257, 98, 0, 223, 97, 257, 98,
+ 0, 119, 97, 1, 0, 119, 97, 257, 1, 0,
+ 223, 97, 1, 0, 223, 97, 257, 1, 0, 222,
+ 0, 119, 0, 235, 0, 236, 0, 234, 46, 0,
+ 234, 45, 0, 238, 0, 239, 0, 3, 237, 0,
+ 4, 237, 0, 240, 0, 3, 1, 0, 4, 1,
+ 0, 46, 237, 0, 46, 1, 0, 45, 237, 0,
+ 45, 1, 0, 234, 0, 89, 237, 0, 90, 237,
+ 0, 241, 0, 89, 1, 0, 90, 1, 0, 93,
+ 113, 230, 94, 237, 0, 93, 113, 94, 237, 0,
+ 93, 257, 94, 240, 0, 93, 119, 230, 94, 240,
+ 0, 93, 113, 97, 1, 0, 93, 1, 0, 93,
+ 113, 230, 94, 1, 0, 93, 113, 94, 1, 0,
+ 93, 119, 230, 94, 1, 0, 237, 0, 242, 5,
+ 237, 0, 242, 6, 237, 0, 242, 7, 237, 0,
+ 242, 5, 1, 0, 242, 6, 1, 0, 242, 7,
+ 1, 0, 242, 0, 243, 3, 242, 0, 243, 4,
+ 242, 0, 243, 3, 1, 0, 243, 4, 1, 0,
+ 243, 0, 244, 8, 243, 0, 244, 9, 243, 0,
+ 244, 10, 243, 0, 244, 8, 1, 0, 244, 9,
+ 1, 0, 244, 10, 1, 0, 244, 0, 245, 20,
+ 244, 0, 245, 18, 244, 0, 245, 21, 244, 0,
+ 245, 19, 244, 0, 245, 57, 114, 0, 245, 20,
+ 1, 0, 245, 18, 1, 0, 245, 21, 1, 0,
+ 245, 19, 1, 0, 245, 57, 1, 0, 245, 0,
+ 246, 16, 245, 0, 246, 17, 245, 0, 246, 16,
+ 1, 0, 246, 17, 1, 0, 246, 0, 247, 11,
+ 246, 0, 247, 11, 1, 0, 247, 0, 248, 12,
+ 247, 0, 248, 12, 1, 0, 248, 0, 249, 13,
+ 248, 0, 249, 13, 1, 0, 249, 0, 250, 14,
+ 249, 0, 250, 14, 1, 0, 250, 0, 251, 15,
+ 250, 0, 251, 15, 1, 0, 251, 0, 251, 87,
+ 257, 88, 252, 0, 251, 87, 88, 1, 0, 251,
+ 87, 1, 0, 251, 87, 257, 88, 1, 0, 252,
+ 0, 254, 0, 255, 256, 253, 0, 255, 256, 1,
+ 0, 119, 0, 231, 0, 233, 0, 91, 0, 92,
+ 0, 253, 0, 257, 0
+};
+
+#endif
+
+#if YYDEBUG != 0
+static const short yyrline[] = { 0,
+ 251, 257, 259, 260, 261, 262, 263, 267, 269, 272,
+ 274, 275, 278, 280, 283, 287, 291, 295, 301, 303,
+ 305, 307, 312, 314, 317, 321, 326, 331, 333, 334,
+ 335, 336, 337, 338, 339, 342, 347, 353, 355, 358,
+ 361, 363, 367, 369, 372, 402, 404, 408, 421, 423,
+ 427, 433, 434, 436, 446, 451, 466, 470, 473, 476,
+ 479, 481, 483, 485, 489, 491, 493, 495, 499, 501,
+ 503, 510, 516, 521, 525, 528, 532, 534, 537, 539,
+ 540, 541, 544, 546, 547, 548, 552, 555, 567, 570,
+ 572, 576, 579, 586, 592, 600, 602, 606, 608, 610,
+ 614, 616, 621, 628, 640, 644, 647, 649, 651, 653,
+ 655, 657, 659, 661, 668, 671, 673, 678, 680, 684,
+ 689, 694, 698, 703, 708, 710, 717, 718, 719, 723,
+ 725, 726, 730, 732, 733, 738, 743, 749, 761, 766,
+ 772, 777, 786, 788, 791, 793, 794, 795, 799, 801,
+ 804, 805, 809, 816, 826, 830, 833, 836, 839, 842,
+ 845, 848, 851, 853, 857, 863, 868, 870, 874, 877,
+ 881, 883, 886, 888, 889, 890, 893, 897, 903, 908,
+ 913, 917, 921, 927, 929, 930, 935, 938, 941, 948,
+ 950, 953, 955, 957, 960, 964, 967, 971, 973, 975,
+ 977, 979, 981, 991, 993, 995, 997, 999, 1003, 1006,
+ 1008, 1010, 1012, 1014, 1016, 1018, 1019, 1021, 1023, 1027,
+ 1032, 1043, 1050, 1054, 1065, 1075, 1081, 1087, 1093, 1095,
+ 1097, 1099, 1101, 1103, 1105, 1107, 1109, 1113, 1115, 1119,
+ 1123, 1127, 1131, 1132, 1138, 1141, 1143, 1145, 1149, 1154,
+ 1159, 1161, 1163, 1165, 1169, 1171, 1172, 1173, 1176, 1178,
+ 1181, 1186, 1188, 1191, 1193, 1194, 1196, 1198, 1202, 1210,
+ 1213, 1215, 1217, 1221, 1226, 1235, 1240, 1243, 1250, 1252,
+ 1254, 1258, 1261, 1270, 1277, 1279, 1283, 1296, 1298, 1304,
+ 1310, 1314, 1316, 1320, 1323, 1325, 1329, 1332, 1334, 1336,
+ 1340, 1343, 1345, 1347, 1351, 1354, 1356, 1358, 1362, 1364,
+ 1366, 1370, 1372, 1374, 1376, 1378, 1382, 1389, 1391, 1392,
+ 1393, 1397, 1399, 1402, 1404, 1406, 1408, 1412, 1414, 1419,
+ 1421, 1424, 1426, 1428, 1430, 1431, 1432, 1433, 1437, 1438,
+ 1439, 1443, 1444, 1446, 1448, 1450, 1454, 1460, 1468, 1470,
+ 1475, 1476, 1477, 1478, 1479, 1481, 1483, 1485, 1487, 1489,
+ 1493, 1495, 1498, 1504, 1509, 1513, 1516, 1518, 1520, 1524,
+ 1526, 1528, 1530, 1534, 1537, 1541, 1547, 1549, 1557, 1560,
+ 1562, 1566, 1569, 1576, 1580, 1583, 1585, 1590, 1595, 1603,
+ 1615, 1617, 1621, 1624, 1626, 1631, 1636, 1641, 1648, 1650,
+ 1651, 1652, 1655, 1660, 1665, 1667, 1668, 1670, 1672, 1673,
+ 1675, 1679, 1682, 1686, 1689, 1693, 1695, 1697, 1699, 1700,
+ 1702, 1706, 1714, 1716, 1718, 1730, 1732, 1738, 1740, 1742,
+ 1746, 1748, 1753, 1758, 1763, 1765, 1767, 1771, 1773, 1778,
+ 1783, 1785, 1789, 1791, 1796, 1801, 1806, 1808, 1810, 1814,
+ 1816, 1821, 1826, 1831, 1836, 1837, 1839, 1841, 1843, 1845,
+ 1849, 1851, 1856, 1861, 1863, 1867, 1869, 1874, 1878, 1880,
+ 1885, 1889, 1891, 1896, 1900, 1902, 1907, 1911, 1913, 1918,
+ 1922, 1924, 1925, 1931, 1933, 1937, 1939, 1942, 1945, 1953,
+ 1955, 1956, 1959, 1961, 1964, 1968
+};
+#endif
+
+
+#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
+
+static const char * const yytname[] = { "$","error","$undefined.","PLUS_TK",
+"MINUS_TK","MULT_TK","DIV_TK","REM_TK","LS_TK","SRS_TK","ZRS_TK","AND_TK","XOR_TK",
+"OR_TK","BOOL_AND_TK","BOOL_OR_TK","EQ_TK","NEQ_TK","GT_TK","GTE_TK","LT_TK",
+"LTE_TK","PLUS_ASSIGN_TK","MINUS_ASSIGN_TK","MULT_ASSIGN_TK","DIV_ASSIGN_TK",
+"REM_ASSIGN_TK","LS_ASSIGN_TK","SRS_ASSIGN_TK","ZRS_ASSIGN_TK","AND_ASSIGN_TK",
+"XOR_ASSIGN_TK","OR_ASSIGN_TK","PUBLIC_TK","PRIVATE_TK","PROTECTED_TK","STATIC_TK",
+"FINAL_TK","SYNCHRONIZED_TK","VOLATILE_TK","TRANSIENT_TK","NATIVE_TK","PAD_TK",
+"ABSTRACT_TK","MODIFIER_TK","DECR_TK","INCR_TK","DEFAULT_TK","IF_TK","THROW_TK",
+"BOOLEAN_TK","DO_TK","IMPLEMENTS_TK","THROWS_TK","BREAK_TK","IMPORT_TK","ELSE_TK",
+"INSTANCEOF_TK","RETURN_TK","VOID_TK","CATCH_TK","INTERFACE_TK","CASE_TK","EXTENDS_TK",
+"FINALLY_TK","SUPER_TK","WHILE_TK","CLASS_TK","SWITCH_TK","CONST_TK","TRY_TK",
+"FOR_TK","NEW_TK","CONTINUE_TK","GOTO_TK","PACKAGE_TK","THIS_TK","BYTE_TK","SHORT_TK",
+"INT_TK","LONG_TK","CHAR_TK","INTEGRAL_TK","FLOAT_TK","DOUBLE_TK","FP_TK","ID_TK",
+"REL_QM_TK","REL_CL_TK","NOT_TK","NEG_TK","ASSIGN_ANY_TK","ASSIGN_TK","OP_TK",
+"CP_TK","OCB_TK","CCB_TK","OSB_TK","CSB_TK","SC_TK","C_TK","DOT_TK","STRING_LIT_TK",
+"CHAR_LIT_TK","INT_LIT_TK","FP_LIT_TK","TRUE_TK","FALSE_TK","BOOL_LIT_TK","NULL_TK",
+"goal","literal","type","primitive_type","reference_type","class_or_interface_type",
+"class_type","interface_type","array_type","name","simple_name","qualified_name",
+"identifier","compilation_unit","import_declarations","type_declarations","package_declaration",
+"import_declaration","single_type_import_declaration","type_import_on_demand_declaration",
+"type_declaration","modifiers","class_declaration","@1","@2","super","interfaces",
+"interface_type_list","class_body","class_body_declarations","class_body_declaration",
+"class_member_declaration","field_declaration","variable_declarators","variable_declarator",
+"variable_declarator_id","variable_initializer","method_declaration","@3","method_header",
+"method_declarator","formal_parameter_list","formal_parameter","throws","class_type_list",
+"method_body","static_initializer","static","constructor_declaration","constructor_declarator",
+"constructor_body","explicit_constructor_invocation","this_or_super","interface_declaration",
+"@4","@5","@6","@7","extends_interfaces","interface_body","interface_member_declarations",
+"interface_member_declaration","constant_declaration","abstract_method_declaration",
+"array_initializer","variable_initializers","block","@8","block_statements",
+"block_statement","local_variable_declaration_statement","local_variable_declaration",
+"statement","statement_nsi","statement_without_trailing_substatement","empty_statement",
+"label_decl","labeled_statement","labeled_statement_nsi","expression_statement",
+"statement_expression","if_then_statement","if_then_else_statement","if_then_else_statement_nsi",
+"switch_statement","switch_block","switch_block_statement_groups","switch_block_statement_group",
+"switch_labels","switch_label","while_expression","while_statement","while_statement_nsi",
+"do_statement_begin","do_statement","for_statement","for_statement_nsi","for_header",
+"for_begin","for_init","for_update","statement_expression_list","break_statement",
+"continue_statement","return_statement","throw_statement","synchronized_statement",
+"synchronized","try_statement","catches","catch_clause","finally","primary",
+"primary_no_new_array","class_instance_creation_expression","something_dot_new",
+"argument_list","array_creation_expression","dim_exprs","dim_expr","dims","field_access",
+"method_invocation","array_access","postfix_expression","post_increment_expression",
+"post_decrement_expression","unary_expression","pre_increment_expression","pre_decrement_expression",
+"unary_expression_not_plus_minus","cast_expression","multiplicative_expression",
+"additive_expression","shift_expression","relational_expression","equality_expression",
+"and_expression","exclusive_or_expression","inclusive_or_expression","conditional_and_expression",
+"conditional_or_expression","conditional_expression","assignment_expression",
+"assignment","left_hand_side","assignment_operator","expression","constant_expression", NULL
+};
+#endif
+
+static const short yyr1[] = { 0,
+ 110, 111, 111, 111, 111, 111, 111, 112, 112, 113,
+ 113, 113, 114, 114, 115, 116, 117, 118, 118, 118,
+ 118, 118, 119, 119, 120, 121, 122, 123, 123, 123,
+ 123, 123, 123, 123, 123, 124, 124, 125, 125, 126,
+ 126, 126, 127, 127, 128, 128, 128, 129, 129, 129,
+ 130, 130, 130, 130, 131, 131, 133, 132, 134, 132,
+ 132, 132, 132, 132, 135, 135, 135, 135, 136, 136,
+ 136, 137, 137, 137, 138, 138, 139, 139, 140, 140,
+ 140, 140, 141, 141, 141, 141, 142, 142, 143, 143,
+ 143, 144, 144, 144, 144, 145, 145, 145, 145, 145,
+ 146, 146, 148, 147, 147, 149, 149, 149, 149, 149,
+ 149, 149, 149, 149, 150, 150, 150, 150, 150, 151,
+ 151, 151, 152, 152, 152, 152, 153, 153, 153, 154,
+ 154, 154, 155, 155, 155, 156, 156, 157, 158, 158,
+ 158, 158, 159, 159, 160, 160, 160, 160, 161, 161,
+ 161, 161, 162, 162, 164, 163, 165, 163, 166, 163,
+ 167, 163, 163, 163, 168, 168, 168, 168, 169, 169,
+ 170, 170, 171, 171, 171, 171, 172, 173, 173, 174,
+ 174, 174, 174, 175, 175, 175, 176, 177, 176, 178,
+ 178, 179, 179, 179, 180, 181, 181, 182, 182, 182,
+ 182, 182, 182, 183, 183, 183, 183, 183, 184, 184,
+ 184, 184, 184, 184, 184, 184, 184, 184, 184, 185,
+ 186, 187, 187, 188, 189, 189, 189, 189, 189, 189,
+ 189, 189, 189, 189, 189, 189, 189, 190, 190, 190,
+ 190, 190, 190, 190, 191, 191, 191, 191, 192, 193,
+ 194, 194, 194, 194, 195, 195, 195, 195, 196, 196,
+ 197, 198, 198, 199, 199, 199, 199, 199, 200, 201,
+ 201, 201, 201, 202, 203, 204, 205, 205, 205, 205,
+ 205, 206, 206, 207, 207, 207, 208, 209, 209, 209,
+ 209, 210, 210, 211, 211, 211, 212, 212, 212, 212,
+ 213, 213, 213, 213, 214, 214, 214, 214, 215, 215,
+ 215, 216, 216, 216, 216, 216, 217, 218, 218, 218,
+ 218, 219, 219, 220, 220, 220, 220, 221, 221, 222,
+ 222, 223, 223, 223, 223, 223, 223, 223, 223, 223,
+ 223, 223, 223, 223, 223, 223, 224, 224, 224, 224,
+ 224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
+ 225, 225, 226, 226, 226, 227, 227, 227, 227, 227,
+ 227, 227, 227, 228, 228, 229, 229, 229, 230, 230,
+ 230, 231, 231, 231, 232, 232, 232, 232, 232, 232,
+ 232, 232, 233, 233, 233, 233, 233, 233, 234, 234,
+ 234, 234, 235, 236, 237, 237, 237, 237, 237, 237,
+ 237, 238, 238, 239, 239, 240, 240, 240, 240, 240,
+ 240, 241, 241, 241, 241, 241, 241, 241, 241, 241,
+ 242, 242, 242, 242, 242, 242, 242, 243, 243, 243,
+ 243, 243, 244, 244, 244, 244, 244, 244, 244, 245,
+ 245, 245, 245, 245, 245, 245, 245, 245, 245, 245,
+ 246, 246, 246, 246, 246, 247, 247, 247, 248, 248,
+ 248, 249, 249, 249, 250, 250, 250, 251, 251, 251,
+ 252, 252, 252, 252, 252, 253, 253, 254, 254, 255,
+ 255, 255, 256, 256, 257, 258
+};
+
+static const short yyr2[] = { 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 3, 3, 3,
+ 3, 3, 1, 1, 1, 3, 1, 0, 1, 1,
+ 1, 2, 2, 2, 3, 1, 2, 1, 2, 3,
+ 2, 3, 1, 1, 3, 2, 3, 5, 4, 5,
+ 1, 1, 1, 1, 1, 2, 0, 7, 0, 6,
+ 3, 2, 3, 4, 0, 2, 3, 2, 0, 2,
+ 2, 1, 3, 3, 2, 3, 1, 2, 1, 1,
+ 1, 1, 1, 1, 1, 1, 3, 4, 1, 3,
+ 3, 1, 3, 3, 4, 1, 3, 2, 3, 3,
+ 1, 1, 0, 3, 2, 3, 3, 4, 4, 2,
+ 3, 2, 3, 2, 3, 4, 3, 3, 3, 1,
+ 3, 3, 2, 3, 2, 3, 0, 2, 2, 1,
+ 3, 3, 1, 2, 1, 2, 3, 1, 3, 4,
+ 4, 5, 3, 4, 2, 3, 3, 4, 4, 5,
+ 7, 6, 1, 1, 0, 4, 0, 5, 0, 5,
+ 0, 6, 3, 4, 2, 3, 2, 3, 2, 3,
+ 1, 2, 1, 1, 1, 1, 1, 2, 2, 2,
+ 3, 3, 4, 1, 3, 3, 2, 0, 4, 1,
+ 2, 1, 1, 1, 2, 2, 3, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 2, 2, 2, 2, 2, 2, 2, 2, 3, 4,
+ 4, 5, 4, 5, 6, 7, 6, 1, 1, 1,
+ 1, 1, 1, 1, 5, 2, 3, 4, 7, 7,
+ 5, 2, 3, 5, 2, 3, 3, 4, 1, 2,
+ 2, 1, 2, 3, 2, 2, 3, 2, 4, 2,
+ 2, 3, 4, 2, 1, 7, 7, 6, 3, 5,
+ 4, 7, 6, 2, 2, 3, 2, 0, 1, 1,
+ 2, 0, 1, 1, 3, 3, 2, 3, 2, 3,
+ 2, 3, 2, 3, 2, 3, 2, 3, 3, 2,
+ 3, 5, 5, 2, 4, 3, 1, 3, 3, 4,
+ 2, 1, 2, 5, 2, 4, 3, 2, 2, 1,
+ 1, 1, 1, 3, 1, 1, 1, 1, 3, 3,
+ 3, 3, 3, 3, 3, 3, 5, 4, 6, 5,
+ 4, 5, 5, 6, 3, 3, 4, 5, 2, 3,
+ 3, 3, 1, 3, 3, 3, 3, 4, 4, 4,
+ 4, 3, 3, 1, 2, 3, 3, 2, 2, 3,
+ 3, 3, 3, 2, 3, 4, 5, 6, 5, 6,
+ 4, 4, 4, 4, 3, 4, 3, 4, 1, 1,
+ 1, 1, 2, 2, 1, 1, 2, 2, 1, 2,
+ 2, 2, 2, 2, 2, 1, 2, 2, 1, 2,
+ 2, 5, 4, 4, 5, 4, 2, 5, 4, 5,
+ 1, 3, 3, 3, 3, 3, 3, 1, 3, 3,
+ 3, 3, 1, 3, 3, 3, 3, 3, 3, 1,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 1, 3, 3, 3, 3, 1, 3, 3, 1, 3,
+ 3, 1, 3, 3, 1, 3, 3, 1, 3, 3,
+ 1, 5, 4, 3, 5, 1, 1, 3, 3, 1,
+ 1, 1, 1, 1, 1, 1
+};
+
+static const short yydefact[] = { 0,
+ 54, 55, 0, 0, 0, 0, 53, 1, 0, 0,
+ 0, 36, 43, 44, 38, 0, 51, 52, 46, 27,
+ 0, 23, 24, 25, 0, 62, 0, 41, 0, 0,
+ 37, 39, 0, 0, 56, 0, 0, 47, 45, 0,
+ 163, 0, 0, 159, 63, 0, 69, 42, 40, 0,
+ 0, 0, 61, 0, 49, 0, 26, 167, 17, 165,
+ 15, 0, 156, 0, 0, 68, 16, 0, 0, 59,
+ 164, 0, 161, 64, 69, 50, 48, 12, 0, 10,
+ 11, 169, 0, 8, 9, 13, 14, 15, 0, 175,
+ 177, 0, 176, 0, 171, 173, 174, 168, 166, 160,
+ 67, 71, 72, 70, 0, 158, 0, 57, 112, 0,
+ 127, 110, 0, 0, 89, 92, 127, 0, 0, 0,
+ 114, 0, 0, 179, 178, 170, 172, 0, 0, 60,
+ 162, 0, 0, 0, 0, 107, 98, 87, 0, 0,
+ 0, 0, 106, 21, 18, 22, 20, 19, 113, 127,
+ 111, 0, 127, 74, 73, 55, 188, 75, 23, 0,
+ 85, 0, 77, 79, 83, 84, 0, 80, 0, 81,
+ 127, 86, 82, 58, 118, 115, 0, 0, 0, 120,
+ 129, 130, 128, 119, 117, 91, 0, 90, 94, 0,
+ 0, 0, 0, 0, 0, 0, 333, 0, 0, 0,
+ 0, 6, 5, 2, 3, 4, 7, 332, 0, 400,
+ 0, 102, 399, 330, 335, 0, 331, 336, 337, 338,
+ 416, 401, 402, 431, 405, 406, 409, 419, 438, 443,
+ 450, 461, 466, 469, 472, 475, 478, 481, 486, 495,
+ 487, 0, 101, 99, 97, 100, 109, 88, 108, 187,
+ 0, 0, 127, 76, 78, 105, 0, 136, 0, 125,
+ 123, 0, 116, 0, 0, 410, 400, 336, 338, 407,
+ 411, 408, 415, 414, 413, 412, 0, 384, 0, 0,
+ 0, 16, 0, 420, 417, 421, 418, 427, 0, 400,
+ 0, 180, 0, 184, 0, 0, 0, 0, 0, 95,
+ 0, 0, 359, 0, 404, 403, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 493, 494, 0,
+ 0, 55, 0, 0, 275, 0, 0, 0, 0, 0,
+ 0, 0, 0, 333, 0, 220, 0, 8, 400, 0,
+ 0, 194, 0, 209, 0, 190, 192, 0, 193, 198,
+ 210, 0, 199, 211, 0, 200, 201, 212, 0, 202,
+ 0, 213, 203, 288, 0, 214, 215, 216, 218, 217,
+ 0, 219, 244, 243, 0, 241, 242, 239, 240, 238,
+ 143, 0, 0, 135, 104, 133, 137, 0, 139, 126,
+ 124, 122, 121, 132, 131, 346, 341, 0, 383, 373,
+ 372, 355, 0, 366, 374, 0, 367, 0, 356, 0,
+ 0, 0, 0, 0, 0, 343, 334, 182, 181, 0,
+ 345, 340, 385, 0, 363, 395, 0, 344, 339, 361,
+ 342, 362, 382, 397, 0, 360, 0, 435, 432, 436,
+ 433, 437, 434, 441, 439, 442, 440, 447, 444, 448,
+ 445, 449, 446, 457, 452, 459, 454, 456, 451, 458,
+ 453, 460, 0, 455, 464, 462, 465, 463, 468, 467,
+ 471, 470, 474, 473, 477, 476, 480, 479, 484, 0,
+ 0, 489, 488, 227, 228, 226, 246, 0, 310, 0,
+ 299, 297, 0, 307, 305, 0, 271, 0, 252, 0,
+ 321, 0, 285, 0, 303, 301, 0, 0, 196, 0,
+ 0, 223, 221, 0, 0, 189, 191, 195, 317, 400,
+ 222, 225, 270, 0, 400, 0, 290, 294, 287, 0,
+ 0, 314, 0, 144, 140, 134, 145, 400, 0, 0,
+ 0, 141, 391, 392, 0, 378, 379, 0, 375, 368,
+ 0, 371, 369, 370, 357, 348, 0, 429, 423, 426,
+ 0, 0, 424, 186, 183, 185, 386, 0, 396, 393,
+ 0, 398, 394, 351, 0, 483, 0, 247, 0, 311,
+ 309, 300, 298, 308, 306, 272, 0, 253, 0, 0,
+ 0, 318, 322, 319, 286, 304, 302, 334, 0, 197,
+ 229, 0, 0, 0, 291, 0, 279, 0, 0, 316,
+ 0, 142, 0, 146, 0, 0, 147, 389, 0, 377,
+ 376, 381, 380, 350, 358, 347, 428, 422, 430, 425,
+ 365, 364, 387, 0, 352, 353, 485, 482, 248, 0,
+ 273, 269, 0, 325, 0, 329, 328, 323, 320, 233,
+ 0, 230, 231, 0, 0, 296, 295, 281, 0, 293,
+ 0, 315, 0, 0, 148, 0, 0, 390, 349, 388,
+ 354, 0, 245, 0, 198, 0, 205, 206, 0, 207,
+ 208, 0, 254, 0, 251, 327, 0, 234, 0, 0,
+ 232, 0, 0, 280, 0, 313, 312, 0, 149, 0,
+ 0, 0, 224, 274, 0, 0, 0, 255, 0, 259,
+ 0, 262, 326, 0, 237, 235, 0, 0, 278, 0,
+ 0, 0, 150, 0, 249, 0, 0, 268, 265, 266,
+ 496, 0, 257, 260, 0, 256, 0, 263, 324, 236,
+ 276, 277, 152, 0, 0, 0, 0, 267, 264, 258,
+ 151, 0, 0, 0, 0, 283, 0, 250, 282, 0,
+ 0, 0
+};
+
+static const short yydefgoto[] = { 770,
+ 208, 347, 209, 85, 86, 68, 60, 87, 210, 22,
+ 23, 24, 8, 9, 10, 11, 12, 13, 14, 15,
+ 351, 352, 132, 105, 47, 70, 104, 130, 162, 163,
+ 164, 91, 114, 115, 116, 211, 166, 257, 92, 111,
+ 179, 180, 136, 183, 395, 168, 169, 170, 171, 399,
+ 549, 353, 18, 43, 72, 65, 107, 44, 63, 94,
+ 95, 96, 97, 212, 295, 354, 251, 747, 356, 357,
+ 358, 359, 684, 360, 361, 362, 363, 687, 364, 365,
+ 366, 367, 688, 368, 695, 719, 720, 721, 722, 369,
+ 370, 690, 371, 372, 373, 691, 374, 375, 539, 669,
+ 670, 376, 377, 378, 379, 380, 381, 382, 602, 603,
+ 604, 213, 214, 215, 216, 434, 217, 414, 415, 416,
+ 218, 219, 220, 221, 222, 223, 224, 225, 226, 227,
+ 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
+ 238, 239, 240, 241, 242, 330, 435, 742
+};
+
+static const short yypact[] = { 353,
+-32768,-32768, 325, -41, 376, 398,-32768,-32768, 164, 528,
+ 436,-32768,-32768,-32768,-32768, 494,-32768,-32768,-32768,-32768,
+ 10,-32768,-32768,-32768, 18,-32768, 297,-32768, 11, 576,
+-32768,-32768, 445, 598,-32768, -41, 428,-32768,-32768, 690,
+-32768, 470, -13, -46,-32768, 495, 82,-32768,-32768, -41,
+ 612, 328,-32768, 381,-32768, 28,-32768,-32768,-32768,-32768,
+ -36, 1021,-32768, 531, -13,-32768,-32768, 232, 577,-32768,
+-32768, -13, -46,-32768, 82,-32768,-32768,-32768, 590,-32768,
+-32768,-32768, 592, 2,-32768,-32768, 170, -7, 916,-32768,
+-32768, 92,-32768, 1055,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768, 172, 202,-32768, -13,-32768,-32768, 262,
+ -1,-32768, 424, -75,-32768, 504, -1, 9, 86, 278,
+-32768, 615, 617,-32768,-32768,-32768,-32768, 637, 936,-32768,
+-32768, 202, 729, 653, 117,-32768,-32768,-32768, 660, 2333,
+ 132, 384,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -1,
+-32768, 655, -1,-32768,-32768, 337, 377,-32768, 417, 916,
+-32768, 1001,-32768,-32768,-32768,-32768, 47,-32768, 406,-32768,
+ 472,-32768,-32768,-32768,-32768,-32768, 667, 903, 551,-32768,
+-32768,-32768, 442,-32768,-32768,-32768, 460,-32768,-32768, 3080,
+ 3145, 3196, 3261, 466, 21, 497,-32768, 3312, 3377, 3428,
+ 5442,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 543, 915,
+ 99,-32768, 548, 560,-32768, 712,-32768, 770,-32768, 836,
+ 888,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 619, 945,
+ 1019, 937, 935, 669, 676, 694, 714, 258,-32768,-32768,
+-32768, 872,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
+ 2125, 731, 472,-32768,-32768,-32768, 128, 634, 668,-32768,
+ 873, 719,-32768, 585, 721,-32768, 673,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768, 25,-32768, 724, 992,
+ 643, 643, 290,-32768,-32768,-32768,-32768,-32768, 746, 962,
+ 208,-32768, 654,-32768, 358, 331, 5509, 3493, 622,-32768,
+ 427, 3544,-32768, 393,-32768,-32768, 3609, 3660, 3725, 3776,
+ 3841, 3892, 3957, 4008, 4073, 4124, 4189, 4240, 525, 4305,
+ 4356, 4421, 4472, 4537, 4588, 4653, 2384,-32768,-32768, 4704,
+ 510, 415, 416, 4769,-32768, 182, 2449, 13, 418, 426,
+ 26, 450, 204, 679, 5741,-32768, -41, 618, 844, 448,
+ 827,-32768, 684,-32768, 1785,-32768,-32768, 685,-32768,-32768,
+-32768, 2193,-32768,-32768, 689,-32768,-32768,-32768, 2193,-32768,
+ 2193,-32768,-32768, 5792, 697,-32768,-32768,-32768,-32768,-32768,
+ 469,-32768, 702, 711, 888, 947, 965,-32768,-32768,-32768,
+-32768, 759, 668,-32768,-32768, 728,-32768, 1853, 732,-32768,
+ 873,-32768,-32768,-32768,-32768,-32768,-32768, 123, 740,-32768,
+-32768,-32768, 2500, 643,-32768, 493, 643, 493,-32768, 2565,
+ 4820, 166, -30, 2616, 308,-32768, 1180,-32768,-32768, 1645,
+-32768,-32768,-32768, 781,-32768,-32768, 239,-32768,-32768,-32768,
+-32768,-32768, 772,-32768, 244,-32768, 5560,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768, 619,-32768, 619,-32768, 945,-32768,
+ 945,-32768, 945,-32768, 1019,-32768, 1019,-32768, 1019,-32768,
+ 1019,-32768, 2,-32768,-32768, 937,-32768, 937,-32768, 935,
+-32768, 669,-32768, 676,-32768, 694,-32768, 714,-32768, 766,
+ 784,-32768,-32768,-32768,-32768,-32768,-32768, 4885,-32768, 143,
+-32768,-32768, 153,-32768,-32768, 180,-32768, 4936,-32768, 5001,
+-32768, 681,-32768, 5350,-32768,-32768, 235, 242, 783, 2681,
+ 620,-32768,-32768, -41, 2732,-32768,-32768,-32768,-32768, 1070,
+-32768,-32768,-32768, 821, 984, 903,-32768,-32768,-32768, 104,
+ 2797,-32768, 5052,-32768, 802,-32768,-32768, 1037, 1921, 812,
+ 1989,-32768,-32768,-32768, 5625,-32768,-32768, 259,-32768, 826,
+ 295,-32768, 826,-32768,-32768, 202, 61,-32768,-32768,-32768,
+ 5117, 817,-32768,-32768,-32768,-32768,-32768, 5168,-32768,-32768,
+ 5676,-32768,-32768, 202, 785,-32768, 5233,-32768, 252,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768, 253,-32768, 845, 471,
+ 46, 681,-32768,-32768,-32768,-32768,-32768,-32768, 473, 783,
+-32768, 941, 122, 851,-32768, 5484,-32768, 5375, 855, 865,
+ 867,-32768, 645,-32768, 2057, 2848,-32768,-32768, 792,-32768,
+-32768,-32768,-32768,-32768,-32768, 202,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768, 814,-32768, 202,-32768,-32768,-32768, 2259,
+-32768,-32768, 87,-32768, 788,-32768,-32768,-32768,-32768,-32768,
+ 2913,-32768,-32768, 972, 5741,-32768,-32768,-32768, 885, 884,
+ 5417,-32768, 206, 478,-32768, 245, 134,-32768,-32768,-32768,
+-32768, 481,-32768, 931, 934, 2259,-32768,-32768, 2259,-32768,
+-32768, 897,-32768, 733,-32768, 905, 910,-32768, 1016, 138,
+-32768, 929, 2193,-32768, 939,-32768,-32768, 2964,-32768, 257,
+ 4885, 2193,-32768,-32768, 3029, 167, 5284,-32768, 739,-32768,
+ 1484,-32768,-32768, 406,-32768,-32768, 1024, 944,-32768, 2193,
+ 273, 150,-32768, 269,-32768, 5375, 948,-32768,-32768,-32768,
+-32768, 212,-32768,-32768, 1571,-32768, 1717,-32768,-32768,-32768,
+-32768,-32768,-32768, 276, 2259, 946, 5417,-32768,-32768,-32768,
+-32768, 974, 2259, 955, 2259,-32768, 2259,-32768,-32768, 1038,
+ 1052,-32768
+};
+
+static const short yypgoto[] = {-32768,
+-32768, -58, 14, 737, 4, -99, 674,-32768, -3, 677,
+-32768, 79,-32768, 1047, 760,-32768, 266,-32768,-32768, 881,
+ 7, 23,-32768,-32768, 1007, 997,-32768, -131,-32768, 912,
+-32768, 281, -121, 928, 431, -195,-32768,-32768, 408, 509,
+ 832, -259, -73,-32768,-32768,-32768,-32768,-32768, 918, 686,
+-32768, 700, -34,-32768,-32768,-32768,-32768, 1040, 508,-32768,
+ 1006,-32768,-32768, 500,-32768, -120,-32768, -221, -340,-32768,
+ 727, -299, 101, -526,-32768, -325,-32768,-32768,-32768, -336,
+-32768,-32768,-32768,-32768,-32768,-32768, 389, 391, -666, -300,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768, -280,-32768, -297,
+ 741,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 511,
+ 517,-32768,-32768, -31,-32768, -369,-32768, 813, 219, -269,
+ 1157, 133, 1187, 279, 423, 486, -20, 569, 607, -419,
+-32768, 703, 819, 534, 699, 799, 801, 803, 800, 816,
+-32768, 552, 815, 695,-32768,-32768, -51,-32768
+};
+
+
+#define YYLAST 5901
+
+
+static const short yytable[] = { 21,
+ 174, 152, 29, 83, 403, 294, 16, 573, 173, 144,
+ 38, 48, 418, 278, 527, 16, 16, 16, 41, 423,
+ 425, 278, 17, 138, 139, 406, 511, 93, 76, 355,
+ 123, 17, 17, 17, 182, 83, 16, 538, 61, 16,
+ 16, 173, 61, 143, 20, 59, 656, 256, 258, 67,
+ 567, 134, 17, 64, 748, 17, 17, 16, 88, 93,
+ 61, 635, 531, 571, 50, 61, 561, 59, 89, 533,
+ 83, 534, 59, 17, 177, 84, 247, 585, 748, 249,
+ 42, 62, 25, 27, 90, 88, 146, 693, 243, 120,
+ 88, 407, 124, 50, 172, 135, 283, 259, 118, 300,
+ 89, 123, 84, 83, 615, -154, 145, 84, 39, 49,
+ 40, 50, -155, 279, 52, 54, 90, 184, 57, 262,
+ 157, 279, 663, 685, 61, 88, 77, 172, 57, 88,
+ 61, 59, 244, 69, 663, 160, 396, 67, 726, 178,
+ 157, -103, 84, 590, 560, -103, 84, 563, 291, 243,
+ 726, 161, 640, 592, 636, 613, 88, 110, 88, 685,
+ 578, 113, 685, -30, 1, 405, 570, 738, 160, 270,
+ 272, 274, 276, 84, 88, 84, 551, 285, 287, 393,
+ 594, 694, 501, 147, 161, 629, 267, 267, 267, 267,
+ 125, 84, 61, 177, 267, 267, 290, -93, -93, 282,
+ 110, 113, -289, 616, 515, 177, 706, 2, 426, 281,
+ 527, 644, 758, 289, 185, 664, 553, 187, 3, 383,
+ 512, 578, 157, 554, 4, 519, 394, 710, 685, 245,
+ 5, 727, 101, 578, 576, 606, 685, 578, 685, 579,
+ 685, 591, 426, 754, 582, 662, 437, 349, 88, 578,
+ 445, 593, 649, 651, 739, 187, 677, 701, 178, 630,
+ 88, 61, 7, 557, 348, 84, 119, 20, 67, 649,
+ 178, 128, 326, 725, 31, 491, 750, 84, 595, 667,
+ 502, 538, 500, -66, 527, 506, 449, 451, 453, 20,
+ 419, 700, 524, 518, 304, 632, 129, 45, 31, 759,
+ 157, 427, 516, 267, 267, 267, 267, 267, 267, 267,
+ 267, 267, 267, 267, 267, 88, 267, 267, 267, 267,
+ 267, 267, 267, 383, 686, 19, -66, 625, 71, 350,
+ 383, 431, 473, 607, 538, 608, 580, 383, 732, 383,
+ 187, 583, 383, 709, 327, 650, 652, 88, -65, 689,
+ 683, 349, -28, 1, 133, 733, 631, 409, 530, 46,
+ 686, 558, 755, 686, 84, 530, 383, 530, 348, 692,
+ 535, 753, 437, 705, 761, 148, 26, 57, 243, 443,
+ 536, 74, 420, 384, 246, 689, 531, 348, 689, 533,
+ 42, -65, 633, 446, 548, 697, 2, 432, 28, 538,
+ 569, 572, 610, 729, 561, 692, 527, 3, 692, 165,
+ 20, 348, 735, 4, 503, -317, 497, 267, 507, 5,
+ 538, 517, -157, 267, 137, 187, 509, 6, 53, 686,
+ 752, -138, -65, 350, 634, -29, 1, 686, 756, 686,
+ 350, 686, 165, 46, -32, 1, 589, 350, 522, 350,
+ 513, 7, 645, 429, 689, 683, 597, 430, 599, 764,
+ 137, 20, 689, 729, 689, 735, 689, 752, 437, 542,
+ 58, 654, 250, 660, 692, -65, 350, 524, 660, 2,
+ 657, 497, 692, 20, 692, 447, 692, 384, 2, 619,
+ 3, 621, -25, -25, 384, 66, 4, 280, 442, 3,
+ 157, 384, 5, 384, 679, 4, 384, -317, 498, 252,
+ 508, 5, 20, 20, 681, -96, 133, 383, 510, 383,
+ -96, -96, -96, -96, 134, 472, 642, -31, 1, 385,
+ 384, 98, 88, -25, 7, 523, 167, 35, -25, -25,
+ -25, 265, 514, 7, -25, 349, 78, 349, -25, 84,
+ 638, -96, 707, -96, 36, 20, -96, -96, -96, -96,
+ 37, 543, 348, 655, 348, 661, 277, 267, 267, 167,
+ 708, 2, 100, 711, 78, -34, 1, 102, 80, 106,
+ 20, 81, 20, 267, 383, 402, 383, 201, 4, 561,
+ 109, 117, 112, 383, 5, 140, 177, -33, 1, 57,
+ 141, 142, 187, 749, 494, 495, 80, 261, 496, 81,
+ 20, -35, 1, 702, 131, 149, 20, 151, 383, 2,
+ 438, 349, 438, 307, 308, 309, 7, 350, 2, 350,
+ 150, 153, 559, 385, 78, 559, 4, 154, 348, 383,
+ 385, 2, 5, 296, 263, 438, 530, 385, 301, 385,
+ 264, 88, 385, 181, 383, 2, 302, 383, 4, 734,
+ 186, 178, 20, 737, 5, 741, 80, 260, 84, 81,
+ 20, 383, 4, 386, 7, 20, 385, 20, 5, 322,
+ 383, 384, 530, 384, 609, 530, 439, 323, 439, 383,
+ 55, 440, 401, 440, 56, 441, 7, 441, 383, 530,
+ 20, 57, 20, 350, 383, 20, 324, 20, 530, 674,
+ 7, 439, 303, 383, 118, 383, 440, 349, 296, 400,
+ 441, 404, 20, 383, 408, 383, 530, 325, 350, 175,
+ 20, 383, 397, 383, 348, 383, 387, 99, 20, 413,
+ 600, 349, 103, 349, 601, 20, -335, -335, 384, 428,
+ 384, 530, 20, 248, 139, -337, -337, 384, 348, 530,
+ 348, 530, 398, 530, 350, 297, 586, 350, 30, 298,
+ 34, -153, 2, 299, 2, 20, 525, 386, 78, 716,
+ 78, 350, 384, 528, 386, 716, 713, 532, 696, 714,
+ 350, 386, 51, 386, 717, 541, 386, 20, -335, 350,
+ 717, 155, -335, 384, 20, 159, 20, -337, 350, 20,
+ 80, -337, 80, 81, 20, 81, 20, 639, 384, 388,
+ 386, 384, 176, 350, 391, 350, 546, 385, 718, 385,
+ 552, 2, 555, 350, 743, 384, 159, 78, 159, 421,
+ 387, 350, 422, 350, 384, 350, 296, 387, 465, 467,
+ 469, 471, 544, 384, 387, 762, 387, 389, 264, 387,
+ -491, -491, 384, 766, 581, 768, 78, 769, 384, 80,
+ 35, 587, 81, 20, 577, 194, 78, 384, 646, 384,
+ 578, 195, 139, 387, 578, 678, 614, 384, 196, 384,
+ 32, 578, 197, 37, 385, 384, 385, 384, 80, 384,
+ 622, 81, 20, 385, 626, 198, 199, 680, 80, 200,
+ 32, 81, 20, 578, 32, 562, 121, 564, 202, 203,
+ 204, 205, 561, 388, 206, 207, -492, -492, 385, -15,
+ 388, 32, 305, 306, -490, -490, 297, 388, 653, 388,
+ 520, 662, 388, 665, 521, 390, 35, 310, 311, 385,
+ 320, 321, 78, 671, 315, 316, 317, 318, 672, 35,
+ 673, 389, 328, 329, 385, 78, 388, 385, 389, 141,
+ 142, 386, 701, 386, 122, 389, 36, 389, 703, 156,
+ 389, 385, 37, 616, 80, 78, 712, 81, 20, -204,
+ 385, -401, -401, 319, 79, 715, 4, 80, 723, 385,
+ 81, 20, 5, 724, 389, -490, -490, 297, 385, -402,
+ -402, 298, 455, 457, 385, 299, 725, 80, 476, 478,
+ 81, 20, 728, 385, 750, 385, 312, 313, 314, 765,
+ 157, 158, 730, 385, 387, 385, 387, 771, 386, 763,
+ 386, 385, 751, 385, 156, 385, 757, 386, 767, 390,
+ 78, 772, -490, -490, 297, 474, 390, 33, 424, 79,
+ 75, 4, 299, 390, 2, 390, 188, 5, 390, -15,
+ 78, 108, 386, 255, -490, -490, 297, 253, 545, 79,
+ 520, 4, 80, 392, 299, 81, 20, 5, 410, 411,
+ 412, 73, 390, 386, 417, 157, 254, 550, 2, 127,
+ 537, 387, 80, 387, 78, 81, 20, 744, 386, 745,
+ 387, 386, 658, 79, 540, 4, 82, 388, 659, 388,
+ 480, 5, -15, 482, 486, 386, 484, -490, -490, 297,
+ 459, 461, 463, 520, 386, 387, 80, 623, 648, 81,
+ 20, 488, 0, 386, 493, 0, 0, 0, 0, 0,
+ 126, 0, 386, 0, 0, 389, 387, 389, 386, 0,
+ -490, -490, 297, 0, 0, 0, 298, 386, 0, 386,
+ 521, 387, 0, 0, 387, 0, 0, 386, 0, 386,
+ 0, 0, 0, 0, 388, 386, 388, 386, 387, 386,
+ 0, 0, 0, 388, 0, 0, 0, 387, 0, 0,
+ 0, 0, 0, 0, 0, 0, 387, 0, 0, 0,
+ 0, 0, 0, 0, 0, 387, 0, 0, 388, 0,
+ 0, 387, 389, 0, 389, 0, 0, 0, 0, 78,
+ 387, 389, 387, 0, 0, 0, 0, 0, 194, 388,
+ 387, 0, 387, 390, 195, 390, 0, 0, 387, 0,
+ 387, 196, 387, 0, 388, 197, 389, 388, 0, 0,
+ 0, 80, 0, 0, 81, 20, 0, 0, 198, 199,
+ 0, 388, 200, 0, 0, 0, 0, 389, 0, 0,
+ 388, 202, 203, 204, 205, 0, 0, 206, 207, 388,
+ 0, 0, 389, 0, 0, 389, 0, 0, 388, 0,
+ 0, 0, 0, 0, 388, 0, 0, 0, 0, 389,
+ 390, 0, 390, 388, 0, 388, 0, 0, 389, 390,
+ 0, 0, 0, 388, 0, 388, 0, 389, 0, 0,
+ 0, 388, 0, 388, 0, 388, 389, 0, 0, 0,
+ 0, 0, 389, 0, 390, 0, 268, 268, 268, 268,
+ 0, 389, 0, 389, 268, 268, 0, 0, 0, 0,
+ 0, 389, 0, 389, 0, 390, 0, 0, 0, 389,
+ 0, 389, 0, 389, 0, 0, 269, 269, 269, 269,
+ 390, 0, 0, 390, 269, 269, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 390, 0, 0,
+ 0, 0, 0, 0, 0, 0, 390, 0, 0, 0,
+ 0, 0, 0, 0, 0, 390, 0, 0, 0, 0,
+ 0, 0, 0, 0, 390, 0, 0, 0, 0, 0,
+ 390, 0, 0, 0, 0, 0, 0, 0, 0, 390,
+ 0, 390, 0, 0, 0, 0, 0, 0, 0, 390,
+ 0, 390, 0, 0, 0, 0, 0, 390, 0, 390,
+ 0, 390, 0, 268, 268, 268, 268, 268, 268, 268,
+ 268, 268, 268, 268, 268, 0, 268, 268, 268, 268,
+ 268, 268, 268, 0, 331, 0, 0, 0, 0, 0,
+ 0, 0, 0, 269, 269, 269, 269, 269, 269, 269,
+ 269, 269, 269, 269, 269, 0, 269, 269, 269, 269,
+ 269, 269, 269, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 332, 192, 193,
+ 716, 333, 334, 78, 335, 0, 0, 336, 0, 0,
+ 0, 337, 194, 0, 0, 717, 0, 0, 338, 339,
+ 5, 340, 0, 341, 342, 196, 343, 0, 0, 344,
+ 0, 0, 0, 0, 0, 80, 0, 0, 81, 20,
+ 0, 331, 0, 0, 0, 0, 345, 268, 157, 746,
+ 0, 0, 346, 268, 0, 202, 203, 204, 205, 0,
+ 0, 206, 207, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 269, 0, 0,
+ 0, 0, 0, 269, 332, 192, 193, 716, 333, 334,
+ 78, 335, 0, 0, 336, 0, 0, 0, 337, 194,
+ 0, 0, 717, 0, 0, 338, 339, 5, 340, 0,
+ 341, 342, 196, 343, 0, 574, 344, 190, 191, 0,
+ 0, 0, 80, 0, 0, 81, 20, 0, 0, 0,
+ 0, 0, 0, 345, 0, 157, 760, 0, 0, 346,
+ 0, 0, 202, 203, 204, 205, 0, 0, 206, 207,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 192,
+ 193, 0, 0, 0, 78, 0, 0, 0, 0, 0,
+ 0, 0, 0, 194, 0, 0, 0, 0, 0, 195,
+ 0, 0, 0, 0, 0, 0, 196, 331, 0, 0,
+ 197, 0, 0, 0, 0, 0, 80, 268, 268, 81,
+ 20, 0, 0, 198, 199, 0, 0, 200, 0, 201,
+ 575, 0, 0, 268, 0, 0, 202, 203, 204, 205,
+ 0, 0, 206, 207, 0, 0, 0, 269, 269, 0,
+ 332, 192, 193, -261, 333, 334, 78, 335, 0, 0,
+ 336, 0, 0, 269, 337, 194, 0, 0, -261, 0,
+ 0, 338, 339, 5, 340, 331, 341, 342, 196, 343,
+ 0, 0, 344, 0, 0, 0, 0, 0, 80, 0,
+ 0, 81, 20, 0, 0, 0, 0, 0, 0, 345,
+ 0, 157, -261, 0, 0, 346, 0, 0, 202, 203,
+ 204, 205, 0, 0, 206, 207, 0, 0, 332, 192,
+ 193, 0, 333, 334, 78, 335, 0, 0, 336, 0,
+ 0, 0, 337, 194, 0, 0, 0, 0, 0, 338,
+ 339, 5, 340, 331, 341, 342, 196, 343, 0, 0,
+ 344, 0, 0, 0, 0, 0, 80, 0, 0, 81,
+ 20, 0, 0, 0, 0, 0, 0, 345, 0, 157,
+ 526, 0, 0, 346, 0, 0, 202, 203, 204, 205,
+ 0, 0, 206, 207, 0, 0, 332, 192, 193, 0,
+ 333, 334, 78, 335, 0, 0, 336, 0, 0, 0,
+ 337, 194, 0, 0, 0, 0, 0, 338, 339, 5,
+ 340, 331, 341, 342, 196, 343, 0, 0, 344, 0,
+ 0, 0, 0, 0, 80, 0, 0, 81, 20, 0,
+ 0, 0, 0, 0, 0, 345, 0, 157, 547, 0,
+ 0, 346, 0, 0, 202, 203, 204, 205, 0, 0,
+ 206, 207, 0, 0, 332, 192, 193, 0, 333, 334,
+ 78, 335, 0, 0, 336, 0, 0, 0, 337, 194,
+ 0, 0, 0, 0, 0, 338, 339, 5, 340, 331,
+ 341, 342, 196, 343, 0, 0, 344, 0, 0, 0,
+ 0, 0, 80, 0, 0, 81, 20, 0, 0, 0,
+ 0, 0, 0, 345, 0, 157, 624, 0, 0, 346,
+ 0, 0, 202, 203, 204, 205, 0, 0, 206, 207,
+ 0, 0, 332, 192, 193, 0, 333, 334, 78, 335,
+ 0, 0, 336, 0, 0, 0, 337, 194, 0, 0,
+ 0, 0, 0, 338, 339, 5, 340, 331, 341, 342,
+ 196, 343, 0, 0, 344, 0, 0, 0, 0, 0,
+ 80, 0, 0, 81, 20, 0, 0, 0, 0, 0,
+ 0, 345, 0, 157, 627, 0, 0, 346, 0, 0,
+ 202, 203, 204, 205, 0, 0, 206, 207, 0, 0,
+ 332, 192, 193, 0, 333, 334, 78, 335, 0, 0,
+ 336, 0, 0, 0, 337, 194, 0, 0, 0, 0,
+ 0, 338, 339, 5, 340, 331, 341, 342, 196, 343,
+ 0, 0, 344, 0, 0, 0, 0, 0, 80, 0,
+ 0, 81, 20, 0, 0, 0, 0, 0, 0, 345,
+ 0, 157, 675, 0, 0, 346, 0, 0, 202, 203,
+ 204, 205, 0, 0, 206, 207, 0, 0, 332, 192,
+ 193, 0, 333, 334, 78, 335, 0, 0, 336, 0,
+ 0, 0, 337, 194, 0, 0, 0, 0, 0, 338,
+ 339, 5, 340, 331, 341, 342, 196, 343, 0, 0,
+ 344, 0, 0, 0, 0, 0, 80, 0, 0, 81,
+ 20, 0, 0, 0, 0, 0, 0, 345, 0, 157,
+ 0, 0, 0, 346, 0, 0, 202, 203, 204, 205,
+ 0, 0, 206, 207, 0, 0, 529, 192, 193, 0,
+ 333, 334, 78, 335, 0, 0, 336, 0, 0, 0,
+ 337, 194, 0, 0, 0, 0, 0, 338, 339, 331,
+ 340, 0, 341, 342, 196, 343, 0, 0, 344, 0,
+ 0, 0, 0, 0, 80, 0, 0, 81, 20, 0,
+ 0, 0, 0, 0, 0, 345, 0, 157, 0, 0,
+ 0, 346, 0, 0, 202, 203, 204, 205, 0, 0,
+ 206, 207, 529, 192, 193, 0, 682, 334, 78, 335,
+ 0, 0, 336, 0, 0, 0, 337, 194, 0, 0,
+ 0, 0, 0, 338, 339, 0, 340, 0, 341, 342,
+ 196, 343, 0, 189, 344, 190, 191, 0, 0, 0,
+ 80, 0, 0, 81, 20, 0, 0, 0, 0, 0,
+ 0, 345, 0, 157, 0, 0, 0, 346, 0, 0,
+ 202, 203, 204, 205, 0, 0, 206, 207, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 192, 193, 0,
+ 0, 0, 78, 0, 489, 0, 190, 191, 0, 0,
+ 0, 194, 0, 0, 0, 0, 0, 195, 0, 0,
+ 0, 0, 0, 0, 196, 0, 0, 0, 197, 0,
+ 0, 0, 0, 0, 80, 0, 0, 81, 20, 0,
+ 0, 198, 199, 0, 0, 200, 0, 201, 192, 193,
+ 0, 0, 0, 78, 202, 203, 204, 205, 0, 0,
+ 206, 207, 194, 0, 0, 0, 0, 0, 195, 504,
+ 0, 190, 191, 0, 0, 196, 0, 0, 0, 197,
+ 0, 0, 0, 0, 0, 80, 0, 0, 81, 20,
+ 0, 490, 198, 199, 0, 0, 200, 0, 0, 0,
+ 0, 0, 0, 0, 0, 202, 203, 204, 205, 0,
+ 0, 206, 207, 192, 193, 0, 0, 0, 78, 0,
+ 556, 0, 190, 191, 0, 0, 0, 194, 0, 0,
+ 0, 0, 0, 195, 0, 0, 0, 0, 0, 0,
+ 196, 0, 0, 0, 197, 0, 0, 0, 0, 0,
+ 80, 0, 0, 81, 20, 0, 0, 198, 199, 0,
+ 0, 200, 0, 0, 192, 193, 0, 505, 0, 78,
+ 202, 203, 204, 205, 0, 0, 206, 207, 194, 0,
+ 0, 0, 0, 0, 195, 565, 0, 190, 191, 0,
+ 0, 196, 0, 0, 0, 197, 0, 0, 0, 0,
+ 0, 80, 0, 0, 81, 20, 0, 0, 198, 199,
+ 0, 0, 200, 0, 0, 0, 0, 557, 0, 0,
+ 0, 202, 203, 204, 205, 0, 0, 206, 207, 192,
+ 193, 0, 0, 0, 78, 0, 436, 0, 190, 191,
+ 0, 0, 0, 194, 0, 0, 0, 0, 0, 195,
+ 0, 0, 0, 0, 0, 0, 196, 0, 0, 0,
+ 197, 0, 0, 0, 0, 0, 80, 0, 0, 81,
+ 20, 0, 0, 198, 199, 0, 0, 200, 566, 0,
+ 192, 193, 0, 0, 0, 78, 202, 203, 204, 205,
+ 0, 0, 206, 207, 194, 0, 0, 0, 0, 0,
+ 195, 436, 0, 190, 191, 0, 0, 196, 0, 0,
+ 0, 197, 0, 0, 0, 0, 0, 80, 0, 0,
+ 81, 20, 0, 0, 198, 199, 0, 0, 200, 0,
+ 0, 0, 0, 557, 0, 0, 0, 202, 203, 204,
+ 205, 0, 0, 206, 207, 192, 193, 0, 0, 0,
+ 78, 0, 611, 0, 190, 191, 0, 0, 0, 194,
+ 0, 0, 0, 0, 0, 195, 0, 0, 0, 0,
+ 0, 0, 196, 0, 0, 0, 197, 0, 0, 0,
+ 0, 0, 80, 0, 0, 81, 20, 0, 0, 198,
+ 199, 0, 0, 200, 0, 0, 192, 193, 148, 0,
+ 0, 78, 202, 203, 204, 205, 0, 0, 206, 207,
+ 194, 0, 0, 0, 0, 0, 195, 617, 0, 190,
+ 191, 0, 0, 196, 0, 0, 0, 197, 0, 0,
+ 0, 0, 0, 80, 0, 0, 81, 20, 0, 0,
+ 198, 199, 0, 0, 200, 612, 0, 0, 0, 0,
+ 0, 0, 0, 202, 203, 204, 205, 0, 0, 206,
+ 207, 192, 193, 0, 0, 0, 78, 0, 611, 0,
+ 190, 191, 0, 0, 0, 194, 0, 0, 0, 0,
+ 0, 195, 0, 0, 0, 0, 0, 0, 196, 0,
+ 0, 0, 197, 0, 0, 0, 0, 0, 80, 0,
+ 0, 81, 20, 0, 0, 198, 199, 0, 0, 200,
+ 0, 0, 192, 193, 0, 618, 0, 78, 202, 203,
+ 204, 205, 0, 0, 206, 207, 194, 0, 0, 0,
+ 0, 0, 195, 698, 0, 190, 191, 0, 0, 196,
+ 0, 0, 0, 197, 0, 0, 0, 0, 0, 80,
+ 0, 0, 81, 20, 0, 0, 198, 199, 0, 0,
+ 200, 676, 0, 0, 0, 0, 0, 0, 0, 202,
+ 203, 204, 205, 0, 0, 206, 207, 192, 193, 0,
+ 0, 0, 78, 0, 698, 0, 190, 191, 0, 0,
+ 0, 194, 0, 0, 0, 0, 0, 195, 0, 0,
+ 0, 0, 0, 0, 196, 0, 0, 0, 197, 0,
+ 0, 0, 0, 0, 80, 0, 0, 81, 20, 0,
+ 0, 198, 199, 0, 0, 200, 699, 0, 192, 193,
+ 0, 0, 0, 78, 202, 203, 204, 205, 0, 0,
+ 206, 207, 194, 0, 0, 0, 0, 0, 195, 617,
+ 0, 190, 191, 0, 0, 196, 0, 0, 0, 197,
+ 0, 0, 0, 0, 0, 80, 0, 0, 81, 20,
+ 0, 0, 198, 199, 0, 0, 200, 731, 0, 0,
+ 0, 0, 0, 0, 0, 202, 203, 204, 205, 0,
+ 0, 206, 207, 192, 193, 0, 0, 0, 78, 0,
+ 266, 0, 190, 191, 0, 0, 0, 194, 0, 0,
+ 0, 0, 0, 195, 0, 0, 0, 0, 0, 0,
+ 196, 0, 0, 0, 197, 0, 0, 0, 0, 0,
+ 80, 0, 0, 81, 20, 0, 0, 198, 199, 0,
+ 0, 200, 0, 0, 192, 193, 0, 736, 0, 78,
+ 202, 203, 204, 205, 0, 0, 206, 207, 194, 0,
+ 0, 0, 0, 0, 195, 271, 0, 190, 191, 0,
+ 0, 196, 0, 0, 0, 197, 0, 0, 0, 0,
+ 0, 80, 0, 0, 81, 20, 0, 0, 198, 199,
+ 0, 0, 200, 0, 0, 0, 0, 0, 0, 0,
+ 0, 202, 203, 204, 205, 0, 0, 206, 207, 192,
+ 193, 0, 0, 0, 78, 0, 273, 0, 190, 191,
+ 0, 0, 0, 194, 0, 0, 0, 0, 0, 195,
+ 0, 0, 0, 0, 0, 0, 196, 0, 0, 0,
+ 197, 0, 0, 0, 0, 0, 80, 0, 0, 81,
+ 20, 0, 0, 198, 199, 0, 0, 200, 0, 0,
+ 192, 193, 0, 0, 0, 78, 202, 203, 204, 205,
+ 0, 0, 206, 207, 194, 0, 0, 0, 0, 0,
+ 195, 275, 0, 190, 191, 0, 0, 196, 0, 0,
+ 0, 197, 0, 0, 0, 0, 0, 80, 0, 0,
+ 81, 20, 0, 0, 198, 199, 0, 0, 200, 0,
+ 0, 0, 0, 0, 0, 0, 0, 202, 203, 204,
+ 205, 0, 0, 206, 207, 192, 193, 0, 0, 0,
+ 78, 0, 284, 0, 190, 191, 0, 0, 0, 194,
+ 0, 0, 0, 0, 0, 195, 0, 0, 0, 0,
+ 0, 0, 196, 0, 0, 0, 197, 0, 0, 0,
+ 0, 0, 80, 0, 0, 81, 20, 0, 0, 198,
+ 199, 0, 0, 200, 0, 0, 192, 193, 0, 0,
+ 0, 78, 202, 203, 204, 205, 0, 0, 206, 207,
+ 194, 0, 0, 0, 0, 0, 195, 286, 0, 190,
+ 191, 0, 0, 196, 0, 0, 0, 197, 0, 0,
+ 0, 0, 0, 80, 0, 0, 81, 20, 0, 0,
+ 198, 199, 0, 0, 200, 0, 0, 0, 0, 0,
+ 0, 0, 0, 202, 203, 204, 205, 0, 0, 206,
+ 207, 192, 193, 0, 0, 0, 78, 0, 288, 0,
+ 190, 191, 0, 0, 0, 194, 0, 0, 0, 0,
+ 0, 195, 0, 0, 0, 0, 0, 0, 196, 0,
+ 0, 0, 197, 0, 0, 0, 0, 0, 80, 0,
+ 0, 81, 20, 0, 0, 198, 199, 0, 0, 200,
+ 0, 0, 192, 193, 0, 0, 0, 78, 202, 203,
+ 204, 205, 0, 0, 206, 207, 194, 0, 0, 0,
+ 0, 0, 195, 436, 0, 190, 191, 0, 0, 196,
+ 0, 0, 0, 197, 0, 0, 0, 0, 0, 80,
+ 0, 0, 81, 20, 0, 0, 198, 199, 0, 0,
+ 200, 0, 0, 0, 0, 0, 0, 0, 0, 202,
+ 203, 204, 205, 0, 0, 206, 207, 192, 193, 0,
+ 0, 0, 78, 0, 444, 0, 190, 191, 0, 0,
+ 0, 194, 0, 0, 0, 0, 0, 195, 0, 0,
+ 0, 0, 0, 0, 196, 0, 0, 0, 197, 0,
+ 0, 0, 0, 0, 80, 0, 0, 81, 20, 0,
+ 0, 198, 199, 0, 0, 200, 0, 0, 192, 193,
+ 0, 0, 0, 78, 202, 203, 204, 205, 0, 0,
+ 206, 207, 194, 0, 0, 0, 0, 0, 195, 448,
+ 0, 190, 191, 0, 0, 196, 0, 0, 0, 197,
+ 0, 0, 0, 0, 0, 80, 0, 0, 81, 20,
+ 0, 0, 198, 199, 0, 0, 200, 0, 0, 0,
+ 0, 0, 0, 0, 0, 202, 203, 204, 205, 0,
+ 0, 206, 207, 192, 193, 0, 0, 0, 78, 0,
+ 450, 0, 190, 191, 0, 0, 0, 194, 0, 0,
+ 0, 0, 0, 195, 0, 0, 0, 0, 0, 0,
+ 196, 0, 0, 0, 197, 0, 0, 0, 0, 0,
+ 80, 0, 0, 81, 20, 0, 0, 198, 199, 0,
+ 0, 200, 0, 0, 192, 193, 0, 0, 0, 78,
+ 202, 203, 204, 205, 0, 0, 206, 207, 194, 0,
+ 0, 0, 0, 0, 195, 452, 0, 190, 191, 0,
+ 0, 196, 0, 0, 0, 197, 0, 0, 0, 0,
+ 0, 80, 0, 0, 81, 20, 0, 0, 198, 199,
+ 0, 0, 200, 0, 0, 0, 0, 0, 0, 0,
+ 0, 202, 203, 204, 205, 0, 0, 206, 207, 192,
+ 193, 0, 0, 0, 78, 0, 454, 0, 190, 191,
+ 0, 0, 0, 194, 0, 0, 0, 0, 0, 195,
+ 0, 0, 0, 0, 0, 0, 196, 0, 0, 0,
+ 197, 0, 0, 0, 0, 0, 80, 0, 0, 81,
+ 20, 0, 0, 198, 199, 0, 0, 200, 0, 0,
+ 192, 193, 0, 0, 0, 78, 202, 203, 204, 205,
+ 0, 0, 206, 207, 194, 0, 0, 0, 0, 0,
+ 195, 456, 0, 190, 191, 0, 0, 196, 0, 0,
+ 0, 197, 0, 0, 0, 0, 0, 80, 0, 0,
+ 81, 20, 0, 0, 198, 199, 0, 0, 200, 0,
+ 0, 0, 0, 0, 0, 0, 0, 202, 203, 204,
+ 205, 0, 0, 206, 207, 192, 193, 0, 0, 0,
+ 78, 0, 458, 0, 190, 191, 0, 0, 0, 194,
+ 0, 0, 0, 0, 0, 195, 0, 0, 0, 0,
+ 0, 0, 196, 0, 0, 0, 197, 0, 0, 0,
+ 0, 0, 80, 0, 0, 81, 20, 0, 0, 198,
+ 199, 0, 0, 200, 0, 0, 192, 193, 0, 0,
+ 0, 78, 202, 203, 204, 205, 0, 0, 206, 207,
+ 194, 0, 0, 0, 0, 0, 195, 460, 0, 190,
+ 191, 0, 0, 196, 0, 0, 0, 197, 0, 0,
+ 0, 0, 0, 80, 0, 0, 81, 20, 0, 0,
+ 198, 199, 0, 0, 200, 0, 0, 0, 0, 0,
+ 0, 0, 0, 202, 203, 204, 205, 0, 0, 206,
+ 207, 192, 193, 0, 0, 0, 78, 0, 462, 0,
+ 190, 191, 0, 0, 0, 194, 0, 0, 0, 0,
+ 0, 195, 0, 0, 0, 0, 0, 0, 196, 0,
+ 0, 0, 197, 0, 0, 0, 0, 0, 80, 0,
+ 0, 81, 20, 0, 0, 198, 199, 0, 0, 200,
+ 0, 0, 192, 193, 0, 0, 0, 78, 202, 203,
+ 204, 205, 0, 0, 206, 207, 194, 0, 0, 0,
+ 0, 0, 195, 464, 0, 190, 191, 0, 0, 196,
+ 0, 0, 0, 197, 0, 0, 0, 0, 0, 80,
+ 0, 0, 81, 20, 0, 0, 198, 199, 0, 0,
+ 200, 0, 0, 0, 0, 0, 0, 0, 0, 202,
+ 203, 204, 205, 0, 0, 206, 207, 192, 193, 0,
+ 0, 0, 78, 0, 466, 0, 190, 191, 0, 0,
+ 0, 194, 0, 0, 0, 0, 0, 195, 0, 0,
+ 0, 0, 0, 0, 196, 0, 0, 0, 197, 0,
+ 0, 0, 0, 0, 80, 0, 0, 81, 20, 0,
+ 0, 198, 199, 0, 0, 200, 0, 0, 192, 193,
+ 0, 0, 0, 78, 202, 203, 204, 205, 0, 0,
+ 206, 207, 194, 0, 0, 0, 0, 0, 195, 468,
+ 0, 190, 191, 0, 0, 196, 0, 0, 0, 197,
+ 0, 0, 0, 0, 0, 80, 0, 0, 81, 20,
+ 0, 0, 198, 199, 0, 0, 200, 0, 0, 0,
+ 0, 0, 0, 0, 0, 202, 203, 204, 205, 0,
+ 0, 206, 207, 192, 193, 0, 0, 0, 78, 0,
+ 470, 0, 190, 191, 0, 0, 0, 194, 0, 0,
+ 0, 0, 0, 195, 0, 0, 0, 0, 0, 0,
+ 196, 0, 0, 0, 197, 0, 0, 0, 0, 0,
+ 80, 0, 0, 81, 20, 0, 0, 198, 199, 0,
+ 0, 200, 0, 0, 192, 193, 0, 0, 0, 78,
+ 202, 203, 204, 205, 0, 0, 206, 207, 194, 0,
+ 0, 0, 0, 0, 195, 475, 0, 190, 191, 0,
+ 0, 196, 0, 0, 0, 197, 0, 0, 0, 0,
+ 0, 80, 0, 0, 81, 20, 0, 0, 198, 199,
+ 0, 0, 200, 0, 0, 0, 0, 0, 0, 0,
+ 0, 202, 203, 204, 205, 0, 0, 206, 207, 192,
+ 193, 0, 0, 0, 78, 0, 477, 0, 190, 191,
+ 0, 0, 0, 194, 0, 0, 0, 0, 0, 195,
+ 0, 0, 0, 0, 0, 0, 196, 0, 0, 0,
+ 197, 0, 0, 0, 0, 0, 80, 0, 0, 81,
+ 20, 0, 0, 198, 199, 0, 0, 200, 0, 0,
+ 192, 193, 0, 0, 0, 78, 202, 203, 204, 205,
+ 0, 0, 206, 207, 194, 0, 0, 0, 0, 0,
+ 195, 479, 0, 190, 191, 0, 0, 196, 0, 0,
+ 0, 197, 0, 0, 0, 0, 0, 80, 0, 0,
+ 81, 20, 0, 0, 198, 199, 0, 0, 200, 0,
+ 0, 0, 0, 0, 0, 0, 0, 202, 203, 204,
+ 205, 0, 0, 206, 207, 192, 193, 0, 0, 0,
+ 78, 0, 481, 0, 190, 191, 0, 0, 0, 194,
+ 0, 0, 0, 0, 0, 195, 0, 0, 0, 0,
+ 0, 0, 196, 0, 0, 0, 197, 0, 0, 0,
+ 0, 0, 80, 0, 0, 81, 20, 0, 0, 198,
+ 199, 0, 0, 200, 0, 0, 192, 193, 0, 0,
+ 0, 78, 202, 203, 204, 205, 0, 0, 206, 207,
+ 194, 0, 0, 0, 0, 0, 195, 483, 0, 190,
+ 191, 0, 0, 196, 0, 0, 0, 197, 0, 0,
+ 0, 0, 0, 80, 0, 0, 81, 20, 0, 0,
+ 198, 199, 0, 0, 200, 0, 0, 0, 0, 0,
+ 0, 0, 0, 202, 203, 204, 205, 0, 0, 206,
+ 207, 192, 193, 0, 0, 0, 78, 0, 485, 0,
+ 190, 191, 0, 0, 0, 194, 0, 0, 0, 0,
+ 0, 195, 0, 0, 0, 0, 0, 0, 196, 0,
+ 0, 0, 197, 0, 0, 0, 0, 0, 80, 0,
+ 0, 81, 20, 0, 0, 198, 199, 0, 0, 200,
+ 0, 0, 192, 193, 0, 0, 0, 78, 202, 203,
+ 204, 205, 0, 0, 206, 207, 194, 0, 0, 0,
+ 0, 0, 195, 487, 0, 190, 191, 0, 0, 196,
+ 0, 0, 0, 197, 0, 0, 0, 0, 0, 80,
+ 0, 0, 81, 20, 0, 0, 198, 199, 0, 0,
+ 200, 0, 0, 0, 0, 0, 0, 0, 0, 202,
+ 203, 204, 205, 0, 0, 206, 207, 192, 193, 0,
+ 0, 0, 78, 0, 492, 0, 190, 191, 0, 0,
+ 0, 194, 0, 0, 0, 0, 0, 195, 0, 0,
+ 0, 0, 0, 0, 196, 0, 0, 0, 197, 0,
+ 0, 0, 0, 0, 80, 0, 0, 81, 20, 0,
+ 0, 198, 199, 0, 0, 200, 0, 0, 192, 193,
+ 0, 0, 0, 78, 202, 203, 204, 205, 0, 0,
+ 206, 207, 194, 0, 0, 0, 0, 0, 195, 499,
+ 0, 190, 191, 0, 0, 196, 0, 0, 0, 197,
+ 0, 0, 0, 0, 0, 80, 0, 0, 81, 20,
+ 0, 0, 198, 199, 0, 0, 200, 0, 0, 0,
+ 0, 0, 0, 0, 0, 202, 203, 204, 205, 0,
+ 0, 206, 207, 192, 193, 0, 0, 0, 78, 0,
+ 568, 0, 190, 191, 0, 0, 0, 194, 0, 0,
+ 0, 0, 0, 195, 0, 0, 0, 0, 0, 0,
+ 196, 0, 0, 0, 197, 0, 0, 0, 0, 0,
+ 80, 0, 0, 81, 20, 0, 0, 198, 199, 0,
+ 0, 200, 0, 0, 192, 193, 0, 0, 0, 78,
+ 202, 203, 204, 205, 0, 0, 206, 207, 194, 0,
+ 0, 0, 0, 0, 195, 588, 0, 190, 191, 0,
+ 0, 196, 0, 0, 0, 197, 0, 0, 0, 0,
+ 0, 80, 0, 0, 81, 20, 0, 0, 198, 199,
+ 0, 0, 200, 0, 0, 0, 0, 0, 0, 0,
+ 0, 202, 203, 204, 205, 0, 0, 206, 207, 192,
+ 193, 0, 0, 0, 78, 0, 596, 0, 190, 191,
+ 0, 0, 0, 194, 0, 0, 0, 0, 0, 195,
+ 0, 0, 0, 0, 0, 0, 196, 0, 0, 0,
+ 197, 0, 0, 0, 0, 0, 80, 0, 0, 81,
+ 20, 0, 0, 198, 199, 0, 0, 200, 0, 0,
+ 192, 193, 0, 0, 0, 78, 202, 203, 204, 205,
+ 0, 0, 206, 207, 194, 0, 0, 0, 0, 0,
+ 195, 598, 0, 190, 191, 0, 0, 196, 0, 0,
+ 0, 197, 0, 0, 0, 0, 0, 80, 0, 0,
+ 81, 20, 0, 0, 198, 199, 0, 0, 200, 0,
+ 0, 0, 0, 0, 0, 0, 0, 202, 203, 204,
+ 205, 0, 0, 206, 207, 192, 193, 0, 0, 0,
+ 78, 0, 620, 0, 190, 191, 0, 0, 0, 194,
+ 0, 0, 0, 0, 0, 195, 0, 0, 0, 0,
+ 0, 0, 196, 0, 0, 0, 197, 0, 0, 0,
+ 0, 0, 80, 0, 0, 81, 20, 0, 0, 198,
+ 199, 0, 0, 200, 0, 0, 192, 193, 0, 0,
+ 0, 78, 202, 203, 204, 205, 0, 0, 206, 207,
+ 194, 0, 0, 0, 0, 0, 195, 637, 0, 190,
+ 191, 0, 0, 196, 0, 0, 0, 197, 0, 0,
+ 0, 0, 0, 80, 0, 0, 81, 20, 0, 0,
+ 198, 199, 0, 0, 200, 0, 0, 0, 0, 0,
+ 0, 0, 0, 202, 203, 204, 205, 0, 0, 206,
+ 207, 192, 193, 0, 0, 0, 78, 0, 641, 0,
+ 190, 191, 0, 0, 0, 194, 0, 0, 0, 0,
+ 0, 195, 0, 0, 0, 0, 0, 0, 196, 0,
+ 0, 0, 197, 0, 0, 0, 0, 0, 80, 0,
+ 0, 81, 20, 0, 0, 198, 199, 0, 0, 200,
+ 0, 0, 192, 193, 0, 0, 0, 78, 202, 203,
+ 204, 205, 0, 0, 206, 207, 194, 0, 0, 0,
+ 0, 0, 195, 647, 0, 190, 191, 0, 0, 196,
+ 0, 0, 0, 197, 0, 0, 0, 0, 0, 80,
+ 0, 0, 81, 20, 0, 0, 198, 199, 0, 0,
+ 200, 0, 0, 0, 0, 0, 0, 0, 0, 202,
+ 203, 204, 205, 0, 0, 206, 207, 192, 193, 0,
+ 0, 0, 78, 0, 740, 0, 190, 191, 0, 0,
+ 0, 194, 0, 0, 0, 0, 0, 195, 0, 0,
+ 0, 0, 0, 0, 196, 0, 0, 0, 197, 0,
+ 0, 0, 0, 0, 80, 0, 0, 81, 20, 0,
+ 0, 198, 199, 0, 0, 200, 0, 0, 192, 193,
+ 0, 0, 0, 78, 202, 203, 204, 205, 0, 0,
+ 206, 207, 194, 0, 0, 0, 0, 0, 195, 0,
+ 605, 0, 0, 0, 0, 196, 0, 0, 0, 197,
+ 0, 0, 0, 0, 0, 80, 0, 0, 81, 20,
+ 0, 0, 198, 199, 0, 668, 200, 0, 0, 0,
+ 0, 0, 0, 0, 0, 202, 203, 204, 205, 0,
+ 0, 206, 207, -284, -284, -284, 0, 0, 0, -284,
+ 0, 0, 0, 0, 0, 0, 0, 0, -284, 0,
+ 0, 0, 0, 0, -284, 0, 0, 704, 0, 192,
+ 193, -284, 0, 0, 78, -284, 0, 0, 0, 0,
+ 0, -284, 0, 194, -284, -284, 0, 0, 0, 195,
+ 0, 0, -284, 0, 190, 191, 196, 0, -284, 0,
+ 197, -284, -284, -284, -284, 0, 80, -284, -284, 81,
+ 20, 192, 193, 0, 0, 0, 78, 345, -292, 0,
+ 0, 0, 0, 0, 0, 194, 202, 203, 204, 205,
+ 0, 195, 206, 207, 666, 0, 192, 193, 196, 0,
+ 0, 78, 197, 0, 0, 0, 0, 0, 80, 0,
+ 194, 81, 20, 0, 0, 0, 195, 0, 0, 345,
+ -292, 190, 191, 196, 0, 0, 0, 197, 202, 203,
+ 204, 205, 0, 80, 206, 207, 81, 20, 192, 193,
+ 198, 199, 0, 78, 200, 0, 201, 292, 0, 0,
+ 0, 293, 194, 202, 203, 204, 205, 0, 195, 206,
+ 207, 0, 0, 192, 193, 196, 0, 0, 78, 197,
+ 0, 0, 190, 191, 0, 80, 0, 194, 81, 20,
+ 0, 0, 0, 195, 0, 0, 345, 0, 0, 0,
+ 196, 0, 0, 0, 197, 202, 203, 204, 205, 0,
+ 80, 206, 207, 81, 20, 0, 0, 198, 199, 0,
+ 0, 200, 433, 0, 192, 193, 0, 0, 0, 78,
+ 202, 203, 204, 205, 0, 0, 206, 207, 194, 0,
+ 0, 0, 0, 0, 195, 0, 0, 190, 191, 0,
+ 0, 196, 0, 0, 0, 197, 0, 0, 0, 0,
+ 0, 80, 0, 0, 81, 20, 0, 0, 198, 199,
+ 0, 0, 200, 584, 0, 0, 0, 0, 0, 0,
+ 0, 202, 203, 204, 205, 0, 0, 206, 207, 192,
+ 193, 0, 0, 0, 78, 0, 0, 0, 190, 191,
+ 0, 0, 0, 194, 0, 0, 0, 0, 0, 195,
+ 0, 0, 0, 0, 0, 0, 196, 0, 0, 0,
+ 197, 0, 0, 0, 0, 0, 80, 0, 0, 81,
+ 20, 0, 0, 198, 199, 0, 0, 200, 628, 0,
+ 192, 193, 0, 0, 0, 78, 202, 203, 204, 205,
+ 0, 0, 206, 207, 194, 0, 0, 0, 0, 0,
+ 195, 0, 0, 190, 191, 0, 0, 196, 0, 0,
+ 0, 197, 0, 0, 0, 0, 0, 80, 0, 0,
+ 81, 20, 0, 0, 198, 199, 0, 0, 200, 643,
+ 0, 0, 0, 0, 0, 0, 0, 202, 203, 204,
+ 205, 0, 0, 206, 207, 192, 193, 0, 0, 0,
+ 78, 0, 0, 0, 0, 0, 0, 0, 0, 194,
+ 0, 0, 0, 0, 0, 195, 0, 0, 0, 0,
+ 0, 0, 196, 0, 0, 0, 197, 0, 0, 0,
+ 0, 0, 80, 0, 0, 81, 20, 0, 0, 198,
+ 199, 0, 0, 200, 0, 2, 192, 193, 0, 0,
+ 0, 78, 202, 203, 204, 205, 0, 0, 206, 207,
+ 194, 0, 0, 0, 0, 0, 195, 0, 0, 0,
+ 0, 0, 0, 196, 0, 0, 0, 197, 0, 0,
+ 0, 0, 0, 80, 0, 0, 81, 20, 0, 0,
+ 0, 0, 0, 0, 345, 0, 0, 0, 0, 0,
+ 0, 0, 0, 202, 203, 204, 205, 0, 0, 206,
+ 207
+};
+
+static const short yycheck[] = { 3,
+ 132, 123, 6, 62, 264, 201, 0, 427, 129, 1,
+ 1, 1, 282, 1, 355, 9, 10, 11, 1, 289,
+ 290, 1, 0, 99, 100, 1, 1, 62, 1, 251,
+ 89, 9, 10, 11, 134, 94, 30, 374, 42, 33,
+ 34, 162, 46, 117, 86, 42, 1, 1, 169, 46,
+ 420, 53, 30, 100, 721, 33, 34, 51, 62, 94,
+ 64, 1, 362, 94, 101, 69, 97, 64, 62, 369,
+ 129, 371, 69, 51, 133, 62, 150, 447, 745, 153,
+ 63, 95, 4, 5, 62, 89, 1, 1, 140, 97,
+ 94, 67, 1, 101, 129, 97, 196, 171, 97, 1,
+ 94, 160, 89, 162, 1, 93, 98, 94, 99, 99,
+ 101, 101, 95, 101, 36, 37, 94, 1, 40, 178,
+ 95, 101, 1, 650, 128, 129, 99, 162, 50, 133,
+ 134, 128, 1, 52, 1, 129, 257, 134, 1, 133,
+ 95, 95, 129, 1, 414, 99, 133, 417, 200, 201,
+ 1, 129, 572, 1, 94, 525, 160, 79, 162, 686,
+ 100, 83, 689, 0, 1, 265, 1, 1, 162, 190,
+ 191, 192, 193, 160, 178, 162, 398, 198, 199, 253,
+ 1, 95, 1, 98, 162, 555, 190, 191, 192, 193,
+ 99, 178, 196, 252, 198, 199, 200, 99, 100, 196,
+ 122, 123, 99, 100, 1, 264, 1, 44, 1, 196,
+ 551, 581, 1, 200, 98, 94, 94, 139, 55, 251,
+ 341, 100, 95, 101, 61, 347, 99, 94, 755, 98,
+ 67, 94, 1, 100, 430, 1, 763, 100, 765, 1,
+ 767, 99, 1, 94, 1, 1, 298, 251, 252, 100,
+ 302, 99, 1, 1, 88, 177, 626, 1, 252, 1,
+ 264, 265, 99, 98, 251, 252, 97, 86, 265, 1,
+ 264, 100, 15, 1, 9, 327, 1, 264, 99, 616,
+ 99, 618, 334, 52, 625, 337, 307, 308, 309, 86,
+ 1, 661, 351, 345, 216, 1, 95, 1, 33, 88,
+ 95, 94, 99, 307, 308, 309, 310, 311, 312, 313,
+ 314, 315, 316, 317, 318, 319, 320, 321, 322, 323,
+ 324, 325, 326, 355, 650, 1, 95, 549, 1, 251,
+ 362, 1, 319, 99, 671, 94, 98, 369, 708, 371,
+ 262, 98, 374, 99, 87, 94, 94, 351, 52, 650,
+ 650, 355, 0, 1, 93, 99, 98, 279, 362, 63,
+ 686, 413, 94, 689, 351, 369, 398, 371, 355, 650,
+ 374, 99, 424, 671, 99, 98, 1, 299, 430, 301,
+ 374, 1, 93, 251, 1, 686, 686, 374, 689, 689,
+ 63, 95, 98, 1, 398, 655, 44, 67, 1, 736,
+ 421, 94, 524, 703, 97, 686, 747, 55, 689, 129,
+ 86, 398, 712, 61, 336, 1, 1, 421, 1, 67,
+ 757, 343, 95, 427, 1, 347, 1, 75, 1, 755,
+ 730, 95, 52, 355, 566, 0, 1, 763, 736, 765,
+ 362, 767, 162, 63, 0, 1, 498, 369, 1, 371,
+ 1, 99, 584, 96, 755, 755, 508, 100, 510, 757,
+ 1, 86, 763, 763, 765, 765, 767, 767, 520, 1,
+ 1, 1, 96, 1, 755, 95, 398, 536, 1, 44,
+ 601, 1, 763, 86, 765, 93, 767, 355, 44, 541,
+ 55, 543, 45, 46, 362, 1, 61, 1, 72, 55,
+ 95, 369, 67, 371, 636, 61, 374, 93, 93, 93,
+ 93, 67, 86, 86, 646, 92, 93, 549, 93, 551,
+ 97, 98, 99, 100, 53, 1, 578, 0, 1, 251,
+ 398, 1, 536, 86, 99, 88, 129, 44, 91, 92,
+ 93, 100, 93, 99, 97, 549, 50, 551, 101, 536,
+ 571, 92, 673, 94, 61, 86, 97, 98, 99, 100,
+ 67, 93, 549, 93, 551, 93, 101, 571, 572, 162,
+ 93, 44, 65, 93, 50, 0, 1, 1, 82, 72,
+ 86, 85, 86, 587, 616, 1, 618, 95, 61, 97,
+ 1, 83, 1, 625, 67, 92, 655, 0, 1, 521,
+ 97, 98, 524, 724, 95, 96, 82, 177, 99, 85,
+ 86, 0, 1, 665, 107, 1, 86, 1, 650, 44,
+ 1, 625, 1, 5, 6, 7, 99, 549, 44, 551,
+ 122, 123, 414, 355, 50, 417, 61, 1, 625, 671,
+ 362, 44, 67, 101, 94, 1, 650, 369, 101, 371,
+ 100, 655, 374, 1, 686, 44, 97, 689, 61, 711,
+ 1, 655, 86, 715, 67, 717, 82, 1, 655, 85,
+ 86, 703, 61, 251, 99, 86, 398, 86, 67, 11,
+ 712, 549, 686, 551, 65, 689, 67, 12, 67, 721,
+ 1, 72, 262, 72, 5, 76, 99, 76, 730, 703,
+ 86, 623, 86, 625, 736, 86, 13, 86, 712, 65,
+ 99, 67, 1, 745, 97, 747, 72, 721, 101, 1,
+ 76, 1, 86, 755, 1, 757, 730, 14, 650, 1,
+ 86, 763, 99, 765, 721, 767, 251, 64, 86, 97,
+ 60, 745, 69, 747, 64, 86, 45, 46, 616, 96,
+ 618, 755, 86, 99, 100, 45, 46, 625, 745, 763,
+ 747, 765, 95, 767, 686, 93, 1, 689, 9, 97,
+ 11, 93, 44, 101, 44, 86, 93, 355, 50, 47,
+ 50, 703, 650, 99, 362, 47, 686, 99, 1, 689,
+ 712, 369, 33, 371, 62, 99, 374, 86, 97, 721,
+ 62, 128, 101, 671, 86, 129, 86, 97, 730, 86,
+ 82, 101, 82, 85, 86, 85, 86, 1, 686, 251,
+ 398, 689, 94, 745, 94, 747, 99, 549, 96, 551,
+ 99, 44, 93, 755, 96, 703, 160, 50, 162, 94,
+ 355, 763, 97, 765, 712, 767, 101, 362, 315, 316,
+ 317, 318, 94, 721, 369, 755, 371, 251, 100, 374,
+ 91, 92, 730, 763, 93, 765, 50, 767, 736, 82,
+ 44, 88, 85, 86, 94, 59, 50, 745, 94, 747,
+ 100, 65, 100, 398, 100, 94, 66, 755, 72, 757,
+ 10, 100, 76, 67, 616, 763, 618, 765, 82, 767,
+ 99, 85, 86, 625, 93, 89, 90, 94, 82, 93,
+ 30, 85, 86, 100, 34, 416, 1, 418, 102, 103,
+ 104, 105, 97, 355, 108, 109, 91, 92, 650, 86,
+ 362, 51, 45, 46, 91, 92, 93, 369, 94, 371,
+ 97, 1, 374, 93, 101, 251, 44, 3, 4, 671,
+ 16, 17, 50, 99, 18, 19, 20, 21, 94, 44,
+ 94, 355, 91, 92, 686, 50, 398, 689, 362, 97,
+ 98, 549, 1, 551, 59, 369, 61, 371, 94, 44,
+ 374, 703, 67, 100, 82, 50, 56, 85, 86, 56,
+ 712, 45, 46, 57, 59, 99, 61, 82, 94, 721,
+ 85, 86, 67, 94, 398, 91, 92, 93, 730, 45,
+ 46, 97, 310, 311, 736, 101, 1, 82, 320, 321,
+ 85, 86, 94, 745, 1, 747, 8, 9, 10, 56,
+ 95, 96, 94, 755, 549, 757, 551, 0, 616, 94,
+ 618, 763, 99, 765, 44, 767, 99, 625, 94, 355,
+ 50, 0, 91, 92, 93, 319, 362, 11, 97, 59,
+ 54, 61, 101, 369, 44, 371, 139, 67, 374, 86,
+ 50, 75, 650, 162, 91, 92, 93, 160, 393, 59,
+ 97, 61, 82, 252, 101, 85, 86, 67, 97, 98,
+ 99, 52, 398, 671, 282, 95, 96, 398, 44, 94,
+ 374, 616, 82, 618, 50, 85, 86, 719, 686, 719,
+ 625, 689, 602, 59, 374, 61, 96, 549, 602, 551,
+ 322, 67, 86, 323, 325, 703, 324, 91, 92, 93,
+ 312, 313, 314, 97, 712, 650, 82, 101, 587, 85,
+ 86, 326, -1, 721, 330, -1, -1, -1, -1, -1,
+ 96, -1, 730, -1, -1, 549, 671, 551, 736, -1,
+ 91, 92, 93, -1, -1, -1, 97, 745, -1, 747,
+ 101, 686, -1, -1, 689, -1, -1, 755, -1, 757,
+ -1, -1, -1, -1, 616, 763, 618, 765, 703, 767,
+ -1, -1, -1, 625, -1, -1, -1, 712, -1, -1,
+ -1, -1, -1, -1, -1, -1, 721, -1, -1, -1,
+ -1, -1, -1, -1, -1, 730, -1, -1, 650, -1,
+ -1, 736, 616, -1, 618, -1, -1, -1, -1, 50,
+ 745, 625, 747, -1, -1, -1, -1, -1, 59, 671,
+ 755, -1, 757, 549, 65, 551, -1, -1, 763, -1,
+ 765, 72, 767, -1, 686, 76, 650, 689, -1, -1,
+ -1, 82, -1, -1, 85, 86, -1, -1, 89, 90,
+ -1, 703, 93, -1, -1, -1, -1, 671, -1, -1,
+ 712, 102, 103, 104, 105, -1, -1, 108, 109, 721,
+ -1, -1, 686, -1, -1, 689, -1, -1, 730, -1,
+ -1, -1, -1, -1, 736, -1, -1, -1, -1, 703,
+ 616, -1, 618, 745, -1, 747, -1, -1, 712, 625,
+ -1, -1, -1, 755, -1, 757, -1, 721, -1, -1,
+ -1, 763, -1, 765, -1, 767, 730, -1, -1, -1,
+ -1, -1, 736, -1, 650, -1, 190, 191, 192, 193,
+ -1, 745, -1, 747, 198, 199, -1, -1, -1, -1,
+ -1, 755, -1, 757, -1, 671, -1, -1, -1, 763,
+ -1, 765, -1, 767, -1, -1, 190, 191, 192, 193,
+ 686, -1, -1, 689, 198, 199, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 703, -1, -1,
+ -1, -1, -1, -1, -1, -1, 712, -1, -1, -1,
+ -1, -1, -1, -1, -1, 721, -1, -1, -1, -1,
+ -1, -1, -1, -1, 730, -1, -1, -1, -1, -1,
+ 736, -1, -1, -1, -1, -1, -1, -1, -1, 745,
+ -1, 747, -1, -1, -1, -1, -1, -1, -1, 755,
+ -1, 757, -1, -1, -1, -1, -1, 763, -1, 765,
+ -1, 767, -1, 307, 308, 309, 310, 311, 312, 313,
+ 314, 315, 316, 317, 318, -1, 320, 321, 322, 323,
+ 324, 325, 326, -1, 1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 307, 308, 309, 310, 311, 312, 313,
+ 314, 315, 316, 317, 318, -1, 320, 321, 322, 323,
+ 324, 325, 326, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 44, 45, 46,
+ 47, 48, 49, 50, 51, -1, -1, 54, -1, -1,
+ -1, 58, 59, -1, -1, 62, -1, -1, 65, 66,
+ 67, 68, -1, 70, 71, 72, 73, -1, -1, 76,
+ -1, -1, -1, -1, -1, 82, -1, -1, 85, 86,
+ -1, 1, -1, -1, -1, -1, 93, 421, 95, 96,
+ -1, -1, 99, 427, -1, 102, 103, 104, 105, -1,
+ -1, 108, 109, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 421, -1, -1,
+ -1, -1, -1, 427, 44, 45, 46, 47, 48, 49,
+ 50, 51, -1, -1, 54, -1, -1, -1, 58, 59,
+ -1, -1, 62, -1, -1, 65, 66, 67, 68, -1,
+ 70, 71, 72, 73, -1, 1, 76, 3, 4, -1,
+ -1, -1, 82, -1, -1, 85, 86, -1, -1, -1,
+ -1, -1, -1, 93, -1, 95, 96, -1, -1, 99,
+ -1, -1, 102, 103, 104, 105, -1, -1, 108, 109,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 45,
+ 46, -1, -1, -1, 50, -1, -1, -1, -1, -1,
+ -1, -1, -1, 59, -1, -1, -1, -1, -1, 65,
+ -1, -1, -1, -1, -1, -1, 72, 1, -1, -1,
+ 76, -1, -1, -1, -1, -1, 82, 571, 572, 85,
+ 86, -1, -1, 89, 90, -1, -1, 93, -1, 95,
+ 96, -1, -1, 587, -1, -1, 102, 103, 104, 105,
+ -1, -1, 108, 109, -1, -1, -1, 571, 572, -1,
+ 44, 45, 46, 47, 48, 49, 50, 51, -1, -1,
+ 54, -1, -1, 587, 58, 59, -1, -1, 62, -1,
+ -1, 65, 66, 67, 68, 1, 70, 71, 72, 73,
+ -1, -1, 76, -1, -1, -1, -1, -1, 82, -1,
+ -1, 85, 86, -1, -1, -1, -1, -1, -1, 93,
+ -1, 95, 96, -1, -1, 99, -1, -1, 102, 103,
+ 104, 105, -1, -1, 108, 109, -1, -1, 44, 45,
+ 46, -1, 48, 49, 50, 51, -1, -1, 54, -1,
+ -1, -1, 58, 59, -1, -1, -1, -1, -1, 65,
+ 66, 67, 68, 1, 70, 71, 72, 73, -1, -1,
+ 76, -1, -1, -1, -1, -1, 82, -1, -1, 85,
+ 86, -1, -1, -1, -1, -1, -1, 93, -1, 95,
+ 96, -1, -1, 99, -1, -1, 102, 103, 104, 105,
+ -1, -1, 108, 109, -1, -1, 44, 45, 46, -1,
+ 48, 49, 50, 51, -1, -1, 54, -1, -1, -1,
+ 58, 59, -1, -1, -1, -1, -1, 65, 66, 67,
+ 68, 1, 70, 71, 72, 73, -1, -1, 76, -1,
+ -1, -1, -1, -1, 82, -1, -1, 85, 86, -1,
+ -1, -1, -1, -1, -1, 93, -1, 95, 96, -1,
+ -1, 99, -1, -1, 102, 103, 104, 105, -1, -1,
+ 108, 109, -1, -1, 44, 45, 46, -1, 48, 49,
+ 50, 51, -1, -1, 54, -1, -1, -1, 58, 59,
+ -1, -1, -1, -1, -1, 65, 66, 67, 68, 1,
+ 70, 71, 72, 73, -1, -1, 76, -1, -1, -1,
+ -1, -1, 82, -1, -1, 85, 86, -1, -1, -1,
+ -1, -1, -1, 93, -1, 95, 96, -1, -1, 99,
+ -1, -1, 102, 103, 104, 105, -1, -1, 108, 109,
+ -1, -1, 44, 45, 46, -1, 48, 49, 50, 51,
+ -1, -1, 54, -1, -1, -1, 58, 59, -1, -1,
+ -1, -1, -1, 65, 66, 67, 68, 1, 70, 71,
+ 72, 73, -1, -1, 76, -1, -1, -1, -1, -1,
+ 82, -1, -1, 85, 86, -1, -1, -1, -1, -1,
+ -1, 93, -1, 95, 96, -1, -1, 99, -1, -1,
+ 102, 103, 104, 105, -1, -1, 108, 109, -1, -1,
+ 44, 45, 46, -1, 48, 49, 50, 51, -1, -1,
+ 54, -1, -1, -1, 58, 59, -1, -1, -1, -1,
+ -1, 65, 66, 67, 68, 1, 70, 71, 72, 73,
+ -1, -1, 76, -1, -1, -1, -1, -1, 82, -1,
+ -1, 85, 86, -1, -1, -1, -1, -1, -1, 93,
+ -1, 95, 96, -1, -1, 99, -1, -1, 102, 103,
+ 104, 105, -1, -1, 108, 109, -1, -1, 44, 45,
+ 46, -1, 48, 49, 50, 51, -1, -1, 54, -1,
+ -1, -1, 58, 59, -1, -1, -1, -1, -1, 65,
+ 66, 67, 68, 1, 70, 71, 72, 73, -1, -1,
+ 76, -1, -1, -1, -1, -1, 82, -1, -1, 85,
+ 86, -1, -1, -1, -1, -1, -1, 93, -1, 95,
+ -1, -1, -1, 99, -1, -1, 102, 103, 104, 105,
+ -1, -1, 108, 109, -1, -1, 44, 45, 46, -1,
+ 48, 49, 50, 51, -1, -1, 54, -1, -1, -1,
+ 58, 59, -1, -1, -1, -1, -1, 65, 66, 1,
+ 68, -1, 70, 71, 72, 73, -1, -1, 76, -1,
+ -1, -1, -1, -1, 82, -1, -1, 85, 86, -1,
+ -1, -1, -1, -1, -1, 93, -1, 95, -1, -1,
+ -1, 99, -1, -1, 102, 103, 104, 105, -1, -1,
+ 108, 109, 44, 45, 46, -1, 48, 49, 50, 51,
+ -1, -1, 54, -1, -1, -1, 58, 59, -1, -1,
+ -1, -1, -1, 65, 66, -1, 68, -1, 70, 71,
+ 72, 73, -1, 1, 76, 3, 4, -1, -1, -1,
+ 82, -1, -1, 85, 86, -1, -1, -1, -1, -1,
+ -1, 93, -1, 95, -1, -1, -1, 99, -1, -1,
+ 102, 103, 104, 105, -1, -1, 108, 109, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 45, 46, -1,
+ -1, -1, 50, -1, 1, -1, 3, 4, -1, -1,
+ -1, 59, -1, -1, -1, -1, -1, 65, -1, -1,
+ -1, -1, -1, -1, 72, -1, -1, -1, 76, -1,
+ -1, -1, -1, -1, 82, -1, -1, 85, 86, -1,
+ -1, 89, 90, -1, -1, 93, -1, 95, 45, 46,
+ -1, -1, -1, 50, 102, 103, 104, 105, -1, -1,
+ 108, 109, 59, -1, -1, -1, -1, -1, 65, 1,
+ -1, 3, 4, -1, -1, 72, -1, -1, -1, 76,
+ -1, -1, -1, -1, -1, 82, -1, -1, 85, 86,
+ -1, 88, 89, 90, -1, -1, 93, -1, -1, -1,
+ -1, -1, -1, -1, -1, 102, 103, 104, 105, -1,
+ -1, 108, 109, 45, 46, -1, -1, -1, 50, -1,
+ 1, -1, 3, 4, -1, -1, -1, 59, -1, -1,
+ -1, -1, -1, 65, -1, -1, -1, -1, -1, -1,
+ 72, -1, -1, -1, 76, -1, -1, -1, -1, -1,
+ 82, -1, -1, 85, 86, -1, -1, 89, 90, -1,
+ -1, 93, -1, -1, 45, 46, -1, 99, -1, 50,
+ 102, 103, 104, 105, -1, -1, 108, 109, 59, -1,
+ -1, -1, -1, -1, 65, 1, -1, 3, 4, -1,
+ -1, 72, -1, -1, -1, 76, -1, -1, -1, -1,
+ -1, 82, -1, -1, 85, 86, -1, -1, 89, 90,
+ -1, -1, 93, -1, -1, -1, -1, 98, -1, -1,
+ -1, 102, 103, 104, 105, -1, -1, 108, 109, 45,
+ 46, -1, -1, -1, 50, -1, 1, -1, 3, 4,
+ -1, -1, -1, 59, -1, -1, -1, -1, -1, 65,
+ -1, -1, -1, -1, -1, -1, 72, -1, -1, -1,
+ 76, -1, -1, -1, -1, -1, 82, -1, -1, 85,
+ 86, -1, -1, 89, 90, -1, -1, 93, 94, -1,
+ 45, 46, -1, -1, -1, 50, 102, 103, 104, 105,
+ -1, -1, 108, 109, 59, -1, -1, -1, -1, -1,
+ 65, 1, -1, 3, 4, -1, -1, 72, -1, -1,
+ -1, 76, -1, -1, -1, -1, -1, 82, -1, -1,
+ 85, 86, -1, -1, 89, 90, -1, -1, 93, -1,
+ -1, -1, -1, 98, -1, -1, -1, 102, 103, 104,
+ 105, -1, -1, 108, 109, 45, 46, -1, -1, -1,
+ 50, -1, 1, -1, 3, 4, -1, -1, -1, 59,
+ -1, -1, -1, -1, -1, 65, -1, -1, -1, -1,
+ -1, -1, 72, -1, -1, -1, 76, -1, -1, -1,
+ -1, -1, 82, -1, -1, 85, 86, -1, -1, 89,
+ 90, -1, -1, 93, -1, -1, 45, 46, 98, -1,
+ -1, 50, 102, 103, 104, 105, -1, -1, 108, 109,
+ 59, -1, -1, -1, -1, -1, 65, 1, -1, 3,
+ 4, -1, -1, 72, -1, -1, -1, 76, -1, -1,
+ -1, -1, -1, 82, -1, -1, 85, 86, -1, -1,
+ 89, 90, -1, -1, 93, 94, -1, -1, -1, -1,
+ -1, -1, -1, 102, 103, 104, 105, -1, -1, 108,
+ 109, 45, 46, -1, -1, -1, 50, -1, 1, -1,
+ 3, 4, -1, -1, -1, 59, -1, -1, -1, -1,
+ -1, 65, -1, -1, -1, -1, -1, -1, 72, -1,
+ -1, -1, 76, -1, -1, -1, -1, -1, 82, -1,
+ -1, 85, 86, -1, -1, 89, 90, -1, -1, 93,
+ -1, -1, 45, 46, -1, 99, -1, 50, 102, 103,
+ 104, 105, -1, -1, 108, 109, 59, -1, -1, -1,
+ -1, -1, 65, 1, -1, 3, 4, -1, -1, 72,
+ -1, -1, -1, 76, -1, -1, -1, -1, -1, 82,
+ -1, -1, 85, 86, -1, -1, 89, 90, -1, -1,
+ 93, 94, -1, -1, -1, -1, -1, -1, -1, 102,
+ 103, 104, 105, -1, -1, 108, 109, 45, 46, -1,
+ -1, -1, 50, -1, 1, -1, 3, 4, -1, -1,
+ -1, 59, -1, -1, -1, -1, -1, 65, -1, -1,
+ -1, -1, -1, -1, 72, -1, -1, -1, 76, -1,
+ -1, -1, -1, -1, 82, -1, -1, 85, 86, -1,
+ -1, 89, 90, -1, -1, 93, 94, -1, 45, 46,
+ -1, -1, -1, 50, 102, 103, 104, 105, -1, -1,
+ 108, 109, 59, -1, -1, -1, -1, -1, 65, 1,
+ -1, 3, 4, -1, -1, 72, -1, -1, -1, 76,
+ -1, -1, -1, -1, -1, 82, -1, -1, 85, 86,
+ -1, -1, 89, 90, -1, -1, 93, 94, -1, -1,
+ -1, -1, -1, -1, -1, 102, 103, 104, 105, -1,
+ -1, 108, 109, 45, 46, -1, -1, -1, 50, -1,
+ 1, -1, 3, 4, -1, -1, -1, 59, -1, -1,
+ -1, -1, -1, 65, -1, -1, -1, -1, -1, -1,
+ 72, -1, -1, -1, 76, -1, -1, -1, -1, -1,
+ 82, -1, -1, 85, 86, -1, -1, 89, 90, -1,
+ -1, 93, -1, -1, 45, 46, -1, 99, -1, 50,
+ 102, 103, 104, 105, -1, -1, 108, 109, 59, -1,
+ -1, -1, -1, -1, 65, 1, -1, 3, 4, -1,
+ -1, 72, -1, -1, -1, 76, -1, -1, -1, -1,
+ -1, 82, -1, -1, 85, 86, -1, -1, 89, 90,
+ -1, -1, 93, -1, -1, -1, -1, -1, -1, -1,
+ -1, 102, 103, 104, 105, -1, -1, 108, 109, 45,
+ 46, -1, -1, -1, 50, -1, 1, -1, 3, 4,
+ -1, -1, -1, 59, -1, -1, -1, -1, -1, 65,
+ -1, -1, -1, -1, -1, -1, 72, -1, -1, -1,
+ 76, -1, -1, -1, -1, -1, 82, -1, -1, 85,
+ 86, -1, -1, 89, 90, -1, -1, 93, -1, -1,
+ 45, 46, -1, -1, -1, 50, 102, 103, 104, 105,
+ -1, -1, 108, 109, 59, -1, -1, -1, -1, -1,
+ 65, 1, -1, 3, 4, -1, -1, 72, -1, -1,
+ -1, 76, -1, -1, -1, -1, -1, 82, -1, -1,
+ 85, 86, -1, -1, 89, 90, -1, -1, 93, -1,
+ -1, -1, -1, -1, -1, -1, -1, 102, 103, 104,
+ 105, -1, -1, 108, 109, 45, 46, -1, -1, -1,
+ 50, -1, 1, -1, 3, 4, -1, -1, -1, 59,
+ -1, -1, -1, -1, -1, 65, -1, -1, -1, -1,
+ -1, -1, 72, -1, -1, -1, 76, -1, -1, -1,
+ -1, -1, 82, -1, -1, 85, 86, -1, -1, 89,
+ 90, -1, -1, 93, -1, -1, 45, 46, -1, -1,
+ -1, 50, 102, 103, 104, 105, -1, -1, 108, 109,
+ 59, -1, -1, -1, -1, -1, 65, 1, -1, 3,
+ 4, -1, -1, 72, -1, -1, -1, 76, -1, -1,
+ -1, -1, -1, 82, -1, -1, 85, 86, -1, -1,
+ 89, 90, -1, -1, 93, -1, -1, -1, -1, -1,
+ -1, -1, -1, 102, 103, 104, 105, -1, -1, 108,
+ 109, 45, 46, -1, -1, -1, 50, -1, 1, -1,
+ 3, 4, -1, -1, -1, 59, -1, -1, -1, -1,
+ -1, 65, -1, -1, -1, -1, -1, -1, 72, -1,
+ -1, -1, 76, -1, -1, -1, -1, -1, 82, -1,
+ -1, 85, 86, -1, -1, 89, 90, -1, -1, 93,
+ -1, -1, 45, 46, -1, -1, -1, 50, 102, 103,
+ 104, 105, -1, -1, 108, 109, 59, -1, -1, -1,
+ -1, -1, 65, 1, -1, 3, 4, -1, -1, 72,
+ -1, -1, -1, 76, -1, -1, -1, -1, -1, 82,
+ -1, -1, 85, 86, -1, -1, 89, 90, -1, -1,
+ 93, -1, -1, -1, -1, -1, -1, -1, -1, 102,
+ 103, 104, 105, -1, -1, 108, 109, 45, 46, -1,
+ -1, -1, 50, -1, 1, -1, 3, 4, -1, -1,
+ -1, 59, -1, -1, -1, -1, -1, 65, -1, -1,
+ -1, -1, -1, -1, 72, -1, -1, -1, 76, -1,
+ -1, -1, -1, -1, 82, -1, -1, 85, 86, -1,
+ -1, 89, 90, -1, -1, 93, -1, -1, 45, 46,
+ -1, -1, -1, 50, 102, 103, 104, 105, -1, -1,
+ 108, 109, 59, -1, -1, -1, -1, -1, 65, 1,
+ -1, 3, 4, -1, -1, 72, -1, -1, -1, 76,
+ -1, -1, -1, -1, -1, 82, -1, -1, 85, 86,
+ -1, -1, 89, 90, -1, -1, 93, -1, -1, -1,
+ -1, -1, -1, -1, -1, 102, 103, 104, 105, -1,
+ -1, 108, 109, 45, 46, -1, -1, -1, 50, -1,
+ 1, -1, 3, 4, -1, -1, -1, 59, -1, -1,
+ -1, -1, -1, 65, -1, -1, -1, -1, -1, -1,
+ 72, -1, -1, -1, 76, -1, -1, -1, -1, -1,
+ 82, -1, -1, 85, 86, -1, -1, 89, 90, -1,
+ -1, 93, -1, -1, 45, 46, -1, -1, -1, 50,
+ 102, 103, 104, 105, -1, -1, 108, 109, 59, -1,
+ -1, -1, -1, -1, 65, 1, -1, 3, 4, -1,
+ -1, 72, -1, -1, -1, 76, -1, -1, -1, -1,
+ -1, 82, -1, -1, 85, 86, -1, -1, 89, 90,
+ -1, -1, 93, -1, -1, -1, -1, -1, -1, -1,
+ -1, 102, 103, 104, 105, -1, -1, 108, 109, 45,
+ 46, -1, -1, -1, 50, -1, 1, -1, 3, 4,
+ -1, -1, -1, 59, -1, -1, -1, -1, -1, 65,
+ -1, -1, -1, -1, -1, -1, 72, -1, -1, -1,
+ 76, -1, -1, -1, -1, -1, 82, -1, -1, 85,
+ 86, -1, -1, 89, 90, -1, -1, 93, -1, -1,
+ 45, 46, -1, -1, -1, 50, 102, 103, 104, 105,
+ -1, -1, 108, 109, 59, -1, -1, -1, -1, -1,
+ 65, 1, -1, 3, 4, -1, -1, 72, -1, -1,
+ -1, 76, -1, -1, -1, -1, -1, 82, -1, -1,
+ 85, 86, -1, -1, 89, 90, -1, -1, 93, -1,
+ -1, -1, -1, -1, -1, -1, -1, 102, 103, 104,
+ 105, -1, -1, 108, 109, 45, 46, -1, -1, -1,
+ 50, -1, 1, -1, 3, 4, -1, -1, -1, 59,
+ -1, -1, -1, -1, -1, 65, -1, -1, -1, -1,
+ -1, -1, 72, -1, -1, -1, 76, -1, -1, -1,
+ -1, -1, 82, -1, -1, 85, 86, -1, -1, 89,
+ 90, -1, -1, 93, -1, -1, 45, 46, -1, -1,
+ -1, 50, 102, 103, 104, 105, -1, -1, 108, 109,
+ 59, -1, -1, -1, -1, -1, 65, 1, -1, 3,
+ 4, -1, -1, 72, -1, -1, -1, 76, -1, -1,
+ -1, -1, -1, 82, -1, -1, 85, 86, -1, -1,
+ 89, 90, -1, -1, 93, -1, -1, -1, -1, -1,
+ -1, -1, -1, 102, 103, 104, 105, -1, -1, 108,
+ 109, 45, 46, -1, -1, -1, 50, -1, 1, -1,
+ 3, 4, -1, -1, -1, 59, -1, -1, -1, -1,
+ -1, 65, -1, -1, -1, -1, -1, -1, 72, -1,
+ -1, -1, 76, -1, -1, -1, -1, -1, 82, -1,
+ -1, 85, 86, -1, -1, 89, 90, -1, -1, 93,
+ -1, -1, 45, 46, -1, -1, -1, 50, 102, 103,
+ 104, 105, -1, -1, 108, 109, 59, -1, -1, -1,
+ -1, -1, 65, 1, -1, 3, 4, -1, -1, 72,
+ -1, -1, -1, 76, -1, -1, -1, -1, -1, 82,
+ -1, -1, 85, 86, -1, -1, 89, 90, -1, -1,
+ 93, -1, -1, -1, -1, -1, -1, -1, -1, 102,
+ 103, 104, 105, -1, -1, 108, 109, 45, 46, -1,
+ -1, -1, 50, -1, 1, -1, 3, 4, -1, -1,
+ -1, 59, -1, -1, -1, -1, -1, 65, -1, -1,
+ -1, -1, -1, -1, 72, -1, -1, -1, 76, -1,
+ -1, -1, -1, -1, 82, -1, -1, 85, 86, -1,
+ -1, 89, 90, -1, -1, 93, -1, -1, 45, 46,
+ -1, -1, -1, 50, 102, 103, 104, 105, -1, -1,
+ 108, 109, 59, -1, -1, -1, -1, -1, 65, 1,
+ -1, 3, 4, -1, -1, 72, -1, -1, -1, 76,
+ -1, -1, -1, -1, -1, 82, -1, -1, 85, 86,
+ -1, -1, 89, 90, -1, -1, 93, -1, -1, -1,
+ -1, -1, -1, -1, -1, 102, 103, 104, 105, -1,
+ -1, 108, 109, 45, 46, -1, -1, -1, 50, -1,
+ 1, -1, 3, 4, -1, -1, -1, 59, -1, -1,
+ -1, -1, -1, 65, -1, -1, -1, -1, -1, -1,
+ 72, -1, -1, -1, 76, -1, -1, -1, -1, -1,
+ 82, -1, -1, 85, 86, -1, -1, 89, 90, -1,
+ -1, 93, -1, -1, 45, 46, -1, -1, -1, 50,
+ 102, 103, 104, 105, -1, -1, 108, 109, 59, -1,
+ -1, -1, -1, -1, 65, 1, -1, 3, 4, -1,
+ -1, 72, -1, -1, -1, 76, -1, -1, -1, -1,
+ -1, 82, -1, -1, 85, 86, -1, -1, 89, 90,
+ -1, -1, 93, -1, -1, -1, -1, -1, -1, -1,
+ -1, 102, 103, 104, 105, -1, -1, 108, 109, 45,
+ 46, -1, -1, -1, 50, -1, 1, -1, 3, 4,
+ -1, -1, -1, 59, -1, -1, -1, -1, -1, 65,
+ -1, -1, -1, -1, -1, -1, 72, -1, -1, -1,
+ 76, -1, -1, -1, -1, -1, 82, -1, -1, 85,
+ 86, -1, -1, 89, 90, -1, -1, 93, -1, -1,
+ 45, 46, -1, -1, -1, 50, 102, 103, 104, 105,
+ -1, -1, 108, 109, 59, -1, -1, -1, -1, -1,
+ 65, 1, -1, 3, 4, -1, -1, 72, -1, -1,
+ -1, 76, -1, -1, -1, -1, -1, 82, -1, -1,
+ 85, 86, -1, -1, 89, 90, -1, -1, 93, -1,
+ -1, -1, -1, -1, -1, -1, -1, 102, 103, 104,
+ 105, -1, -1, 108, 109, 45, 46, -1, -1, -1,
+ 50, -1, 1, -1, 3, 4, -1, -1, -1, 59,
+ -1, -1, -1, -1, -1, 65, -1, -1, -1, -1,
+ -1, -1, 72, -1, -1, -1, 76, -1, -1, -1,
+ -1, -1, 82, -1, -1, 85, 86, -1, -1, 89,
+ 90, -1, -1, 93, -1, -1, 45, 46, -1, -1,
+ -1, 50, 102, 103, 104, 105, -1, -1, 108, 109,
+ 59, -1, -1, -1, -1, -1, 65, 1, -1, 3,
+ 4, -1, -1, 72, -1, -1, -1, 76, -1, -1,
+ -1, -1, -1, 82, -1, -1, 85, 86, -1, -1,
+ 89, 90, -1, -1, 93, -1, -1, -1, -1, -1,
+ -1, -1, -1, 102, 103, 104, 105, -1, -1, 108,
+ 109, 45, 46, -1, -1, -1, 50, -1, 1, -1,
+ 3, 4, -1, -1, -1, 59, -1, -1, -1, -1,
+ -1, 65, -1, -1, -1, -1, -1, -1, 72, -1,
+ -1, -1, 76, -1, -1, -1, -1, -1, 82, -1,
+ -1, 85, 86, -1, -1, 89, 90, -1, -1, 93,
+ -1, -1, 45, 46, -1, -1, -1, 50, 102, 103,
+ 104, 105, -1, -1, 108, 109, 59, -1, -1, -1,
+ -1, -1, 65, 1, -1, 3, 4, -1, -1, 72,
+ -1, -1, -1, 76, -1, -1, -1, -1, -1, 82,
+ -1, -1, 85, 86, -1, -1, 89, 90, -1, -1,
+ 93, -1, -1, -1, -1, -1, -1, -1, -1, 102,
+ 103, 104, 105, -1, -1, 108, 109, 45, 46, -1,
+ -1, -1, 50, -1, 1, -1, 3, 4, -1, -1,
+ -1, 59, -1, -1, -1, -1, -1, 65, -1, -1,
+ -1, -1, -1, -1, 72, -1, -1, -1, 76, -1,
+ -1, -1, -1, -1, 82, -1, -1, 85, 86, -1,
+ -1, 89, 90, -1, -1, 93, -1, -1, 45, 46,
+ -1, -1, -1, 50, 102, 103, 104, 105, -1, -1,
+ 108, 109, 59, -1, -1, -1, -1, -1, 65, 1,
+ -1, 3, 4, -1, -1, 72, -1, -1, -1, 76,
+ -1, -1, -1, -1, -1, 82, -1, -1, 85, 86,
+ -1, -1, 89, 90, -1, -1, 93, -1, -1, -1,
+ -1, -1, -1, -1, -1, 102, 103, 104, 105, -1,
+ -1, 108, 109, 45, 46, -1, -1, -1, 50, -1,
+ 1, -1, 3, 4, -1, -1, -1, 59, -1, -1,
+ -1, -1, -1, 65, -1, -1, -1, -1, -1, -1,
+ 72, -1, -1, -1, 76, -1, -1, -1, -1, -1,
+ 82, -1, -1, 85, 86, -1, -1, 89, 90, -1,
+ -1, 93, -1, -1, 45, 46, -1, -1, -1, 50,
+ 102, 103, 104, 105, -1, -1, 108, 109, 59, -1,
+ -1, -1, -1, -1, 65, 1, -1, 3, 4, -1,
+ -1, 72, -1, -1, -1, 76, -1, -1, -1, -1,
+ -1, 82, -1, -1, 85, 86, -1, -1, 89, 90,
+ -1, -1, 93, -1, -1, -1, -1, -1, -1, -1,
+ -1, 102, 103, 104, 105, -1, -1, 108, 109, 45,
+ 46, -1, -1, -1, 50, -1, 1, -1, 3, 4,
+ -1, -1, -1, 59, -1, -1, -1, -1, -1, 65,
+ -1, -1, -1, -1, -1, -1, 72, -1, -1, -1,
+ 76, -1, -1, -1, -1, -1, 82, -1, -1, 85,
+ 86, -1, -1, 89, 90, -1, -1, 93, -1, -1,
+ 45, 46, -1, -1, -1, 50, 102, 103, 104, 105,
+ -1, -1, 108, 109, 59, -1, -1, -1, -1, -1,
+ 65, 1, -1, 3, 4, -1, -1, 72, -1, -1,
+ -1, 76, -1, -1, -1, -1, -1, 82, -1, -1,
+ 85, 86, -1, -1, 89, 90, -1, -1, 93, -1,
+ -1, -1, -1, -1, -1, -1, -1, 102, 103, 104,
+ 105, -1, -1, 108, 109, 45, 46, -1, -1, -1,
+ 50, -1, 1, -1, 3, 4, -1, -1, -1, 59,
+ -1, -1, -1, -1, -1, 65, -1, -1, -1, -1,
+ -1, -1, 72, -1, -1, -1, 76, -1, -1, -1,
+ -1, -1, 82, -1, -1, 85, 86, -1, -1, 89,
+ 90, -1, -1, 93, -1, -1, 45, 46, -1, -1,
+ -1, 50, 102, 103, 104, 105, -1, -1, 108, 109,
+ 59, -1, -1, -1, -1, -1, 65, 1, -1, 3,
+ 4, -1, -1, 72, -1, -1, -1, 76, -1, -1,
+ -1, -1, -1, 82, -1, -1, 85, 86, -1, -1,
+ 89, 90, -1, -1, 93, -1, -1, -1, -1, -1,
+ -1, -1, -1, 102, 103, 104, 105, -1, -1, 108,
+ 109, 45, 46, -1, -1, -1, 50, -1, 1, -1,
+ 3, 4, -1, -1, -1, 59, -1, -1, -1, -1,
+ -1, 65, -1, -1, -1, -1, -1, -1, 72, -1,
+ -1, -1, 76, -1, -1, -1, -1, -1, 82, -1,
+ -1, 85, 86, -1, -1, 89, 90, -1, -1, 93,
+ -1, -1, 45, 46, -1, -1, -1, 50, 102, 103,
+ 104, 105, -1, -1, 108, 109, 59, -1, -1, -1,
+ -1, -1, 65, 1, -1, 3, 4, -1, -1, 72,
+ -1, -1, -1, 76, -1, -1, -1, -1, -1, 82,
+ -1, -1, 85, 86, -1, -1, 89, 90, -1, -1,
+ 93, -1, -1, -1, -1, -1, -1, -1, -1, 102,
+ 103, 104, 105, -1, -1, 108, 109, 45, 46, -1,
+ -1, -1, 50, -1, 1, -1, 3, 4, -1, -1,
+ -1, 59, -1, -1, -1, -1, -1, 65, -1, -1,
+ -1, -1, -1, -1, 72, -1, -1, -1, 76, -1,
+ -1, -1, -1, -1, 82, -1, -1, 85, 86, -1,
+ -1, 89, 90, -1, -1, 93, -1, -1, 45, 46,
+ -1, -1, -1, 50, 102, 103, 104, 105, -1, -1,
+ 108, 109, 59, -1, -1, -1, -1, -1, 65, -1,
+ 1, -1, -1, -1, -1, 72, -1, -1, -1, 76,
+ -1, -1, -1, -1, -1, 82, -1, -1, 85, 86,
+ -1, -1, 89, 90, -1, 1, 93, -1, -1, -1,
+ -1, -1, -1, -1, -1, 102, 103, 104, 105, -1,
+ -1, 108, 109, 44, 45, 46, -1, -1, -1, 50,
+ -1, -1, -1, -1, -1, -1, -1, -1, 59, -1,
+ -1, -1, -1, -1, 65, -1, -1, 1, -1, 45,
+ 46, 72, -1, -1, 50, 76, -1, -1, -1, -1,
+ -1, 82, -1, 59, 85, 86, -1, -1, -1, 65,
+ -1, -1, 93, -1, 3, 4, 72, -1, 99, -1,
+ 76, 102, 103, 104, 105, -1, 82, 108, 109, 85,
+ 86, 45, 46, -1, -1, -1, 50, 93, 94, -1,
+ -1, -1, -1, -1, -1, 59, 102, 103, 104, 105,
+ -1, 65, 108, 109, 1, -1, 45, 46, 72, -1,
+ -1, 50, 76, -1, -1, -1, -1, -1, 82, -1,
+ 59, 85, 86, -1, -1, -1, 65, -1, -1, 93,
+ 94, 3, 4, 72, -1, -1, -1, 76, 102, 103,
+ 104, 105, -1, 82, 108, 109, 85, 86, 45, 46,
+ 89, 90, -1, 50, 93, -1, 95, 96, -1, -1,
+ -1, 100, 59, 102, 103, 104, 105, -1, 65, 108,
+ 109, -1, -1, 45, 46, 72, -1, -1, 50, 76,
+ -1, -1, 3, 4, -1, 82, -1, 59, 85, 86,
+ -1, -1, -1, 65, -1, -1, 93, -1, -1, -1,
+ 72, -1, -1, -1, 76, 102, 103, 104, 105, -1,
+ 82, 108, 109, 85, 86, -1, -1, 89, 90, -1,
+ -1, 93, 94, -1, 45, 46, -1, -1, -1, 50,
+ 102, 103, 104, 105, -1, -1, 108, 109, 59, -1,
+ -1, -1, -1, -1, 65, -1, -1, 3, 4, -1,
+ -1, 72, -1, -1, -1, 76, -1, -1, -1, -1,
+ -1, 82, -1, -1, 85, 86, -1, -1, 89, 90,
+ -1, -1, 93, 94, -1, -1, -1, -1, -1, -1,
+ -1, 102, 103, 104, 105, -1, -1, 108, 109, 45,
+ 46, -1, -1, -1, 50, -1, -1, -1, 3, 4,
+ -1, -1, -1, 59, -1, -1, -1, -1, -1, 65,
+ -1, -1, -1, -1, -1, -1, 72, -1, -1, -1,
+ 76, -1, -1, -1, -1, -1, 82, -1, -1, 85,
+ 86, -1, -1, 89, 90, -1, -1, 93, 94, -1,
+ 45, 46, -1, -1, -1, 50, 102, 103, 104, 105,
+ -1, -1, 108, 109, 59, -1, -1, -1, -1, -1,
+ 65, -1, -1, 3, 4, -1, -1, 72, -1, -1,
+ -1, 76, -1, -1, -1, -1, -1, 82, -1, -1,
+ 85, 86, -1, -1, 89, 90, -1, -1, 93, 94,
+ -1, -1, -1, -1, -1, -1, -1, 102, 103, 104,
+ 105, -1, -1, 108, 109, 45, 46, -1, -1, -1,
+ 50, -1, -1, -1, -1, -1, -1, -1, -1, 59,
+ -1, -1, -1, -1, -1, 65, -1, -1, -1, -1,
+ -1, -1, 72, -1, -1, -1, 76, -1, -1, -1,
+ -1, -1, 82, -1, -1, 85, 86, -1, -1, 89,
+ 90, -1, -1, 93, -1, 44, 45, 46, -1, -1,
+ -1, 50, 102, 103, 104, 105, -1, -1, 108, 109,
+ 59, -1, -1, -1, -1, -1, 65, -1, -1, -1,
+ -1, -1, -1, 72, -1, -1, -1, 76, -1, -1,
+ -1, -1, -1, 82, -1, -1, 85, 86, -1, -1,
+ -1, -1, -1, -1, 93, -1, -1, -1, -1, -1,
+ -1, -1, -1, 102, 103, 104, 105, -1, -1, 108,
+ 109
+};
+#define YYPURE 1
+
+/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
+#line 3 "/usr/cygnus/gnupro-98r1/share/bison.simple"
+
+/* Skeleton output parser for bison,
+ Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/* As a special exception, when this file is copied by Bison into a
+ Bison output file, you may use that output file without restriction.
+ This special exception was added by the Free Software Foundation
+ in version 1.24 of Bison. */
+
+#ifndef alloca
+#ifdef __GNUC__
+#define alloca __builtin_alloca
+#else /* not GNU C. */
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
+#include <alloca.h>
+#else /* not sparc */
+#if defined (MSDOS) && !defined (__TURBOC__)
+#include <malloc.h>
+#else /* not MSDOS, or __TURBOC__ */
+#if defined(_AIX)
+#include <malloc.h>
+ #pragma alloca
+#else /* not MSDOS, __TURBOC__, or _AIX */
+#ifdef __hpux
+#ifdef __cplusplus
+extern "C" {
+void *alloca (unsigned int);
+};
+#else /* not __cplusplus */
+void *alloca ();
+#endif /* not __cplusplus */
+#endif /* __hpux */
+#endif /* not _AIX */
+#endif /* not MSDOS, or __TURBOC__ */
+#endif /* not sparc. */
+#endif /* not GNU C. */
+#endif /* alloca not defined. */
+
+/* This is the parser code that is written into each bison parser
+ when the %semantic_parser declaration is not specified in the grammar.
+ It was written by Richard Stallman by simplifying the hairy parser
+ used when %semantic_parser is specified. */
+
+/* Note: there must be only one dollar sign in this file.
+ It is replaced by the list of actions, each action
+ as one case of the switch. */
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+#define YYEMPTY -2
+#define YYEOF 0
+#define YYACCEPT return(0)
+#define YYABORT return(1)
+#define YYERROR goto yyerrlab1
+/* Like YYERROR except do call yyerror.
+ This remains here temporarily to ease the
+ transition to the new meaning of YYERROR, for GCC.
+ Once GCC version 2 has supplanted version 1, this can go. */
+#define YYFAIL goto yyerrlab
+#define YYRECOVERING() (!!yyerrstatus)
+#define YYBACKUP(token, value) \
+do \
+ if (yychar == YYEMPTY && yylen == 1) \
+ { yychar = (token), yylval = (value); \
+ yychar1 = YYTRANSLATE (yychar); \
+ YYPOPSTACK; \
+ goto yybackup; \
+ } \
+ else \
+ { yyerror ("syntax error: cannot back up"); YYERROR; } \
+while (0)
+
+#define YYTERROR 1
+#define YYERRCODE 256
+
+#ifndef YYPURE
+#define YYLEX yylex()
+#endif
+
+#ifdef YYPURE
+#ifdef YYLSP_NEEDED
+#ifdef YYLEX_PARAM
+#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
+#else
+#define YYLEX yylex(&yylval, &yylloc)
+#endif
+#else /* not YYLSP_NEEDED */
+#ifdef YYLEX_PARAM
+#define YYLEX yylex(&yylval, YYLEX_PARAM)
+#else
+#define YYLEX yylex(&yylval)
+#endif
+#endif /* not YYLSP_NEEDED */
+#endif
+
+/* If nonreentrant, generate the variables here */
+
+#ifndef YYPURE
+
+int yychar; /* the lookahead symbol */
+YYSTYPE yylval; /* the semantic value of the */
+ /* lookahead symbol */
+
+#ifdef YYLSP_NEEDED
+YYLTYPE yylloc; /* location data for the lookahead */
+ /* symbol */
+#endif
+
+int yynerrs; /* number of parse errors so far */
+#endif /* not YYPURE */
+
+#if YYDEBUG != 0
+int yydebug; /* nonzero means print parse trace */
+/* Since this is uninitialized, it does not stop multiple parsers
+ from coexisting. */
+#endif
+
+/* YYINITDEPTH indicates the initial size of the parser's stacks */
+
+#ifndef YYINITDEPTH
+#define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH is the maximum size the stacks can grow to
+ (effective only if the built-in stack extension method is used). */
+
+#if YYMAXDEPTH == 0
+#undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+#define YYMAXDEPTH 10000
+#endif
+
+/* Prevent warning if -Wstrict-prototypes. */
+#ifdef __GNUC__
+int yyparse (void);
+#endif
+\f
+#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
+#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
+#else /* not GNU C or C++ */
+#ifndef __cplusplus
+
+/* This is the most reliable way to avoid incompatibilities
+ in available built-in functions on various systems. */
+static void
+__yy_memcpy (to, from, count)
+ char *to;
+ char *from;
+ int count;
+{
+ register char *f = from;
+ register char *t = to;
+ register int i = count;
+
+ while (i-- > 0)
+ *t++ = *f++;
+}
+
+#else /* __cplusplus */
+
+/* This is the most reliable way to avoid incompatibilities
+ in available built-in functions on various systems. */
+static void
+__yy_memcpy (char *to, char *from, int count)
+{
+ register char *f = from;
+ register char *t = to;
+ register int i = count;
+
+ while (i-- > 0)
+ *t++ = *f++;
+}
+
+#endif
+#endif
+\f
+#line 196 "/usr/cygnus/gnupro-98r1/share/bison.simple"
+
+/* The user can define YYPARSE_PARAM as the name of an argument to be passed
+ into yyparse. The argument should have type void *.
+ It should actually point to an object.
+ Grammar actions can access the variable by casting it
+ to the proper pointer type. */
+
+#ifdef YYPARSE_PARAM
+#ifdef __cplusplus
+#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+#define YYPARSE_PARAM_DECL
+#else /* not __cplusplus */
+#define YYPARSE_PARAM_ARG YYPARSE_PARAM
+#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+#endif /* not __cplusplus */
+#else /* not YYPARSE_PARAM */
+#define YYPARSE_PARAM_ARG
+#define YYPARSE_PARAM_DECL
+#endif /* not YYPARSE_PARAM */
+
+int
+yyparse(YYPARSE_PARAM_ARG)
+ YYPARSE_PARAM_DECL
+{
+ register int yystate;
+ register int yyn;
+ register short *yyssp;
+ register YYSTYPE *yyvsp;
+ int yyerrstatus; /* number of tokens to shift before error messages enabled */
+ int yychar1 = 0; /* lookahead token as an internal (translated) token number */
+
+ short yyssa[YYINITDEPTH]; /* the state stack */
+ YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
+
+ short *yyss = yyssa; /* refer to the stacks thru separate pointers */
+ YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
+
+#ifdef YYLSP_NEEDED
+ YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
+ YYLTYPE *yyls = yylsa;
+ YYLTYPE *yylsp;
+
+#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
+#else
+#define YYPOPSTACK (yyvsp--, yyssp--)
+#endif
+
+ int yystacksize = YYINITDEPTH;
+
+#ifdef YYPURE
+ int yychar;
+ YYSTYPE yylval;
+ int yynerrs;
+#ifdef YYLSP_NEEDED
+ YYLTYPE yylloc;
+#endif
+#endif
+
+ YYSTYPE yyval; /* the variable used to return */
+ /* semantic values from the action */
+ /* routines */
+
+ int yylen;
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Starting parse\n");
+#endif
+
+ yystate = 0;
+ yyerrstatus = 0;
+ yynerrs = 0;
+ yychar = YYEMPTY; /* Cause a token to be read. */
+
+ /* Initialize stack pointers.
+ Waste one element of value and location stack
+ so that they stay on the same level as the state stack.
+ The wasted elements are never initialized. */
+
+ yyssp = yyss - 1;
+ yyvsp = yyvs;
+#ifdef YYLSP_NEEDED
+ yylsp = yyls;
+#endif
+
+/* Push a new state, which is found in yystate . */
+/* In all cases, when you get here, the value and location stacks
+ have just been pushed. so pushing a state here evens the stacks. */
+yynewstate:
+
+ *++yyssp = yystate;
+
+ if (yyssp >= yyss + yystacksize - 1)
+ {
+ /* Give user a chance to reallocate the stack */
+ /* Use copies of these so that the &'s don't force the real ones into memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ short *yyss1 = yyss;
+#ifdef YYLSP_NEEDED
+ YYLTYPE *yyls1 = yyls;
+#endif
+
+ /* Get the current used size of the three stacks, in elements. */
+ int size = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+ /* Each stack pointer address is followed by the size of
+ the data in use in that stack, in bytes. */
+#ifdef YYLSP_NEEDED
+ /* This used to be a conditional around just the two extra args,
+ but that might be undefined if yyoverflow is a macro. */
+ yyoverflow("parser stack overflow",
+ &yyss1, size * sizeof (*yyssp),
+ &yyvs1, size * sizeof (*yyvsp),
+ &yyls1, size * sizeof (*yylsp),
+ &yystacksize);
+#else
+ yyoverflow("parser stack overflow",
+ &yyss1, size * sizeof (*yyssp),
+ &yyvs1, size * sizeof (*yyvsp),
+ &yystacksize);
+#endif
+
+ yyss = yyss1; yyvs = yyvs1;
+#ifdef YYLSP_NEEDED
+ yyls = yyls1;
+#endif
+#else /* no yyoverflow */
+ /* Extend the stack our own way. */
+ if (yystacksize >= YYMAXDEPTH)
+ {
+ yyerror("parser stack overflow");
+ return 2;
+ }
+ yystacksize *= 2;
+ if (yystacksize > YYMAXDEPTH)
+ yystacksize = YYMAXDEPTH;
+ yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
+ __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
+ yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
+ __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
+#ifdef YYLSP_NEEDED
+ yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
+ __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
+#endif
+#endif /* no yyoverflow */
+
+ yyssp = yyss + size - 1;
+ yyvsp = yyvs + size - 1;
+#ifdef YYLSP_NEEDED
+ yylsp = yyls + size - 1;
+#endif
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Stack size increased to %d\n", yystacksize);
+#endif
+
+ if (yyssp >= yyss + yystacksize - 1)
+ YYABORT;
+ }
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Entering state %d\n", yystate);
+#endif
+
+ goto yybackup;
+ yybackup:
+
+/* Do appropriate processing given the current state. */
+/* Read a lookahead token if we need one and don't already have one. */
+/* yyresume: */
+
+ /* First try to decide what to do without reference to lookahead token. */
+
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ goto yydefault;
+
+ /* Not known => get a lookahead token if don't already have one. */
+
+ /* yychar is either YYEMPTY or YYEOF
+ or a valid token in external form. */
+
+ if (yychar == YYEMPTY)
+ {
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Reading a token: ");
+#endif
+ yychar = YYLEX;
+ }
+
+ /* Convert token to internal form (in yychar1) for indexing tables with */
+
+ if (yychar <= 0) /* This means end of input. */
+ {
+ yychar1 = 0;
+ yychar = YYEOF; /* Don't call YYLEX any more */
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Now at end of input.\n");
+#endif
+ }
+ else
+ {
+ yychar1 = YYTRANSLATE(yychar);
+
+#if YYDEBUG != 0
+ if (yydebug)
+ {
+ fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
+ /* Give the individual parser a way to print the precise meaning
+ of a token, for further debugging info. */
+#ifdef YYPRINT
+ YYPRINT (stderr, yychar, yylval);
+#endif
+ fprintf (stderr, ")\n");
+ }
+#endif
+ }
+
+ yyn += yychar1;
+ if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+ goto yydefault;
+
+ yyn = yytable[yyn];
+
+ /* yyn is what to do for this token type in this state.
+ Negative => reduce, -yyn is rule number.
+ Positive => shift, yyn is new state.
+ New state is final state => don't bother to shift,
+ just return success.
+ 0, or most negative number => error. */
+
+ if (yyn < 0)
+ {
+ if (yyn == YYFLAG)
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+ else if (yyn == 0)
+ goto yyerrlab;
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+ /* Shift the lookahead token. */
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
+#endif
+
+ /* Discard the token being shifted unless it is eof. */
+ if (yychar != YYEOF)
+ yychar = YYEMPTY;
+
+ *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+ *++yylsp = yylloc;
+#endif
+
+ /* count tokens shifted since error; after three, turn off error status. */
+ if (yyerrstatus) yyerrstatus--;
+
+ yystate = yyn;
+ goto yynewstate;
+
+/* Do the default action for the current state. */
+yydefault:
+
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+
+/* Do a reduction. yyn is the number of a rule to reduce with. */
+yyreduce:
+ yylen = yyr2[yyn];
+ if (yylen > 0)
+ yyval = yyvsp[1-yylen]; /* implement default value of the action */
+
+#if YYDEBUG != 0
+ if (yydebug)
+ {
+ int i;
+
+ fprintf (stderr, "Reducing via rule %d (line %d), ",
+ yyn, yyrline[yyn]);
+
+ /* Print the symbols being reduced, and their result. */
+ for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+ fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+ fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+ }
+#endif
+
+
+ switch (yyn) {
+
+case 1:
+#line 253 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{;
+ break;}
+case 18:
+#line 297 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_java_array_type (yyvsp[-2].node, -1);
+ CLASS_LOADED_P (yyval.node) = 1;
+ ;
+ break;}
+case 19:
+#line 302 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_unresolved_array_type (yyvsp[-2].node); ;
+ break;}
+case 20:
+#line 304 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_unresolved_array_type (yyvsp[-2].node); ;
+ break;}
+case 21:
+#line 306 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{RULE ("']' expected"); RECOVER;;
+ break;}
+case 22:
+#line 308 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{RULE ("']' expected"); RECOVER;;
+ break;}
+case 26:
+#line 323 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = make_qualified_name (yyvsp[-2].node, yyvsp[0].node, yyvsp[-1].operator.location); ;
+ break;}
+case 28:
+#line 332 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = NULL;;
+ break;}
+case 36:
+#line 344 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = NULL;
+ ;
+ break;}
+case 37:
+#line 348 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = NULL;
+ ;
+ break;}
+case 40:
+#line 360 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ ctxp->package = EXPR_WFL_NODE (yyvsp[-1].node); ;
+ break;}
+case 41:
+#line 362 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing name"); RECOVER;;
+ break;}
+case 42:
+#line 364 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 45:
+#line 374 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree name = EXPR_WFL_NODE (yyvsp[-1].node), node, last_name;
+ int i = IDENTIFIER_LENGTH (name)-1;
+ char *last = &IDENTIFIER_POINTER (name)[i];
+ while (last != IDENTIFIER_POINTER (name))
+ {
+ if (last [0] == '.')
+ break;
+ last--;
+ }
+ last_name = get_identifier (++last);
+ if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
+ {
+ tree err = find_name_in_single_imports (last_name);
+ if (err && err != name)
+ parse_error_context
+ (yyvsp[-1].node, "Ambiguous class: `%s' and `%s'",
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (err));
+ }
+ else
+ {
+ IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name) = 1;
+ node = build_tree_list (yyvsp[-1].node, last_name);
+ TREE_CHAIN (node) = ctxp->import_list;
+ ctxp->import_list = node;
+ }
+ ;
+ break;}
+case 46:
+#line 403 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing name"); RECOVER;;
+ break;}
+case 47:
+#line 405 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 48:
+#line 410 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree name = EXPR_WFL_NODE (yyvsp[-3].node);
+ tree node = build_tree_list (yyvsp[-3].node, NULL_TREE);
+ if (!IS_AN_IMPORT_ON_DEMAND_P (name))
+ {
+ read_import_dir (yyvsp[-3].node);
+ IS_AN_IMPORT_ON_DEMAND_P (name) = 1;
+ }
+ TREE_CHAIN (node) = ctxp->import_demand_list;
+ ctxp->import_demand_list = node;
+ ;
+ break;}
+case 49:
+#line 422 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'*' expected"); RECOVER;;
+ break;}
+case 50:
+#line 424 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 51:
+#line 429 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ maybe_generate_clinit ();
+ yyval.node = yyvsp[0].node;
+ ;
+ break;}
+case 53:
+#line 435 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = NULL; ;
+ break;}
+case 54:
+#line 437 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ YYERROR_NOW;
+ yyerror ("Class or interface declaration expected");
+ ;
+ break;}
+case 55:
+#line 448 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.value = (1 << yyvsp[0].value);
+ ;
+ break;}
+case 56:
+#line 452 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ int acc = (1 << yyvsp[0].value);
+ if (yyval.value & acc)
+ parse_error_context
+ (ctxp->modifier_ctx [yyvsp[0].value], "Modifier `%s' declared twice",
+ java_accstring_lookup (acc));
+ else
+ {
+ yyval.value |= acc;
+ }
+ ;
+ break;}
+case 57:
+#line 468 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ create_class (yyvsp[-4].value, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); ;
+ break;}
+case 58:
+#line 470 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = yyvsp[0].node;
+ ;
+ break;}
+case 59:
+#line 474 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ create_class (0, yyvsp[-2].node, yyvsp[-1].node, yyvsp[0].node); ;
+ break;}
+case 60:
+#line 476 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = yyvsp[0].node;
+ ;
+ break;}
+case 61:
+#line 480 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing class name"); RECOVER;;
+ break;}
+case 62:
+#line 482 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing class name"); RECOVER;;
+ break;}
+case 63:
+#line 484 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{if (!ctxp->class_err) yyerror ("'{' expected"); DRECOVER(class1);;
+ break;}
+case 64:
+#line 486 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER;;
+ break;}
+case 65:
+#line 490 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = NULL; ;
+ break;}
+case 66:
+#line 492 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = yyvsp[0].node; ;
+ break;}
+case 67:
+#line 494 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'{' expected"); ctxp->class_err=1;;
+ break;}
+case 68:
+#line 496 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing super class name"); ctxp->class_err=1;;
+ break;}
+case 69:
+#line 500 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = NULL_TREE; ;
+ break;}
+case 70:
+#line 502 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = yyvsp[0].node; ;
+ break;}
+case 71:
+#line 504 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ ctxp->class_err=1;
+ yyerror ("Missing interface name");
+ ;
+ break;}
+case 72:
+#line 512 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ ctxp->interface_number = 1;
+ yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE);
+ ;
+ break;}
+case 73:
+#line 517 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ ctxp->interface_number++;
+ yyval.node = chainon (yyvsp[-2].node, build_tree_list (yyvsp[0].node, NULL_TREE));
+ ;
+ break;}
+case 74:
+#line 522 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing interface name"); RECOVER;;
+ break;}
+case 75:
+#line 527 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = ctxp->current_parsed_class; ;
+ break;}
+case 76:
+#line 529 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = ctxp->current_parsed_class; ;
+ break;}
+case 87:
+#line 554 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ register_fields (0, yyvsp[-2].node, yyvsp[-1].node); ;
+ break;}
+case 88:
+#line 556 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ int acc_count = 0;
+
+ check_modifiers
+ ("Illegal modifier `%s' for field declaration",
+ yyvsp[-3].value, FIELD_MODIFIERS);
+ check_modifiers_consistency (yyvsp[-3].value);
+ register_fields (yyvsp[-3].value, yyvsp[-2].node, yyvsp[-1].node);
+ ;
+ break;}
+case 90:
+#line 571 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = chainon (yyvsp[-2].node, yyvsp[0].node); ;
+ break;}
+case 91:
+#line 573 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 92:
+#line 578 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE); ;
+ break;}
+case 93:
+#line 580 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ if (java_error_count)
+ yyvsp[0].node = NULL_TREE;
+ yyval.node = build_tree_list
+ (yyvsp[-2].node, build_assignment (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node));
+ ;
+ break;}
+case 94:
+#line 587 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyerror ("Missing variable initializer");
+ yyval.node = build_tree_list (yyvsp[-2].node, NULL_TREE);
+ RECOVER;
+ ;
+ break;}
+case 95:
+#line 593 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyerror ("';' expected");
+ yyval.node = build_tree_list (yyvsp[-3].node, NULL_TREE);
+ RECOVER;
+ ;
+ break;}
+case 97:
+#line 603 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = NULL; /* FIXME */
+ ;
+ break;}
+case 98:
+#line 607 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Invalid declaration"); DRECOVER(vdi);;
+ break;}
+case 99:
+#line 609 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("']' expected"); DRECOVER(vdi);;
+ break;}
+case 100:
+#line 611 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Unbalanced ']'"); DRECOVER(vdi);;
+ break;}
+case 102:
+#line 617 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = NULL; ;
+ break;}
+case 103:
+#line 623 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ current_function_decl = yyvsp[0].node;
+ source_start_java_method (current_function_decl);
+ ;
+ break;}
+case 104:
+#line 628 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ BLOCK_EXPR_BODY
+ (DECL_FUNCTION_BODY (current_function_decl)) = yyvsp[0].node;
+ maybe_absorb_scoping_blocks ();
+ exit_block (); /* Exit function's body. */
+
+ /* Merge last line of the function with first line,
+ directly in the function decl. It will be used to
+ emit correct debug info. */
+ DECL_SOURCE_LINE_MERGE (current_function_decl,
+ ctxp->last_ccb_indent1);
+ ;
+ break;}
+case 105:
+#line 641 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{YYNOT_TWICE yyerror ("'{' expected"); RECOVER;;
+ break;}
+case 106:
+#line 646 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = method_header (0, yyvsp[-2].node, yyvsp[-1].node, NULL); ;
+ break;}
+case 107:
+#line 648 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = method_header (0, void_type_node, yyvsp[-1].node, NULL); ;
+ break;}
+case 108:
+#line 650 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = method_header (yyvsp[-3].value, yyvsp[-2].node, yyvsp[-1].node, NULL); ;
+ break;}
+case 109:
+#line 652 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = method_header (yyvsp[-3].value, void_type_node, yyvsp[-1].node, NULL); ;
+ break;}
+case 110:
+#line 654 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{RECOVER;;
+ break;}
+case 111:
+#line 656 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{RECOVER;;
+ break;}
+case 112:
+#line 658 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Identifier expected"); RECOVER;;
+ break;}
+case 113:
+#line 660 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Identifier expected"); RECOVER;;
+ break;}
+case 114:
+#line 662 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyerror ("Invalid method declaration, return type required");
+ RECOVER;
+ ;
+ break;}
+case 115:
+#line 670 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = method_declarator (yyvsp[-2].node, NULL_TREE); ;
+ break;}
+case 116:
+#line 672 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = method_declarator (yyvsp[-3].node, yyvsp[-1].node); ;
+ break;}
+case 117:
+#line 674 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ /* Issue a warning here: obsolete declaration. FIXME */
+ yyval.node = NULL; /* FIXME */
+ ;
+ break;}
+case 118:
+#line 679 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("')' expected"); DRECOVER(method_declarator);;
+ break;}
+case 119:
+#line 681 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("']' expected"); RECOVER;;
+ break;}
+case 120:
+#line 686 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ ctxp->formal_parameter_number = 1;
+ ;
+ break;}
+case 121:
+#line 690 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ ctxp->formal_parameter_number += 1;
+ yyval.node = chainon (yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 122:
+#line 695 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing formal parameter term"); RECOVER;;
+ break;}
+case 123:
+#line 700 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_tree_list (yyvsp[0].node, yyvsp[-1].node);
+ ;
+ break;}
+case 124:
+#line 704 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[-2].value));
+ yyval.node = NULL; /* FIXME */
+ ;
+ break;}
+case 125:
+#line 709 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing identifier"); RECOVER;;
+ break;}
+case 126:
+#line 711 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[-2].value));
+ yyerror ("Missing identifier"); RECOVER;
+ ;
+ break;}
+case 129:
+#line 720 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing class type term"); RECOVER;;
+ break;}
+case 132:
+#line 727 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing class type term"); RECOVER;;
+ break;}
+case 135:
+#line 734 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = NULL_TREE; ;
+ break;}
+case 136:
+#line 740 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("STATIC_INITIALIZER");
+ ;
+ break;}
+case 137:
+#line 744 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("STATIC_INITIALIZER");
+ ;
+ break;}
+case 138:
+#line 751 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[0].value));
+ ;
+ break;}
+case 139:
+#line 763 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("CONSTRUCTOR_DECLARATION");
+ ;
+ break;}
+case 140:
+#line 767 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[-3].value));
+ RULE ("CONSTRUCTOR_DECLARATION (modifier)");
+ ;
+ break;}
+case 141:
+#line 773 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("CONSTRUCTOR_DECLARATION");
+ ;
+ break;}
+case 142:
+#line 778 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[-4].value));
+ RULE ("CONSTRUCTOR_DECLARATION (modifier)");
+ ;
+ break;}
+case 152:
+#line 806 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{RULE ("explicit_constructor_invocation (X.super)");;
+ break;}
+case 153:
+#line 811 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree wfl = build_wfl_node (this_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = yyvsp[0].operator.location;
+ yyval.node = wfl;
+ ;
+ break;}
+case 154:
+#line 817 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree wfl = build_wfl_node (super_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = yyvsp[0].operator.location;
+ yyval.node = wfl;
+ ;
+ break;}
+case 155:
+#line 828 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ create_interface (0, yyvsp[0].node, NULL_TREE); ;
+ break;}
+case 156:
+#line 830 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = yyvsp[0].node;
+ ;
+ break;}
+case 157:
+#line 834 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ create_interface (yyvsp[-2].value, yyvsp[0].node, NULL_TREE); ;
+ break;}
+case 158:
+#line 836 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = yyvsp[0].node;
+ ;
+ break;}
+case 159:
+#line 840 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ create_interface (0, yyvsp[-1].node, yyvsp[0].node); ;
+ break;}
+case 160:
+#line 842 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = yyvsp[0].node;
+ ;
+ break;}
+case 161:
+#line 846 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ create_interface (yyvsp[-3].value, yyvsp[-1].node, yyvsp[0].node); ;
+ break;}
+case 162:
+#line 848 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = yyvsp[0].node;
+ ;
+ break;}
+case 163:
+#line 852 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("(here)'{' expected"); RECOVER;;
+ break;}
+case 164:
+#line 854 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("(there)'{' expected"); RECOVER;;
+ break;}
+case 165:
+#line 859 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ ctxp->interface_number = 1;
+ yyval.node = build_tree_list (yyvsp[0].node, NULL_TREE);
+ ;
+ break;}
+case 166:
+#line 864 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ ctxp->interface_number++;
+ yyval.node = chainon (yyvsp[-2].node, build_tree_list (yyvsp[0].node, NULL_TREE));
+ ;
+ break;}
+case 167:
+#line 869 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Invalid interface type"); RECOVER;;
+ break;}
+case 168:
+#line 871 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 169:
+#line 876 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = NULL_TREE; ;
+ break;}
+case 170:
+#line 878 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = NULL_TREE; ;
+ break;}
+case 178:
+#line 899 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ check_abstract_method_header (yyvsp[-1].node);
+ current_function_decl = NULL_TREE; /* FIXME ? */
+ ;
+ break;}
+case 179:
+#line 904 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 180:
+#line 910 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("ARRAY_INITIALIZER (empty)");
+ ;
+ break;}
+case 181:
+#line 914 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("ARRAY_INITIALIZER (variable)");
+ ;
+ break;}
+case 182:
+#line 918 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("ARRAY_INITIALIZER (,)");
+ ;
+ break;}
+case 183:
+#line 922 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("ARRAY_INITIALIZER (variable, ,)");
+ ;
+ break;}
+case 186:
+#line 931 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 187:
+#line 937 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = size_zero_node; ;
+ break;}
+case 188:
+#line 939 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ enter_block (); ;
+ break;}
+case 189:
+#line 942 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ maybe_absorb_scoping_blocks ();
+ yyval.node = exit_block ();
+ ;
+ break;}
+case 193:
+#line 956 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = java_method_add_stmt (current_function_decl, yyvsp[0].node); ;
+ break;}
+case 196:
+#line 966 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ declare_local_variables (0, yyvsp[-1].node, yyvsp[0].node); ;
+ break;}
+case 197:
+#line 968 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ declare_local_variables (yyvsp[-2].value, yyvsp[-1].node, yyvsp[0].node); ;
+ break;}
+case 199:
+#line 974 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (labeled)"); ;
+ break;}
+case 200:
+#line 976 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (if-then)"); ;
+ break;}
+case 201:
+#line 978 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (if-then-else)"); ;
+ break;}
+case 202:
+#line 980 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (while)"); ;
+ break;}
+case 203:
+#line 982 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ /* If the for loop is unlabeled, we must return the
+ block it was defined it. It our last chance to
+ get a hold on it. */
+ if (!LOOP_HAS_LABEL_P (yyval.node))
+ yyval.node = exit_block ();
+ ;
+ break;}
+case 205:
+#line 994 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("NSI STATEMENT (labeled)"); ;
+ break;}
+case 206:
+#line 996 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("NSI STATEMENT (if-then-else)"); ;
+ break;}
+case 207:
+#line 998 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("NSI STATEMENT (while)"); ;
+ break;}
+case 208:
+#line 1000 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("NSI STATEMENT (for)"); ;
+ break;}
+case 209:
+#line 1005 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (block)"); ;
+ break;}
+case 210:
+#line 1007 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (empty)"); ;
+ break;}
+case 211:
+#line 1009 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (expression)"); ;
+ break;}
+case 212:
+#line 1011 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (switch)"); ;
+ break;}
+case 213:
+#line 1013 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (do)"); ;
+ break;}
+case 214:
+#line 1015 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (break)"); ;
+ break;}
+case 215:
+#line 1017 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (continue)"); ;
+ break;}
+case 217:
+#line 1020 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (synchronized)"); ;
+ break;}
+case 218:
+#line 1022 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (throw)"); ;
+ break;}
+case 219:
+#line 1024 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ RULE ("STATEMENT (try)"); ;
+ break;}
+case 220:
+#line 1029 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = size_zero_node; ;
+ break;}
+case 221:
+#line 1034 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_labeled_block (EXPR_WFL_LINECOL (yyvsp[-1].node),
+ EXPR_WFL_NODE (yyvsp[-1].node), yyvsp[-1].node);
+ pushlevel (2);
+ push_labeled_block (yyval.node);
+ PUSH_LABELED_BLOCK (yyval.node);
+ ;
+ break;}
+case 222:
+#line 1045 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = complete_labeled_statement (yyvsp[-1].node, yyvsp[0].node);
+ pop_labeled_block ();
+ POP_LABELED_BLOCK ();
+ ;
+ break;}
+case 223:
+#line 1051 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("':' expected"); RECOVER;;
+ break;}
+case 224:
+#line 1056 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = complete_labeled_statement (yyvsp[-1].node, yyvsp[0].node);
+ pop_labeled_block ();
+ POP_LABELED_BLOCK ();
+ ;
+ break;}
+case 225:
+#line 1067 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ /* We have a statement. Generate a WFL around it so
+ we can debug it */
+ yyval.node = build_expr_wfl (yyvsp[-1].node, input_filename, lineno, 0);
+ /* We know we have a statement, so set the debug
+ info to be eventually generate here. */
+ yyval.node = JAVA_MAYBE_GENERATE_DEBUG_INFO (yyval.node);
+ ;
+ break;}
+case 226:
+#line 1076 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid expression statement");
+ DRECOVER (expr_stmt);
+ ;
+ break;}
+case 227:
+#line 1082 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid expression statement");
+ DRECOVER (expr_stmt);
+ ;
+ break;}
+case 228:
+#line 1088 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid expression statement");
+ DRECOVER (expr_stmt);
+ ;
+ break;}
+case 229:
+#line 1094 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("')' expected"); RECOVER;;
+ break;}
+case 230:
+#line 1096 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 231:
+#line 1098 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("')' expected"); RECOVER;;
+ break;}
+case 232:
+#line 1100 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 233:
+#line 1102 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'(' expected"); RECOVER;;
+ break;}
+case 234:
+#line 1104 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("')' expected"); RECOVER;;
+ break;}
+case 235:
+#line 1106 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("')' expected"); RECOVER;;
+ break;}
+case 236:
+#line 1108 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 237:
+#line 1110 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 239:
+#line 1116 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("++INCREMENT");
+ ;
+ break;}
+case 240:
+#line 1120 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("--DECREMENT");
+ ;
+ break;}
+case 241:
+#line 1124 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("INCREMENT++");
+ ;
+ break;}
+case 242:
+#line 1128 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("DECREMENT--");
+ ;
+ break;}
+case 244:
+#line 1133 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ RULE ("INSTANCE CREATION");
+ ;
+ break;}
+case 245:
+#line 1140 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_if_else_statement (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[0].node, NULL_TREE); ;
+ break;}
+case 246:
+#line 1142 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'(' expected"); RECOVER;;
+ break;}
+case 247:
+#line 1144 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 248:
+#line 1146 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("')' expected"); RECOVER;;
+ break;}
+case 249:
+#line 1151 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_if_else_statement (yyvsp[-5].operator.location, yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); ;
+ break;}
+case 250:
+#line 1156 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_if_else_statement (yyvsp[-5].operator.location, yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node); ;
+ break;}
+case 252:
+#line 1162 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'(' expected"); RECOVER;;
+ break;}
+case 253:
+#line 1164 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term or ')'"); DRECOVER(switch_statement);;
+ break;}
+case 254:
+#line 1166 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'{' expected"); RECOVER;;
+ break;}
+case 266:
+#line 1195 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing or invalid constant expression"); RECOVER;;
+ break;}
+case 267:
+#line 1197 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("':' expected"); RECOVER;;
+ break;}
+case 268:
+#line 1199 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("':' expected"); RECOVER;;
+ break;}
+case 269:
+#line 1204 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree body = build_loop_body (yyvsp[-2].operator.location, yyvsp[-1].node, 0);
+ yyval.node = build_new_loop (body);
+ ;
+ break;}
+case 270:
+#line 1212 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = complete_loop_body (0, NULL_TREE, yyvsp[0].node, 0); ;
+ break;}
+case 271:
+#line 1214 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{YYERROR_NOW; yyerror ("'(' expected"); RECOVER;;
+ break;}
+case 272:
+#line 1216 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term and ')' expected"); RECOVER;;
+ break;}
+case 273:
+#line 1218 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("')' expected"); RECOVER;;
+ break;}
+case 274:
+#line 1223 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = complete_loop_body (0, NULL_TREE, yyvsp[0].node, 0); ;
+ break;}
+case 275:
+#line 1228 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree body = build_loop_body (0, NULL_TREE, 1);
+ yyval.node = build_new_loop (body);
+ ;
+ break;}
+case 276:
+#line 1237 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = complete_loop_body (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[-5].node, 1); ;
+ break;}
+case 277:
+#line 1242 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = complete_for_loop (EXPR_WFL_LINECOL (yyvsp[-4].node), yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node);;
+ break;}
+case 278:
+#line 1244 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = complete_for_loop (0, NULL_TREE, yyvsp[-2].node, yyvsp[0].node);
+ /* We have not condition, so we get rid of the EXIT_EXPR */
+ LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY (yyval.node), 0) =
+ size_zero_node;
+ ;
+ break;}
+case 279:
+#line 1251 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Invalid control expression"); RECOVER;;
+ break;}
+case 280:
+#line 1253 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Invalid update expression"); RECOVER;;
+ break;}
+case 281:
+#line 1255 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Invalid update expression"); RECOVER;;
+ break;}
+case 282:
+#line 1260 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = complete_for_loop (EXPR_WFL_LINECOL (yyvsp[-4].node), yyvsp[-4].node, yyvsp[-2].node, yyvsp[0].node);;
+ break;}
+case 283:
+#line 1262 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = complete_for_loop (0, NULL_TREE, yyvsp[-2].node, yyvsp[0].node);
+ /* We have not condition, so we get rid of the EXIT_EXPR */
+ LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY (yyval.node), 0) =
+ size_zero_node;
+ ;
+ break;}
+case 284:
+#line 1272 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ /* This scope defined for local variable that may be
+ defined within the scope of the for loop */
+ enter_block ();
+ ;
+ break;}
+case 285:
+#line 1278 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'(' expected"); DRECOVER(for_1);;
+ break;}
+case 286:
+#line 1280 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Invalid init statement"); RECOVER;;
+ break;}
+case 287:
+#line 1285 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ /* We now declare the loop body. The loop is
+ declared as a for loop. */
+ tree body = build_loop_body (0, NULL_TREE, 0);
+ yyval.node = build_new_loop (body);
+ IS_FOR_LOOP_P (yyval.node) = 1;
+ /* The loop is added to the current block the for
+ statement is defined within */
+ java_method_add_stmt (current_function_decl, yyval.node);
+ ;
+ break;}
+case 288:
+#line 1297 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = size_zero_node; ;
+ break;}
+case 289:
+#line 1299 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ /* Init statement recorded within the previously
+ defined block scope */
+ yyval.node = java_method_add_stmt (current_function_decl, yyvsp[0].node);
+ ;
+ break;}
+case 290:
+#line 1305 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ /* Local variable are recorded within the previously
+ defined block scope */
+ yyval.node = NULL_TREE;
+ ;
+ break;}
+case 291:
+#line 1311 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); DRECOVER(for_init_1);;
+ break;}
+case 292:
+#line 1315 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = size_zero_node;;
+ break;}
+case 293:
+#line 1317 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_debugable_stmt (BUILD_LOCATION (), yyvsp[0].node); ;
+ break;}
+case 294:
+#line 1322 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = add_stmt_to_compound (NULL_TREE, NULL_TREE, yyvsp[0].node); ;
+ break;}
+case 295:
+#line 1324 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = add_stmt_to_compound (yyvsp[-2].node, NULL_TREE, yyvsp[0].node); ;
+ break;}
+case 296:
+#line 1326 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 297:
+#line 1331 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_bc_statement (yyvsp[-1].operator.location, 1, NULL_TREE); ;
+ break;}
+case 298:
+#line 1333 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_bc_statement (yyvsp[-2].operator.location, 1, yyvsp[-1].node); ;
+ break;}
+case 299:
+#line 1335 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 300:
+#line 1337 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 301:
+#line 1342 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_bc_statement (yyvsp[-1].operator.location, 0, NULL_TREE); ;
+ break;}
+case 302:
+#line 1344 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_bc_statement (yyvsp[-2].operator.location, 0, yyvsp[-1].node); ;
+ break;}
+case 303:
+#line 1346 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 304:
+#line 1348 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 305:
+#line 1353 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_return (yyvsp[-1].operator.location, NULL_TREE); ;
+ break;}
+case 306:
+#line 1355 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_return (yyvsp[-2].operator.location, yyvsp[-1].node); ;
+ break;}
+case 307:
+#line 1357 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 308:
+#line 1359 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 310:
+#line 1365 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 311:
+#line 1367 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("';' expected"); RECOVER;;
+ break;}
+case 313:
+#line 1373 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'{' expected"); RECOVER;;
+ break;}
+case 314:
+#line 1375 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'(' expected"); RECOVER;;
+ break;}
+case 315:
+#line 1377 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 316:
+#line 1379 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 317:
+#line 1384 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", yyvsp[0].value));
+ ;
+ break;}
+case 321:
+#line 1394 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'{' expected"); DRECOVER (try_statement);;
+ break;}
+case 325:
+#line 1405 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'(' expected"); RECOVER;;
+ break;}
+case 326:
+#line 1407 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); DRECOVER (1);;
+ break;}
+case 327:
+#line 1409 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); DRECOVER (2);;
+ break;}
+case 329:
+#line 1415 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'{' expected"); RECOVER; ;
+ break;}
+case 333:
+#line 1427 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_this (yyvsp[0].operator.location); ;
+ break;}
+case 334:
+#line 1429 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = yyvsp[-1].node;;
+ break;}
+case 343:
+#line 1445 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("')' expected"); RECOVER;;
+ break;}
+case 344:
+#line 1447 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'class' or 'this' expected" ); RECOVER;;
+ break;}
+case 345:
+#line 1449 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'class' expected" ); RECOVER;;
+ break;}
+case 346:
+#line 1451 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'class' expected" ); RECOVER;;
+ break;}
+case 347:
+#line 1456 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node);
+ TREE_SET_CODE (yyval.node, JAVA_NEW_CLASS_EXPR);
+ ;
+ break;}
+case 348:
+#line 1461 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_method_invocation (yyvsp[-2].node, NULL_TREE);
+ TREE_SET_CODE (yyval.node, JAVA_NEW_CLASS_EXPR);
+ ;
+ break;}
+case 349:
+#line 1469 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = yyvsp[-4].node;;
+ break;}
+case 350:
+#line 1471 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = yyvsp[-3].node;;
+ break;}
+case 355:
+#line 1480 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'(' expected"); DRECOVER(new_1);;
+ break;}
+case 356:
+#line 1482 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'(' expected"); RECOVER;;
+ break;}
+case 357:
+#line 1484 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("')' or term expected"); RECOVER;;
+ break;}
+case 358:
+#line 1486 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("')' expected"); RECOVER;;
+ break;}
+case 359:
+#line 1488 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;;
+ break;}
+case 360:
+#line 1490 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'(' expected"); RECOVER;;
+ break;}
+case 363:
+#line 1500 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, NULL_TREE);
+ ctxp->formal_parameter_number = 1;
+ ;
+ break;}
+case 364:
+#line 1505 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ ctxp->formal_parameter_number += 1;
+ yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, yyvsp[-2].node);
+ ;
+ break;}
+case 365:
+#line 1510 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 366:
+#line 1515 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_newarray_node (yyvsp[-1].node, yyvsp[0].node, 0); ;
+ break;}
+case 367:
+#line 1517 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_newarray_node (yyvsp[-1].node, yyvsp[0].node, 0); ;
+ break;}
+case 368:
+#line 1519 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_newarray_node (yyvsp[-2].node, yyvsp[-1].node, ctxp->osb_number); ;
+ break;}
+case 369:
+#line 1521 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_newarray_node (yyvsp[-2].node, yyvsp[-1].node, ctxp->osb_number); ;
+ break;}
+case 370:
+#line 1525 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = yyvsp[-2].node;;
+ break;}
+case 371:
+#line 1527 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = yyvsp[-2].node;;
+ break;}
+case 372:
+#line 1529 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("'[' expected"); DRECOVER ("]");;
+ break;}
+case 373:
+#line 1531 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("']' expected"); RECOVER;;
+ break;}
+case 374:
+#line 1536 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_tree_list (NULL_TREE, yyvsp[0].node); ;
+ break;}
+case 375:
+#line 1538 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = tree_cons (NULL_TREE, yyvsp[0].node, yyval.node); ;
+ break;}
+case 376:
+#line 1543 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ EXPR_WFL_LINECOL (yyvsp[-1].node) = yyvsp[-2].operator.location;
+ yyval.node = yyvsp[-1].node;
+ ;
+ break;}
+case 377:
+#line 1548 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("']' expected"); RECOVER;;
+ break;}
+case 378:
+#line 1550 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyerror ("Missing term");
+ yyerror ("']' expected");
+ RECOVER;
+ ;
+ break;}
+case 379:
+#line 1559 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ ctxp->osb_number = 1; ;
+ break;}
+case 380:
+#line 1561 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ ctxp->osb_number++; ;
+ break;}
+case 381:
+#line 1563 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyerror ("']' expected"); RECOVER;;
+ break;}
+case 382:
+#line 1568 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = make_qualified_primary (yyvsp[-2].node, yyvsp[0].node, yyvsp[-1].operator.location); ;
+ break;}
+case 383:
+#line 1570 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree super_wfl =
+ build_wfl_node (super_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (super_wfl) = yyvsp[-2].operator.location;
+ yyval.node = make_qualified_name (super_wfl, yyvsp[0].node, yyvsp[-1].operator.location);
+ ;
+ break;}
+case 384:
+#line 1577 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Field expected"); DRECOVER (super_field_acces);;
+ break;}
+case 385:
+#line 1582 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_method_invocation (yyvsp[-2].node, NULL_TREE); ;
+ break;}
+case 386:
+#line 1584 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node); ;
+ break;}
+case 387:
+#line 1586 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree invok = build_method_invocation (yyvsp[-2].node, NULL_TREE);
+ yyval.node = make_qualified_primary (yyvsp[-4].node, invok, yyvsp[-3].operator.location);
+ ;
+ break;}
+case 388:
+#line 1591 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree invok = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node);
+ yyval.node = make_qualified_primary (yyvsp[-5].node, invok, yyvsp[-4].operator.location);
+ ;
+ break;}
+case 389:
+#line 1596 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree invok;
+ tree wfl = build_wfl_node (super_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = yyvsp[-4].operator.location;
+ invok = build_method_invocation (yyvsp[-2].node, NULL_TREE);
+ yyval.node = make_qualified_primary (wfl, invok, yyvsp[-3].operator.location);
+ ;
+ break;}
+case 390:
+#line 1604 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree invok;
+ tree wfl = build_wfl_node (super_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = yyvsp[-5].operator.location;
+ invok = build_method_invocation (yyvsp[-3].node, yyvsp[-1].node);
+ yyval.node = make_qualified_primary (wfl, invok, yyvsp[-4].operator.location);
+ ;
+ break;}
+case 391:
+#line 1616 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyerror ("'(' expected"); DRECOVER (method_invocation); ;
+ break;}
+case 392:
+#line 1618 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyerror ("'(' expected"); DRECOVER (method_invocation); ;
+ break;}
+case 393:
+#line 1623 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_array_ref (yyvsp[-2].operator.location, yyvsp[-3].node, yyvsp[-1].node); ;
+ break;}
+case 394:
+#line 1625 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_array_ref (yyvsp[-2].operator.location, yyvsp[-3].node, yyvsp[-1].node); ;
+ break;}
+case 395:
+#line 1627 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyerror ("Missing term and ']' expected");
+ DRECOVER(array_access);
+ ;
+ break;}
+case 396:
+#line 1632 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyerror ("']' expected");
+ DRECOVER(array_access);
+ ;
+ break;}
+case 397:
+#line 1637 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyerror ("Missing term and ']' expected");
+ DRECOVER(array_access);
+ ;
+ break;}
+case 398:
+#line 1642 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyerror ("']' expected");
+ DRECOVER(array_access);
+ ;
+ break;}
+case 403:
+#line 1657 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_incdec (yyvsp[0].operator.token, yyvsp[0].operator.location, yyvsp[-1].node, 1); ;
+ break;}
+case 404:
+#line 1662 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_incdec (yyvsp[0].operator.token, yyvsp[0].operator.location, yyvsp[-1].node, 1); ;
+ break;}
+case 407:
+#line 1669 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ;
+ break;}
+case 408:
+#line 1671 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ;
+ break;}
+case 410:
+#line 1674 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;
+ break;}
+case 411:
+#line 1676 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;
+ break;}
+case 412:
+#line 1681 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = build_incdec (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node, 0); ;
+ break;}
+case 413:
+#line 1683 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;
+ break;}
+case 414:
+#line 1688 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = build_incdec (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node, 0); ;
+ break;}
+case 415:
+#line 1690 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;
+ break;}
+case 417:
+#line 1696 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ;
+ break;}
+case 418:
+#line 1698 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyval.node = build_unaryop (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[0].node); ;
+ break;}
+case 420:
+#line 1701 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;
+ break;}
+case 421:
+#line 1703 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;
+ break;}
+case 422:
+#line 1708 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ tree type = yyvsp[-3].node;
+ while (ctxp->osb_number--)
+ type = build_java_array_type (type, -1);
+ yyval.node = build_cast (yyvsp[-4].operator.location, type, yyvsp[0].node);
+ ;
+ break;}
+case 423:
+#line 1715 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_cast (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[0].node); ;
+ break;}
+case 424:
+#line 1717 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_cast (yyvsp[-3].operator.location, yyvsp[-2].node, yyvsp[0].node); ;
+ break;}
+case 425:
+#line 1719 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ char *ptr;
+ while (ctxp->osb_number--)
+ obstack_1grow (&temporary_obstack, '[');
+ obstack_grow0 (&temporary_obstack,
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (yyvsp[-3].node)),
+ IDENTIFIER_LENGTH (EXPR_WFL_NODE (yyvsp[-3].node)));
+ ptr = obstack_finish (&temporary_obstack);
+ EXPR_WFL_NODE (yyvsp[-3].node) = get_identifier (ptr);
+ yyval.node = build_cast (yyvsp[-4].operator.location, yyvsp[-3].node, yyvsp[0].node);
+ ;
+ break;}
+case 426:
+#line 1731 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("']' expected, invalid type expression");;
+ break;}
+case 427:
+#line 1733 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid type expression"); RECOVER;
+ RECOVER;
+ ;
+ break;}
+case 428:
+#line 1739 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 429:
+#line 1741 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 430:
+#line 1743 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 432:
+#line 1749 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token),
+ yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 433:
+#line 1754 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 434:
+#line 1759 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 435:
+#line 1764 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 436:
+#line 1766 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 437:
+#line 1768 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 439:
+#line 1774 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 440:
+#line 1779 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 441:
+#line 1784 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 442:
+#line 1786 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 444:
+#line 1792 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 445:
+#line 1797 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 446:
+#line 1802 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 447:
+#line 1807 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 448:
+#line 1809 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 449:
+#line 1811 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 451:
+#line 1817 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 452:
+#line 1822 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 453:
+#line 1827 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 454:
+#line 1832 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 456:
+#line 1838 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 457:
+#line 1840 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 458:
+#line 1842 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 459:
+#line 1844 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 460:
+#line 1846 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Invalid reference type"); RECOVER;;
+ break;}
+case 462:
+#line 1852 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 463:
+#line 1857 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 464:
+#line 1862 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 465:
+#line 1864 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 467:
+#line 1870 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 468:
+#line 1875 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 470:
+#line 1881 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 471:
+#line 1886 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 473:
+#line 1892 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 474:
+#line 1897 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 476:
+#line 1903 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 477:
+#line 1908 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 479:
+#line 1914 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ yyval.node = build_binop (BINOP_LOOKUP (yyvsp[-1].operator.token), yyvsp[-1].operator.location,
+ yyvsp[-2].node, yyvsp[0].node);
+ ;
+ break;}
+case 480:
+#line 1919 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); RECOVER;;
+ break;}
+case 483:
+#line 1926 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ YYERROR_NOW;
+ yyerror ("Missing term");
+ DRECOVER (1);
+ ;
+ break;}
+case 484:
+#line 1932 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); DRECOVER (2);;
+ break;}
+case 485:
+#line 1934 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{yyerror ("Missing term"); DRECOVER (3);;
+ break;}
+case 488:
+#line 1944 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{ yyval.node = build_assignment (yyvsp[-1].operator.token, yyvsp[-1].operator.location, yyvsp[-2].node, yyvsp[0].node); ;
+ break;}
+case 489:
+#line 1946 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+{
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Missing term");
+ DRECOVER (assign);
+ ;
+ break;}
+}
+ /* the action file gets copied in in place of this dollarsign */
+#line 498 "/usr/cygnus/gnupro-98r1/share/bison.simple"
+\f
+ yyvsp -= yylen;
+ yyssp -= yylen;
+#ifdef YYLSP_NEEDED
+ yylsp -= yylen;
+#endif
+
+#if YYDEBUG != 0
+ if (yydebug)
+ {
+ short *ssp1 = yyss - 1;
+ fprintf (stderr, "state stack now");
+ while (ssp1 != yyssp)
+ fprintf (stderr, " %d", *++ssp1);
+ fprintf (stderr, "\n");
+ }
+#endif
+
+ *++yyvsp = yyval;
+
+#ifdef YYLSP_NEEDED
+ yylsp++;
+ if (yylen == 0)
+ {
+ yylsp->first_line = yylloc.first_line;
+ yylsp->first_column = yylloc.first_column;
+ yylsp->last_line = (yylsp-1)->last_line;
+ yylsp->last_column = (yylsp-1)->last_column;
+ yylsp->text = 0;
+ }
+ else
+ {
+ yylsp->last_line = (yylsp+yylen-1)->last_line;
+ yylsp->last_column = (yylsp+yylen-1)->last_column;
+ }
+#endif
+
+ /* Now "shift" the result of the reduction.
+ Determine what state that goes to,
+ based on the state we popped back to
+ and the rule number reduced by. */
+
+ yyn = yyr1[yyn];
+
+ yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+ if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+ yystate = yytable[yystate];
+ else
+ yystate = yydefgoto[yyn - YYNTBASE];
+
+ goto yynewstate;
+
+yyerrlab: /* here on detecting error */
+
+ if (! yyerrstatus)
+ /* If not already recovering from an error, report this error. */
+ {
+ ++yynerrs;
+
+#ifdef YYERROR_VERBOSE
+ yyn = yypact[yystate];
+
+ if (yyn > YYFLAG && yyn < YYLAST)
+ {
+ int size = 0;
+ char *msg;
+ int x, count;
+
+ count = 0;
+ /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
+ for (x = (yyn < 0 ? -yyn : 0);
+ x < (sizeof(yytname) / sizeof(char *)); x++)
+ if (yycheck[x + yyn] == x)
+ size += strlen(yytname[x]) + 15, count++;
+ msg = (char *) malloc(size + 15);
+ if (msg != 0)
+ {
+ strcpy(msg, "parse error");
+
+ if (count < 5)
+ {
+ count = 0;
+ for (x = (yyn < 0 ? -yyn : 0);
+ x < (sizeof(yytname) / sizeof(char *)); x++)
+ if (yycheck[x + yyn] == x)
+ {
+ strcat(msg, count == 0 ? ", expecting `" : " or `");
+ strcat(msg, yytname[x]);
+ strcat(msg, "'");
+ count++;
+ }
+ }
+ yyerror(msg);
+ free(msg);
+ }
+ else
+ yyerror ("parse error; also virtual memory exceeded");
+ }
+ else
+#endif /* YYERROR_VERBOSE */
+ yyerror("parse error");
+ }
+
+ goto yyerrlab1;
+yyerrlab1: /* here on error raised explicitly by an action */
+
+ if (yyerrstatus == 3)
+ {
+ /* if just tried and failed to reuse lookahead token after an error, discard it. */
+
+ /* return failure if at end of input */
+ if (yychar == YYEOF)
+ YYABORT;
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+#endif
+
+ yychar = YYEMPTY;
+ }
+
+ /* Else will try to reuse lookahead token
+ after shifting the error token. */
+
+ yyerrstatus = 3; /* Each real token shifted decrements this */
+
+ goto yyerrhandle;
+
+yyerrdefault: /* current state does not do anything special for the error token. */
+
+#if 0
+ /* This is wrong; only states that explicitly want error tokens
+ should shift them. */
+ yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
+ if (yyn) goto yydefault;
+#endif
+
+yyerrpop: /* pop the current state because it cannot handle the error token */
+
+ if (yyssp == yyss) YYABORT;
+ yyvsp--;
+ yystate = *--yyssp;
+#ifdef YYLSP_NEEDED
+ yylsp--;
+#endif
+
+#if YYDEBUG != 0
+ if (yydebug)
+ {
+ short *ssp1 = yyss - 1;
+ fprintf (stderr, "Error: state stack now");
+ while (ssp1 != yyssp)
+ fprintf (stderr, " %d", *++ssp1);
+ fprintf (stderr, "\n");
+ }
+#endif
+
+yyerrhandle:
+
+ yyn = yypact[yystate];
+ if (yyn == YYFLAG)
+ goto yyerrdefault;
+
+ yyn += YYTERROR;
+ if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+ goto yyerrdefault;
+
+ yyn = yytable[yyn];
+ if (yyn < 0)
+ {
+ if (yyn == YYFLAG)
+ goto yyerrpop;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+ else if (yyn == 0)
+ goto yyerrpop;
+
+ if (yyn == YYFINAL)
+ YYACCEPT;
+
+#if YYDEBUG != 0
+ if (yydebug)
+ fprintf(stderr, "Shifting error token, ");
+#endif
+
+ *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+ *++yylsp = yylloc;
+#endif
+
+ yystate = yyn;
+ goto yynewstate;
+}
+#line 1972 "/nfs/hoser/beer/java/egcs/gcc/java/parse.y"
+
+\f
+
+#include "lex.c"
+
+/* Flag for the error report routine to issue the error the first time
+ it's called (overriding the default behavior which is to drop the
+ first invocation and honor the second one, taking advantage of a
+ richer context. */
+static int force_error = 0;
+
+/* Create a new parser context and make it the current one. */
+
+void
+java_push_parser_context ()
+{
+ struct parser_ctxt *new =
+ (struct parser_ctxt *)malloc(sizeof (struct parser_ctxt));
+
+ bzero (new, sizeof (struct parser_ctxt));
+ new->next = ctxp;
+ ctxp = new;
+ if (ctxp->next)
+ ctxp->incomplete_class = ctxp->next->incomplete_class;
+}
+
+void
+java_parser_context_save_global ()
+{
+ ctxp->finput = finput;
+ ctxp->lineno = lineno;
+ ctxp->current_class = current_class;
+ ctxp->filename = input_filename;
+ ctxp->current_function_decl = current_function_decl;
+}
+
+void
+java_parser_context_restore_global ()
+{
+ finput = ctxp->finput;
+ lineno = ctxp->lineno;
+ current_class = ctxp->current_class;
+ input_filename = ctxp->filename;
+ current_function_decl = ctxp->current_function_decl;
+}
+
+void
+java_pop_parser_context ()
+{
+ tree current;
+ struct parser_ctxt *toFree = ctxp;
+ struct parser_ctxt *next = ctxp->next;
+
+ if (next)
+ {
+ next->incomplete_class = ctxp->incomplete_class;
+ lineno = ctxp->lineno;
+ finput = ctxp->finput;
+ current_class = ctxp->current_class;
+ }
+
+ /* Set the single import class file flag to 0 for the current list
+ of imported things */
+ for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
+ IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 0;
+
+ /* And restore those of the previous context */
+ if (ctxp = next)
+ for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
+ IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 1;
+
+ free (toFree);
+}
+
+static int do_warning = 0;
+
+void
+yyerror (msg)
+ char *msg;
+{
+ static java_lc elc;
+ static int prev_lineno;
+ static char *prev_msg;
+
+ int i, save_lineno;
+ char *remainder, *code_from_source;
+ extern struct obstack temporary_obstack;
+
+ if (!force_error && prev_lineno == lineno)
+ return;
+
+ /* Save current error location but report latter, when the context is
+ richer. */
+ if (ctxp->java_error_flag == 0)
+ {
+ ctxp->java_error_flag = 1;
+ elc = ctxp->elc;
+ /* Do something to use the previous line if we're reaching the
+ end of the file... */
+#ifdef VERBOSE_SKELETON
+ printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
+#endif
+ return;
+ }
+
+ /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
+ if (!force_error && msg == prev_msg && prev_lineno == elc.line)
+ return;
+
+ ctxp->java_error_flag = 0;
+ if (do_warning)
+ java_warning_count++;
+ else
+ java_error_count++;
+
+ if (elc.col == 0 && msg[1] == ';')
+ {
+ elc.col = ctxp->p_line->char_col-1;
+ elc.line = ctxp->p_line->lineno;
+ }
+
+ save_lineno = lineno;
+ prev_lineno = lineno = elc.line;
+ prev_msg = msg;
+
+ code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
+ obstack_grow0 (&temporary_obstack,
+ code_from_source, strlen (code_from_source));
+ remainder = obstack_finish (&temporary_obstack);
+ if (do_warning)
+ warning ("%s.\n%s", msg, remainder);
+ else
+ error ("%s.\n%s", msg, remainder);
+
+ /* This allow us to cheaply avoid an extra 'Invalid expression
+ statement' error report when errors have been already reported on
+ the same line. This occurs when we report an error but don't have
+ a synchronization point other than ';', which
+ expression_statement is the only one to take care of. */
+ ctxp->prevent_ese = lineno = save_lineno;
+}
+
+static void
+parse_error (msg)
+ char *msg;
+{
+ java_error (NULL);
+ java_error (msg);
+}
+
+/* Issue an error message at a current source line CL */
+
+static void
+parse_error_context VPROTO ((tree cl, char *msg, ...))
+{
+#ifndef __STDC__
+ tree cl;
+ char *msg;
+#endif
+ char buffer [4096];
+ va_list ap;
+
+ VA_START (ap, msg);
+#ifndef __STDC__
+ cl = va_arg (ap, tree);
+ msg = va_arg (ap, char *);
+#endif
+ vsprintf (buffer, msg, ap);
+
+ force_error = 1;
+ ctxp->elc.line = EXPR_WFL_LINENO (cl);
+ ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 : EXPR_WFL_COLNO (cl));
+
+ parse_error (buffer);
+ force_error = 0;
+}
+
+/* Issue a warning at a current source line CL */
+
+static void
+parse_warning_context VPROTO ((tree cl, char *msg, ...))
+{
+#ifndef __STDC__
+ tree cl;
+ char *msg;
+#endif
+ char buffer [4096];
+ va_list ap;
+
+ VA_START (ap, msg);
+#ifndef __STDC__
+ cl = va_arg (ap, tree);
+ msg = va_arg (ap, char *);
+#endif
+ vsprintf (buffer, msg, ap);
+
+ force_error = do_warning = 1;
+ ctxp->elc.line = EXPR_WFL_LINENO (cl);
+ ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 : EXPR_WFL_COLNO (cl));
+
+ parse_error (buffer);
+ do_warning = force_error = 0;
+}
+
+void
+java_report_errors ()
+{
+ if (java_error_count)
+ fprintf (stderr, "%d error%s",
+ java_error_count, (java_error_count == 1 ? "" : "s"));
+ if (java_warning_count)
+ fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
+ java_warning_count, (java_warning_count == 1 ? "" : "s"));
+ if (java_error_count || java_warning_count)
+ putc ('\n', stderr);
+}
+
+static char *
+java_accstring_lookup (flags)
+ int flags;
+{
+ static char buffer [80];
+#define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
+
+ /* Access modifier looked-up first for easier report on forbidden
+ access. */
+ if (flags & ACC_PUBLIC) COPY_RETURN ("public");
+ if (flags & ACC_PRIVATE) COPY_RETURN ("private");
+ if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
+ if (flags & ACC_STATIC) COPY_RETURN ("static");
+ if (flags & ACC_FINAL) COPY_RETURN ("final");
+ if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
+ if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
+ if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
+ if (flags & ACC_NATIVE) COPY_RETURN ("native");
+ if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
+ if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
+
+ buffer [0] = '\0';
+ return buffer;
+#undef COPY_RETURN
+}
+
+static void
+redefinition_error (context, id, decl, cl)
+ char *context;
+ tree id, decl, cl;
+{
+ parse_error_context (cl, "%s `%s' already defined in %s:%d",
+ context, IDENTIFIER_POINTER (id),
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
+ /* Here we should point out where its redefined. It's a unicode. FIXME */
+}
+
+/* Build something that the type identifier resolver will identify as
+ being an array to an unresolved type. TYPE_WFL is a WFL on a
+ identifier. */
+
+static tree
+build_unresolved_array_type (type_or_wfl)
+ tree type_or_wfl;
+{
+ char *ptr;
+
+ /* TYPE_OR_WFL might be an array on a primitive type. In this case,
+ just create a array type */
+ if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
+ {
+ tree type = build_java_array_type (type_or_wfl, -1);
+ CLASS_LOADED_P (type) = CLASS_LOADED_P (type_or_wfl);
+ return type;
+ }
+
+ obstack_1grow (&temporary_obstack, '[');
+ obstack_grow0 (&temporary_obstack,
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
+ IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
+ ptr = obstack_finish (&temporary_obstack);
+ return build_expr_wfl (get_identifier (ptr),
+ EXPR_WFL_FILENAME (type_or_wfl),
+ EXPR_WFL_LINENO (type_or_wfl),
+ EXPR_WFL_COLNO (type_or_wfl));
+}
+
+/* Check modifiers. If one doesn't fit, retrieve it in its declaration line
+ and point it out. */
+
+static void
+check_modifiers (message, value, mask)
+ char *message;
+ int value;
+ int mask;
+{
+ /* Should point out the one that don't fit. ASCII/unicode,
+ going backward. FIXME */
+ if (value & ~mask)
+ {
+ int i, remainder = value & ~mask;
+ for (i = 0; i <= 10; i++)
+ if ((1 << i) & remainder)
+ parse_error_context (ctxp->modifier_ctx [i], message,
+ java_accstring_lookup (1 << i));
+ }
+}
+
+static void
+parser_add_interface (class_decl, interface_decl, wfl)
+ tree class_decl, interface_decl, wfl;
+{
+ if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
+ parse_error_context (wfl, "Interface `%s' repeated",
+ IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
+}
+
+/* Bulk of common class/interface checks. Return 1 if an error was
+ encountered. TAG is 0 for a class, 1 for an interface. */
+
+static int
+check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
+ int is_interface, flags;
+ tree raw_name, qualified_name, decl, cl;
+{
+ tree node;
+
+ if (!quiet_flag)
+ fprintf (stderr, " %s %s", (is_interface ? "interface" : "class"),
+ IDENTIFIER_POINTER (qualified_name));
+
+ /* Scope of an interface/class type name:
+ - Can't be imported by a single type import
+ - Can't already exists in the package */
+ if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
+ && (node = find_name_in_single_imports (raw_name)))
+ {
+ parse_error_context
+ (cl, "%s name `%s' clashes with imported type `%s'",
+ (is_interface ? "Interface" : "Class"),
+ IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
+ return 1;
+ }
+ if (decl && CLASS_COMPLETE_P (decl))
+ {
+ redefinition_error ((is_interface ? "Interface" : "Class"),
+ qualified_name, decl, cl);
+ return 1;
+ }
+
+ /* If public, file name should match class/interface name */
+ if (flags & ACC_PUBLIC)
+ {
+ char *f;
+
+ /* Contains OS dependent assumption on path separator. FIXME */
+ for (f = &input_filename [strlen (input_filename)];
+ f != input_filename && f[0] != '/'; f--);
+ if (f[0] == '/')
+ f++;
+ if (strncmp (IDENTIFIER_POINTER (raw_name),
+ f , IDENTIFIER_LENGTH (raw_name)) ||
+ f [IDENTIFIER_LENGTH (raw_name)] != '.')
+ parse_error_context (cl, "Public %s `%s' must be defined in a file "
+ "called `%s.java'",
+ (is_interface ? "interface" : "class"),
+ IDENTIFIER_POINTER (qualified_name),
+ IDENTIFIER_POINTER (raw_name));
+ }
+
+ check_modifiers ((is_interface ?
+ "Illegal modifier `%s' for interface declaration" :
+ "Illegal modifier `%s' for class declaration"), flags,
+ (is_interface ? INTERFACE_MODIFIERS : CLASS_MODIFIERS));
+ return 0;
+}
+
+/* If DECL is NULL, create and push a new DECL, record the current
+ line CL and do other maintenance things. */
+
+static tree
+maybe_create_class_interface_decl (decl, qualified_name, cl)
+ tree decl, qualified_name, cl;
+{
+ if (decl)
+ DECL_ARTIFICIAL (decl) = 1; /* FIXME */
+ else
+ decl = push_class (make_class (), qualified_name);
+
+ /* Take care of the file and line business */
+ DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
+ DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
+ CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
+
+ ctxp->current_parsed_class = decl;
+
+ /* Link the declaration to the already seen ones */
+ TREE_CHAIN (decl) = ctxp->class_list;
+ ctxp->class_list = decl;
+ /* Install a new dependency list element */
+ create_jdep_list (ctxp);
+
+ SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
+ IDENTIFIER_POINTER (qualified_name)));
+ return decl;
+}
+
+static void
+add_superinterfaces (decl, interface_list)
+ tree decl, interface_list;
+{
+ tree node;
+ /* Superinterface(s): if present and defined, parser_check_super_interface ()
+ takes care of ensuring that:
+ - This is an accessible interface type,
+ - Circularity detection.
+ parser_add_interface is then called. If present but not defined,
+ the check operation is delayed until the super interface gets
+ defined. */
+ for (node = interface_list; node; node = TREE_CHAIN (node))
+ {
+ tree current = TREE_PURPOSE (node), interface_decl;
+ if ((interface_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current))))
+ {
+ if (!parser_check_super_interface (interface_decl, decl, current))
+ parser_add_interface (decl, interface_decl, current);
+ }
+ else
+ register_incomplete_type (JDEP_INTERFACE,
+ current, decl, NULL_TREE);
+ }
+}
+
+/* Create an interface in pass1 and return its decl. Return the
+ interface's decl in pass 2. */
+
+static tree
+create_interface (flags, id, super)
+ int flags;
+ tree id, super;
+{
+ int chk;
+ tree raw_name = EXPR_WFL_NODE (id);
+ tree q_name = parser_qualified_classname (id);
+ tree decl = IDENTIFIER_CLASS_VALUE (q_name);
+
+ EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */
+
+ /* Basic checks: scope, redefinition, modifiers */
+ if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
+ return NULL_TREE;
+
+ /* Interface modifiers check
+ - public/abstract allowed (already done at that point)
+ - abstract is obsolete (comes first, it's a warning, or should be)
+ - Can't use twice the same (checked in the modifier rule) */
+ if (flags & ACC_ABSTRACT)
+ parse_warning_context
+ (MODIFIER_WFL (ABSTRACT_TK),
+ "Obsolete use of `abstract' modifier. Interface `%s' is implicitely "
+ "abstract", IDENTIFIER_POINTER (raw_name));
+ if (flags & ACC_PUBLIC && flags & ACC_ABSTRACT)
+ parse_error_context
+ (MODIFIER_WFL (ABSTRACT_TK),
+ "Can't specify both `public' and `abstract' modifiers in the "
+ "definition of interface `%s'", IDENTIFIER_POINTER (raw_name));
+
+ /* Create a new decl if DECL is NULL, otherwise fix it */
+ decl = maybe_create_class_interface_decl (decl, q_name, id);
+
+ /* Set super info and mark the class a complete */
+ set_super_info (ACC_ABSTRACT | ACC_INTERFACE | flags, TREE_TYPE (decl),
+ object_type_node, ctxp->interface_number);
+ ctxp->interface_number = 0;
+ CLASS_COMPLETE_P (decl) = 1;
+ add_superinterfaces (decl, super);
+
+ return decl;
+}
+
+/* Create an class in pass1 and return its decl. Return class
+ interface's decl in pass 2. */
+
+static tree
+create_class (flags, id, super, interfaces)
+ int flags;
+ tree id, super, interfaces;
+{
+ int chk;
+ tree raw_name = EXPR_WFL_NODE (id);
+ tree class_id, decl;
+ tree super_decl = NULL, super_decl_type;
+
+ class_id = parser_qualified_classname (id);
+ decl = IDENTIFIER_CLASS_VALUE (class_id);
+ EXPR_WFL_NODE (id) = class_id;
+
+ /* Basic check: scope, redefinition, modifiers */
+ if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
+ return NULL_TREE;
+
+ /* Class modifier check:
+ - Allowed modifier (already done at that point)
+ - abstract AND final forbidden
+ - Public classes defined in the correct file */
+ if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
+ parse_error_context (id, "Class `%s' can't be declared both abstract "
+ "and final", IDENTIFIER_POINTER (raw_name));
+
+ /* Create a new decl if DECL is NULL, otherwise fix it */
+ decl = maybe_create_class_interface_decl (decl, class_id, id);
+
+ /* If SUPER exists, use it, otherwise use Object */
+ if (super)
+ {
+ /* Can't extend java.lang.Object */
+ if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
+ {
+ parse_error_context (id, "Can't extend `java.lang.Object'");
+ return NULL_TREE;
+ }
+
+ /* The class is known and exists if there is a decl. Otherwise,
+ postpone the operation and do it later. */
+ super_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (super));
+ if (super_decl)
+ {
+ parser_check_super (super_decl, decl, id);
+ super_decl_type = TREE_TYPE (super_decl);
+ }
+ else
+ super_decl_type =
+ register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
+ }
+ else if (TREE_TYPE (decl) != object_type_node)
+ super_decl_type = object_type_node;
+ /* We're defining java.lang.Object */
+ else
+ super_decl_type = NULL_TREE;
+
+ /* Set super info and mark the class a complete */
+ set_super_info (flags, TREE_TYPE (decl), super_decl_type,
+ ctxp->interface_number);
+ ctxp->interface_number = 0;
+ CLASS_COMPLETE_P (decl) = 1;
+ add_superinterfaces (decl, interfaces);
+
+ return decl;
+}
+
+/* Can't use lookup_field () since we don't want to load the class and
+ can't set the CLASS_LOADED_P flag */
+
+static tree
+find_field (class, name)
+ tree class;
+ tree name;
+{
+ tree decl;
+ for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
+ {
+ if (DECL_NAME (decl) == name)
+ return decl;
+ }
+ return NULL_TREE;
+}
+
+/* Wrap around lookup_field that doesn't potentially upset the value
+ of CLASS */
+
+static tree
+lookup_field_wrapper (class, name)
+ tree class, name;
+{
+ tree type = class;
+ return lookup_field (&type, name);
+}
+
+/* Find duplicate field within the same class declarations and report
+ the error */
+
+static int
+duplicate_declaration_error (class, new_field_name, new_type, cl)
+ tree class, new_field_name, new_type, cl;
+{
+ /* This might be modified to work with method decl as well */
+ tree decl = find_field (TREE_TYPE (ctxp->current_parsed_class),
+ new_field_name);
+ if (decl)
+ {
+ char *t1 = strdup ((char *)lang_printable_name (new_type, 1));
+ char *t2 =
+ strdup ((TREE_CODE (TREE_TYPE (decl)) == TREE_LIST ?
+ IDENTIFIER_POINTER (TYPE_NAME
+ (TREE_PURPOSE (TREE_TYPE (decl)))) :
+ (char *)lang_printable_name (TREE_TYPE (decl), 1)));
+ parse_error_context
+ (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
+ t1, IDENTIFIER_POINTER (new_field_name),
+ t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
+ free (t1);
+ free (t2);
+ return 0;
+ }
+ return 1;
+}
+
+/* Field registration routine. If TYPE doesn't exist, field
+ declarations are linked to the undefined TYPE dependency list, to
+ be later resolved in java_complete_class () */
+
+static void
+register_fields (flags, type, variable_list)
+ int flags;
+ tree type, variable_list;
+{
+ tree current, type_decl, returned_type;
+ tree class_type = TREE_TYPE (ctxp->current_parsed_class);
+ int saved_lineno = lineno;
+ int must_chain = 0;
+ tree wfl = NULL_TREE;
+
+ /* If we're adding fields to interfaces, those fields are public,
+ static, final */
+ if (CLASS_INTERFACE (TYPE_NAME (class_type)))
+ {
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
+ flags, ACC_PUBLIC,
+ "%s", "interface field(s)");
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
+ flags, ACC_STATIC,
+ "%s", "interface field(s)");
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
+ flags, ACC_FINAL, "%s", "interface field(s)");
+ check_modifiers ("Illegal interface member modifier `%s'", flags,
+ INTERFACE_FIELD_MODIFIERS);
+ flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
+ }
+
+ if (unresolved_type_p (type, &returned_type))
+ {
+ if (returned_type)
+ type = returned_type;
+ else
+ {
+ wfl = type;
+ type = obtain_incomplete_type (type);
+ must_chain = 1;
+ }
+ }
+
+ for (current = variable_list; current; current = TREE_CHAIN (current))
+ {
+ tree cl = TREE_PURPOSE (current);
+ tree init = TREE_VALUE (current);
+ tree current_name = EXPR_WFL_NODE (cl);
+
+ if (duplicate_declaration_error (class_type, current_name, type, cl))
+ {
+ tree field_decl;
+ lineno = EXPR_WFL_LINENO (cl);
+ field_decl = add_field (class_type, current_name, type, flags);
+
+ /* Check if we must chain. */
+ if (must_chain)
+ register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
+
+ /* Default value of a static field is 0 and it is considered
+ initialized. */
+ if (flags & ACC_STATIC)
+ INITIALIZED_P (field_decl) = 1;
+
+ /* If we have an initialization value tied to the field */
+ if (init)
+ {
+ /* The field is declared static */
+ if (flags & ACC_STATIC)
+ {
+ /* FIXME */
+ if (flags & ACC_FINAL)
+ ;
+ /* Otherwise, the field should be initialized in
+ <clinit>. This field is remembered so we can
+ generate <clinit> later. */
+ else
+ {
+ INITIALIZED_P (field_decl) = 1;
+ TREE_CHAIN (init) = ctxp->static_initialized;
+ ctxp->static_initialized = init;
+ }
+ }
+ /* A non-static field declared with an immediate
+ initialization is to be initialized in <init>, if
+ any. This field is remembered to be processed at the
+ time of the generation of <init>. */
+ else
+ {
+ TREE_CHAIN (init) = ctxp->non_static_initialized;
+ ctxp->non_static_initialized = init;
+ }
+ }
+ }
+ }
+ lineno = saved_lineno;
+}
+
+/* Check whether it is necessary to generate a <clinit> for the class
+ we just parsed. */
+
+static void
+maybe_generate_clinit ()
+{
+ int saved_lineno;
+ tree meth, mdecl, c;
+ tree cclass, class_wfl;
+
+ if (!ctxp->static_initialized || java_error_count)
+ return;
+
+ cclass = TREE_TYPE (ctxp->current_parsed_class);
+ class_wfl = build_expr_wfl (DECL_NAME (TYPE_NAME (cclass)),
+ input_filename, 0, 0);
+
+ saved_lineno = lineno;
+ lineno = 0;
+ meth = make_node (FUNCTION_TYPE);
+ TREE_TYPE (meth) = void_type_node;
+ TYPE_ARG_TYPES (meth) = NULL_TREE;
+ mdecl = add_method (cclass, ACC_STATIC, clinit_identifier_node,
+ build_java_signature (meth));
+ lineno = saved_lineno;
+
+ DECL_SOURCE_LINE (mdecl) = 1;
+ DECL_SOURCE_LINE_MERGE (mdecl, 1);
+ source_start_java_method (mdecl);
+ enter_block ();
+
+ /* Keep initialization in order to enforce 8.5 */
+ ctxp->static_initialized = nreverse (ctxp->static_initialized);
+
+ /* We process the list of assignment we produced as the result of
+ the declaration of initialized static field and add them as
+ statement to the <clinit> method. */
+ for (c = ctxp->static_initialized; c; c = TREE_CHAIN (c))
+ {
+ /* We build the assignment expression that will initialize the
+ field to its value. There are strict rules on static
+ initializers (8.5). FIXME */
+ java_method_add_stmt (mdecl, c);
+ }
+
+ BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block ();
+ exit_block ();
+ ctxp->static_initialized = NULL_TREE;
+}
+
+/* Shared accros method_declarator and method_header to remember the
+ patch stage that was reached during the declaration of the method.
+ A method DECL is built differently is there is no patch
+ (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
+ pending on the currently defined method. */
+
+static int patch_stage;
+
+/* Check the method declaration and add the method to its current
+ class. If the argument list is known to contain incomplete types,
+ the method is partially added and the registration will be resume
+ once the method arguments resolved */
+
+static tree
+method_header (flags, type, mdecl, throws)
+ int flags;
+ tree type, mdecl, throws;
+{
+ tree meth = TREE_VALUE (mdecl);
+ tree id = TREE_PURPOSE (mdecl);
+ tree this_class = TREE_TYPE (ctxp->current_parsed_class);
+ tree handle_class = CLASS_TO_HANDLE_TYPE (this_class);
+ tree meth_name, returned_type;
+ int saved_lineno;
+
+ check_modifiers_consistency (flags);
+
+ /* There are some forbidden modifiers for an abstract method and its
+ class must be abstract as well. */
+ if (flags & ACC_ABSTRACT)
+ {
+ ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
+ ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
+ ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
+ ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
+ ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED,id, "Synchronized");
+ if (!CLASS_ABSTRACT (TYPE_NAME (this_class)))
+ parse_error_context
+ (id, "Class `%s' must be declared abstract to define abstract "
+ "method `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (ctxp->current_parsed_class)),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
+ }
+
+
+ /* Method declared within the scope of an interface are implicitly
+ abstract and public. Conflicts with other erroneously provided
+ modifiers are check right after. */
+
+ if (CLASS_INTERFACE (TYPE_NAME (this_class)))
+ {
+ /* If FLAGS isn't set because of a modifier, turn the
+ corresponding modifier WFL to NULL so we issue a warning on
+ the obsolete use of the modifier */
+ if (!(flags & ACC_PUBLIC))
+ MODIFIER_WFL (PUBLIC_TK) = NULL;
+ if (!(flags & ACC_ABSTRACT))
+ MODIFIER_WFL (ABSTRACT_TK) = NULL;
+ flags |= ACC_PUBLIC;
+ flags |= ACC_ABSTRACT;
+ }
+
+ /* Modifiers context reset moved up, so abstract method declaration
+ modifiers can be later checked. */
+
+ meth_name = EXPR_WFL_NODE (id);
+
+ if (unresolved_type_p (type, &returned_type))
+ {
+ if (returned_type)
+ TREE_TYPE (meth) = returned_type;
+ else
+ {
+ patch_stage = JDEP_METHOD_RETURN;
+ TREE_TYPE (meth) =
+ register_incomplete_type (patch_stage, type, id, NULL_TREE);
+ }
+ }
+ else
+ TREE_TYPE (meth) = type;
+
+ saved_lineno = lineno;
+ /* When defining an abstract or interface method, the curly
+ bracket at level 1 doesn't exist because there is no function
+ body */
+ lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
+ EXPR_WFL_LINENO (id));
+
+ if (patch_stage) /* includes ret type and/or all args */
+ {
+ jdep *jdep;
+ meth = add_method_1 (this_class, flags, meth_name, meth);
+ /* Patch for the return type */
+ if (patch_stage == JDEP_METHOD_RETURN)
+ {
+ jdep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
+ }
+ /* This is the stop JDEP. METH allows the function's signature
+ to be computed. */
+ register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
+ }
+ else
+ {
+ tree signature = build_java_signature (meth);
+ tree arg, orig_arg;
+ /* Save original argument list, including argument's names */
+ orig_arg = TYPE_ARG_TYPES (meth);
+ /* Add the method to its class */
+ meth = add_method (this_class, flags, meth_name, signature);
+ /* Fix the method argument list so we have the argument name
+ information */
+ arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
+ if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
+ {
+ TREE_PURPOSE (arg) = this_identifier_node;
+ arg = TREE_CHAIN (arg);
+ }
+ while (orig_arg)
+ {
+ TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
+ orig_arg = TREE_CHAIN (orig_arg);
+ arg = TREE_CHAIN (arg);
+ }
+ }
+ DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
+ lineno = saved_lineno;
+ /* We set the DECL_NAME to ID so we can track the location where
+ the function was declared. This allow us to report
+ redefinition error accurately. When method are verified,
+ DECL_NAME is reinstalled properly (using the content of the
+ WFL node ID) (see check_method_redefinition). We don't do that
+ when Object is being defined. */
+ if (TREE_TYPE (ctxp->current_parsed_class) != object_type_node)
+ DECL_NAME (meth) = id;
+ return meth;
+}
+
+/* Check modifiers that can be declared but exclusively */
+
+static void
+check_modifiers_consistency (flags)
+ int flags;
+{
+ int acc_count = 0;
+ tree cl = NULL_TREE;
+
+ THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, 0, acc_count, cl);
+ THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, 1, acc_count, cl);
+ THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, 2, acc_count, cl);
+ if (acc_count > 1)
+ parse_error_context
+ (cl, "Inconsistent member declaration. At most one of `public', "
+ "`private', or `protected' may be specified");
+}
+
+/* Check the methode header METH for abstract specifics features */
+
+static void
+check_abstract_method_header (meth)
+ tree meth;
+{
+ int flags = get_access_flags_from_decl (meth);
+ /* DECL_NAME might still be a WFL node */
+ tree name = (TREE_CODE (DECL_NAME (meth)) == EXPR_WITH_FILE_LOCATION ?
+ EXPR_WFL_NODE (DECL_NAME (meth)) : DECL_NAME (meth));
+
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (ABSTRACT_TK), flags,
+ ACC_ABSTRACT, "abstract method `%s'",
+ IDENTIFIER_POINTER (name));
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK), flags,
+ ACC_PUBLIC, "abstract method `%s'",
+ IDENTIFIER_POINTER (name));
+
+ check_modifiers ("Illegal modifier `%s' for interface method",
+ flags, INTERFACE_METHOD_MODIFIERS);
+}
+
+/* Create a FUNCTION_TYPE node and start augmenting it with the
+ declared function arguments. Arguments type that can't be resolved
+ are left as they are, but the returned node is marked as containing
+ incomplete types. */
+
+static tree
+method_declarator (id, list)
+ tree id, list;
+{
+ tree arg_types = NULL_TREE, current, node;
+ tree meth = make_node (FUNCTION_TYPE);
+ jdep *jdep;
+ int incomplete = 0;
+
+ patch_stage = JDEP_NO_PATCH;
+
+ for (current = list; current; current = TREE_CHAIN (current))
+ {
+ tree wfl_name = TREE_PURPOSE (current);
+ tree type = TREE_VALUE (current);
+ tree name = EXPR_WFL_NODE (wfl_name);
+ tree patchable_type = NULL_TREE, already;
+ tree arg_node, returned_type;
+
+ /* Check redefinition */
+ for (already = arg_types; already; already = TREE_CHAIN (already))
+ if (TREE_PURPOSE (already) == name)
+ {
+ parse_error_context
+ (wfl_name, "Variable `%s' is used more than once in the "
+ "argument list of method `%s'", IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
+ break;
+ }
+
+ /* If we've an incomplete argument type, we know there is a location
+ to patch when the type get resolved, later. */
+ jdep = NULL;
+ if (unresolved_type_p (type, &returned_type))
+ {
+ if (returned_type)
+ type = returned_type;
+ else
+ {
+ patch_stage = JDEP_METHOD;
+ type = register_incomplete_type (patch_stage, type,
+ wfl_name, NULL_TREE);
+ jdep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_MISC (jdep) = id;
+ }
+ }
+ /* The argument node: a name and a (possibly) incomplete type */
+ arg_node = build_tree_list (name, type);
+ if (jdep)
+ JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
+ TREE_CHAIN (arg_node) = arg_types;
+ arg_types = arg_node;
+ }
+ TYPE_ARG_TYPES (meth) = nreverse (arg_types);
+ node = build_tree_list (id, meth);
+ return node;
+}
+
+static int
+unresolved_type_p (wfl, returned)
+ tree wfl;
+ tree *returned;
+
+{
+ if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
+ {
+ tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
+ if (returned)
+ *returned = (decl ? TREE_TYPE (decl) : NULL_TREE);
+ return 1;
+ }
+ if (returned)
+ *returned = wfl;
+ return 0;
+}
+
+/* From NAME, build a qualified identifier node using the
+ qualification from the current package definition. */
+
+static tree
+parser_qualified_classname (name)
+ tree name;
+{
+ if (ctxp->package)
+ return merge_qualified_name (ctxp->package, EXPR_WFL_NODE (name));
+ else
+ return EXPR_WFL_NODE (name);
+}
+
+/* Called once the type a interface extends is resolved. Returns 0 if
+ everything is OK. */
+
+static int
+parser_check_super_interface (super_decl, this_decl, this_wfl)
+ tree super_decl, this_decl, this_wfl;
+{
+ tree super_type = TREE_TYPE (super_decl);
+
+ /* Has to be an interface */
+ if (!CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (super_decl))))
+ {
+ parse_error_context
+ (this_wfl, "Can't use %s `%s' to implement/extend %s `%s'",
+ (TYPE_ARRAY_P (super_type) ? "array" : "class"),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl)),
+ (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
+ "interface" : "class"),
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)));
+ return 1;
+ }
+
+ /* Check scope: same package OK, other package: OK if public */
+ if (check_pkg_class_access (DECL_NAME (super_decl), lookup_cl (this_decl)))
+ return 1;
+
+ SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl))));
+ return 0;
+}
+
+/* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
+ 0 if everthing is OK. */
+
+static int
+parser_check_super (super_decl, this_decl, wfl)
+ tree super_decl, this_decl, wfl;
+{
+ tree this_type = TREE_TYPE (this_decl);
+ tree super_type = TREE_TYPE (super_decl);
+
+ /* SUPER should be a CLASS (neither an array nor an interface) */
+ if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
+ {
+ parse_error_context
+ (wfl, "Class `%s' can't subclass %s `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)),
+ (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl)));
+ return 1;
+ }
+
+ if (CLASS_FINAL (TYPE_NAME (super_type)))
+ {
+ parse_error_context (wfl, "Can't subclass final classes: %s",
+ IDENTIFIER_POINTER (DECL_NAME (super_decl)));
+ return 1;
+ }
+
+ /* Check scope: same package OK, other package: OK if public */
+ if (check_pkg_class_access (DECL_NAME (super_decl), wfl))
+ return 1;
+
+ SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl))));
+ return 0;
+}
+
+/* Create a new dependency list and link it (in a LIFO manner) to the
+ CTXP list of type dependency list. */
+
+static void
+create_jdep_list (ctxp)
+ struct parser_ctxt *ctxp;
+{
+ jdeplist *new = malloc (sizeof (jdeplist));
+
+ if (!new)
+ fatal ("Can't alloc jdeplist - create_jdep_list");
+
+ new->first = new->last = NULL;
+ new->next = ctxp->classd_list;
+ ctxp->classd_list = new;
+}
+
+static jdeplist *
+reverse_jdep_list (ctxp)
+ struct parser_ctxt *ctxp;
+{
+ register jdeplist *prev = NULL, *current, *next;
+ for (current = ctxp->classd_list; current; current = next)
+ {
+ next = current->next;
+ current->next = prev;
+ prev = current;
+ }
+ return prev;
+}
+
+/* Create a fake pointer based on the ID stored in the WFL */
+
+static tree
+obtain_incomplete_type (wfl)
+ tree wfl;
+{
+ tree ptr;
+ tree name = EXPR_WFL_NODE (wfl);
+
+ for (ptr = ctxp->incomplete_class; ptr; ptr = TREE_CHAIN (ptr))
+ if (TYPE_NAME (TREE_PURPOSE (ptr)) == name)
+ break;
+
+ if (!ptr)
+ {
+ tree core;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ BUILD_PTR_FROM_NAME (core, name);
+ ptr = build_tree_list (core, NULL_TREE);
+ pop_obstacks ();
+ TREE_CHAIN (ptr) = ctxp->incomplete_class;
+ ctxp->incomplete_class = ptr;
+ }
+
+ return ptr;
+}
+
+/* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
+ non NULL instead of computing a new fake type based on WFL. The new
+ dependency is inserted in the current type dependency list, in FIFO
+ manner. */
+
+static tree
+register_incomplete_type (kind, wfl, decl, ptr)
+ int kind;
+ tree wfl, decl, ptr;
+{
+ jdep *new = malloc (sizeof (jdep));
+
+ if (!new)
+ fatal ("Can't allocate new jdep - register_incomplete_type");
+ if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
+ ptr = obtain_incomplete_type (wfl);
+
+ JDEP_KIND (new) = kind;
+ JDEP_DECL (new) = decl;
+ JDEP_SOLV (new) = ptr;
+ JDEP_WFL (new) = wfl;
+ JDEP_CHAIN (new) = NULL;
+ JDEP_MISC (new) = NULL_TREE;
+ JDEP_GET_PATCH (new) = (tree *)NULL;
+
+ JDEP_INSERT (ctxp->classd_list, new);
+
+ return ptr;
+}
+
+void
+java_check_circular_reference ()
+{
+ tree current;
+ for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+ {
+ tree type = TREE_TYPE (current);
+ if (CLASS_INTERFACE (TYPE_NAME (type)))
+ {
+ /* Check all interfaces this class extends */
+ tree basetype_vec = TYPE_BINFO_BASETYPES (type);
+ int n, i;
+
+ if (!basetype_vec)
+ return;
+ n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; i < n; i++)
+ {
+ tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
+ if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
+ && interface_of_p (type, BINFO_TYPE (vec_elt)))
+ parse_error_context (lookup_cl (current),
+ "Cyclic interface inheritance");
+ }
+ }
+ else
+ if (inherits_from_p (CLASSTYPE_SUPER (type), type))
+ parse_error_context (lookup_cl (current),
+ "Cyclic class inheritance");
+ }
+}
+
+void
+safe_layout_class (class)
+ tree class;
+{
+ tree save_current_class = current_class;
+ char *save_input_filename = input_filename;
+ int save_lineno = lineno;
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ layout_class (class);
+ pop_obstacks ();
+
+ current_class = save_current_class;
+ input_filename = save_input_filename;
+ lineno = save_lineno;
+ CLASS_LOADED_P (class) = 1;
+}
+
+static tree
+jdep_resolve_class (dep)
+ jdep *dep;
+{
+ tree decl;
+
+ if (!JDEP_RESOLVED_P (dep))
+ {
+ decl =
+ resolve_class (JDEP_TO_RESOLVE (dep), JDEP_DECL (dep), JDEP_WFL (dep));
+ JDEP_RESOLVED (dep, decl);
+ }
+ else
+ decl = JDEP_RESOLVED_DECL (dep);
+
+ if (!decl)
+ {
+ complete_class_report_errors (dep);
+ return NULL_TREE;
+ }
+ return decl;
+}
+
+/* Complete unsatisfied class declaration and their dependencies */
+
+void
+java_complete_class ()
+{
+ tree current;
+ tree cclass;
+ jdeplist *cclassd;
+ int error_found;
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+
+ /* Process imports and reverse the import on demand list */
+ process_imports ();
+ if (ctxp->import_demand_list)
+ ctxp->import_demand_list = nreverse (ctxp->import_demand_list);
+
+ /* Rever things so we have the right order */
+ ctxp->class_list = nreverse (ctxp->class_list);
+ ctxp->classd_list = reverse_jdep_list (ctxp);
+
+ for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
+ cclass && cclassd;
+ cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
+ {
+ jdep *dep;
+ for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
+ {
+ tree decl;
+
+ if (!(decl = jdep_resolve_class (dep)))
+ continue;
+
+ /* Now it's time to patch */
+ switch (JDEP_KIND (dep))
+ {
+ case JDEP_SUPER:
+ /* Simply patch super */
+ if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
+ continue;
+ BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
+ (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
+ break;
+
+ case JDEP_FIELD:
+ {
+ /* We do part of the job done in add_field */
+ tree field_decl = JDEP_DECL (dep);
+ tree field_type = TREE_TYPE (decl);
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+#if ! JAVA_PROMOTE_TO_INT
+ if (TREE_CODE (field_type) == RECORD_TYPE)
+#endif
+ field_type = promote_type (field_type);
+ pop_obstacks ();
+ TREE_TYPE (field_decl) = field_type;
+ SOURCE_FRONTEND_DEBUG
+ (("Completed field/var decl `%s' with `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (field_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (decl))));
+ break;
+ }
+ case JDEP_METHOD: /* We start patching a method */
+ case JDEP_METHOD_RETURN:
+ error_found = 0;
+ while (1)
+ {
+ if (decl)
+ {
+ tree type = promote_type (TREE_TYPE(decl));
+ JDEP_APPLY_PATCH (dep, type);
+ SOURCE_FRONTEND_DEBUG
+ (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
+ "Completing fct `%s' with ret type `%s'":
+ "Completing arg `%s' with type `%s'"),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE
+ (JDEP_DECL_WFL (dep))),
+ IDENTIFIER_POINTER (DECL_NAME (decl))));
+ }
+ else
+ error_found = 1;
+ dep = JDEP_CHAIN (dep);
+ if (JDEP_KIND (dep) == JDEP_METHOD_END)
+ break;
+ else
+ decl = jdep_resolve_class (dep);
+ }
+ if (!error_found)
+ {
+ tree mdecl = JDEP_DECL (dep), signature;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ /* Recompute and reset the signature */
+ signature = build_java_signature (TREE_TYPE (mdecl));
+ set_java_signature (TREE_TYPE (mdecl), signature);
+ pop_obstacks ();
+ }
+ else
+ continue;
+ break;
+
+ case JDEP_INTERFACE:
+ if (parser_check_super_interface (decl, JDEP_DECL (dep),
+ JDEP_WFL (dep)))
+ continue;
+ parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
+ break;
+
+ case JDEP_VARIABLE:
+ JDEP_APPLY_PATCH (dep, promote_type (TREE_TYPE (decl)));
+ SOURCE_FRONTEND_DEBUG
+ (("Completing variable `%s' with type `%s'",
+ (TREE_CODE (JDEP_DECL_WFL (dep)) == EXPR_WITH_FILE_LOCATION ?
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))) :
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL_WFL (dep)))),
+ IDENTIFIER_POINTER (DECL_NAME (decl))));
+ break;
+
+ case JDEP_TYPE:
+ JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
+ SOURCE_FRONTEND_DEBUG
+ (("Completing a random type dependency on a '%s' node",
+ tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
+ break;
+
+ case JDEP_PARM:
+ JDEP_APPLY_PATCH (dep, promote_type (TREE_TYPE (decl)));
+ SOURCE_FRONTEND_DEBUG
+ (("Completing parameter `%s' with type `%s'",
+ IDENTIFIER_POINTER (JDEP_MISC (dep)),
+ IDENTIFIER_POINTER (DECL_NAME (decl))));
+ break;
+
+ default:
+ fatal ("incomplete switch - java_complete_class");
+ }
+ }
+ }
+ pop_obstacks ();
+ return;
+}
+
+/* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
+ array. */
+
+static tree
+resolve_class (class_type, decl, cl)
+ tree class_type, decl, cl;
+{
+ char *name = IDENTIFIER_POINTER (TYPE_NAME (class_type));
+ char *base = name;
+ tree resolved_type, resolved_type_decl;
+
+ /* 1- Check to see if we have an array. If true, find what we really
+ want to resolve */
+ while (name[0] == '[')
+ name++;
+ if (base != name)
+ TYPE_NAME (class_type) = get_identifier (name);
+
+ /* 2- Resolve the bare type */
+ if (!(resolved_type_decl = do_resolve_class (class_type, decl, cl)))
+ return NULL_TREE;
+ resolved_type = TREE_TYPE (resolved_type_decl);
+
+ /* 3- If we have and array, reconstruct the array down to its nesting */
+ if (base != name)
+ {
+ while (base != name)
+ {
+ if (TREE_CODE (resolved_type) == RECORD_TYPE)
+ resolved_type = promote_type (resolved_type);
+ resolved_type = build_java_array_type (resolved_type, -1);
+ name--;
+ }
+ /* Build a fake decl for this, since this is what is expected to
+ be returned. */
+ resolved_type_decl =
+ build_decl (TYPE_DECL, TYPE_NAME (resolved_type), resolved_type);
+ /* Figure how those two things are important for error report. FIXME */
+ DECL_SOURCE_LINE (resolved_type_decl) = 0;
+ DECL_SOURCE_FILE (resolved_type_decl) = input_filename;
+ }
+ return resolved_type_decl;
+}
+
+/* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
+ are used to report error messages. */
+
+static tree
+do_resolve_class (class_type, decl, cl)
+ tree class_type;
+ tree decl;
+ tree cl;
+{
+ tree new_class_decl;
+ tree original_name = NULL_TREE;
+
+ /* Do not try to replace TYPE_NAME (class_type) by a variable, since
+ its is changed by find_in_imports{_on_demand} */
+
+ /* 1- Check for the type in single imports */
+ if (find_in_imports (class_type))
+ return NULL_TREE;
+
+ /* 2- And check for the type in the current compilation unit. If it fails,
+ try with a name qualified with the package name if appropriate. */
+
+ if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
+ {
+ if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
+ !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
+ load_class (TYPE_NAME (class_type), 0);
+ return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+ }
+
+ original_name = TYPE_NAME (class_type);
+ if (!QUALIFIED_P (TYPE_NAME (class_type)) && ctxp->package)
+ TYPE_NAME (class_type) = merge_qualified_name (ctxp->package,
+ TYPE_NAME (class_type));
+ if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
+ {
+ if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
+ !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
+ load_class (TYPE_NAME (class_type), 0);
+ return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+ }
+ TYPE_NAME (class_type) = original_name;
+
+ /* 3- Check an other compilation unit that bears the name of type */
+ load_class (TYPE_NAME (class_type), 0);
+ if (check_pkg_class_access (TYPE_NAME (class_type),
+ (cl ? cl : lookup_cl (decl))))
+ return NULL_TREE;
+
+ if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
+ return new_class_decl;
+
+ /* 4- Check the import on demands. Don't allow bar.baz to be
+ imported from foo.* */
+ if (!QUALIFIED_P (TYPE_NAME (class_type)))
+ if (find_in_imports_on_demand (class_type))
+ return NULL_TREE;
+
+ /* 5- Last call for a resolution */
+ return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+}
+
+/* Resolve NAME and lay it out (if not done and if not the current
+ parsed class). Return a decl node. */
+
+static tree
+resolve_and_layout (name, cl)
+ tree name;
+ tree cl;
+{
+ tree decl = resolve_no_layout (name, cl);
+ if (decl && TREE_TYPE (decl) != current_class
+ && !CLASS_LOADED_P (TREE_TYPE (decl)))
+ safe_layout_class (TREE_TYPE (decl));
+ return decl;
+}
+
+/* Resolve a class, returns its decl but doesn't perform any
+ layout. The current parsing context is saved and restored */
+
+static tree
+resolve_no_layout (name, cl)
+ tree name, cl;
+{
+ tree ptr, decl;
+ BUILD_PTR_FROM_NAME (ptr, name);
+ java_parser_context_save_global ();
+ decl = resolve_class (ptr, NULL_TREE, cl);
+ java_parser_context_restore_global ();
+
+ return decl;
+}
+
+/* Called to report errors. Skip leader '[' in a complex array type
+ description that failed to be resolved. */
+
+static char *
+purify_type_name (name)
+ char *name;
+{
+ while (*name && *name == '[')
+ name++;
+ return name;
+}
+
+/* The type CURRENT refers to can't be found. We print error messages. */
+
+static void
+complete_class_report_errors (dep)
+ jdep *dep;
+{
+ switch (JDEP_KIND (dep))
+ {
+ case JDEP_SUPER:
+ parse_error_context
+ (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ case JDEP_FIELD:
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ case JDEP_METHOD: /* Covers arguments */
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
+ "argument `%s' of method `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
+ break;
+ case JDEP_METHOD_RETURN: /* Covers return type */
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
+ "return type of method `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
+ break;
+ case JDEP_INTERFACE:
+ parse_error_context
+ (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
+ (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ case JDEP_VARIABLE:
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
+ "local variable `%s'",
+ purify_type_name (IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ }
+}
+
+/* Check uninitialized final. */
+
+void
+java_check_final ()
+{
+}
+
+static int
+check_method_redefinition (class, method)
+ tree class, method;
+{
+ tree redef, name;
+ tree cl = DECL_NAME (method);
+ tree sig = TYPE_LANG_SPECIFIC (TREE_TYPE (method))->signature;
+ /* decl name of generated <clinit> doesn't need to be fixed and
+ checked */
+ if (DECL_NAME (method) != clinit_identifier_node)
+ {
+ /* NAME is just the plain name when Object is being defined */
+ if (class != object_type_node)
+ name = DECL_NAME (method) = EXPR_WFL_NODE (DECL_NAME (method));
+ else
+ name = DECL_NAME (method);
+ }
+ else
+ return 0;
+
+ for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
+ {
+ struct lang_type *t = TYPE_LANG_SPECIFIC (TREE_TYPE (redef));
+
+ if (! t || (redef == method))
+ break;
+ if (DECL_NAME (redef) == name && sig == t->signature)
+ {
+ parse_error_context (cl, "Duplicate method declaration");
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* Check all the methods of CLASS. Methods are first completed then
+ checked according to regular method existance rules.
+ If no constructor were encountered, then build its declaration. */
+
+static void
+java_check_regular_methods (class_decl)
+ tree class_decl;
+{
+ tree method;
+ tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl));
+ tree super_class = CLASSTYPE_SUPER (class);
+ int seen_constructor = 0;
+
+ TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
+
+ /* Should take interfaces into account. FIXME */
+ for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
+ {
+ tree found, sig;
+ tree method_wfl = DECL_NAME (method);
+ int aflags;
+
+ if (DECL_CONSTRUCTOR_P (method))
+ seen_constructor = 1;
+
+ /* Check for redefinitions */
+ if (check_method_redefinition (class, method))
+ continue;
+
+ sig = build_java_argument_signature (TREE_TYPE (method));
+
+ found = lookup_argument_method (super_class, DECL_NAME (method), sig);
+ if (! found)
+ continue;
+ /* Can't override a method with the same name and different return
+ types. */
+ if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
+ parse_warning_context
+ (method_wfl,
+ "Method `%s' redefined with different return type in class `%s'",
+ lang_printable_name (found),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+
+ /* Can't override final. Can't override static. */
+ if (METHOD_FINAL (found) || METHOD_STATIC (found))
+ {
+ /* Static *can* override static */
+ if (METHOD_STATIC (found) && METHOD_STATIC (method))
+ continue;
+ parse_error_context
+ (method_wfl,
+ "%s methods can't be overriden. Method `%s' is %s in class `%s'",
+ (METHOD_FINAL (found) ? "Final" : "Static"),
+ lang_printable_name (found),
+ (METHOD_FINAL (found) ? "final" : "static"),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ continue;
+ }
+ /* Static method can't override instance method. */
+ if (METHOD_STATIC (method))
+ {
+ parse_error_context
+ (method_wfl,
+ "Instance methods can't be overriden by a static method. Method "
+ "`%s' is an instance method in class `%s'",
+ lang_printable_name (found),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ continue;
+ }
+ /* Overriding/hiding public must be public or
+ overriding/hiding protected must be protected or public */
+ if ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method)) ||
+ (METHOD_PROTECTED (found)
+ && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method))))
+ {
+ parse_error_context
+ (method_wfl,
+ "Methods can't be overridden to be more private. Method `%s' is "
+ "%s in class `%s'", lang_printable_name (found),
+ (METHOD_PUBLIC (found) ? "public" : "protected"),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ continue;
+ }
+
+ /* If the method has default access in an other package, then
+ issue a warning that the current method doesn't override the one
+ that was found elsewhere */
+ aflags = get_access_flags_from_decl (found);
+ if ((!aflags || (aflags > ACC_PROTECTED))
+ && !class_in_current_package (DECL_CONTEXT (found)))
+ parse_warning_context
+ (method_wfl, "Method `%s' in class `%s' does not "
+ "override the corresponding method in class `%s', which is "
+ "private to a different package",
+ lang_printable_name (found),
+ IDENTIFIER_POINTER (DECL_NAME (class_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+
+ /* Check on (default) package access. FIXME. */
+ /* Inheriting multiple methods with the same signature. FIXME */
+ }
+
+ TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
+
+ if (!seen_constructor)
+ {
+ /* No constructor seen, we craft one, at line 0 */
+ int saved_lineno = lineno;
+ tree meth, decl;
+ lineno = 0;
+ meth = make_node (FUNCTION_TYPE);
+ TREE_TYPE (meth) = void_type_node;
+ TYPE_ARG_TYPES (meth) = NULL_TREE;
+ decl = add_method (class, 0, init_identifier_node,
+ build_java_signature (meth));
+ DECL_CONSTRUCTOR_P (decl) = 1;
+ lineno = saved_lineno;
+ }
+}
+
+/* Check abstract method of interface INTERFACE */
+
+static void
+java_check_abstract_methods (interface)
+ tree interface;
+{
+ int i, n;
+ tree method, basetype_vec, found;
+
+ for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
+ {
+ char *csig;
+ tree name = DECL_NAME (method);
+
+ /* 2- Check for double definition inside the defining interface */
+ if (check_method_redefinition (interface, method))
+ continue;
+
+ /* 3- Overriding is OK as far as we preserve the return type and
+ the thrown exceptions */
+ found = lookup_java_interface_method2 (interface, method);
+ if (found)
+ {
+ parse_error_context
+ (lookup_cl (method),
+ "Method `%s' previously defined in interface `%s' is "
+ "redefined with different return type in interface `%s'",
+ lang_printable_name (found),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))));
+ continue;
+ }
+ }
+
+ /* 4- Inherited methods can't differ by their returned types */
+ if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
+ return;
+ n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; i < n; i++)
+ {
+ tree sub_interface_method, sub_interface;
+ tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
+ if (!vec_elt)
+ continue;
+ sub_interface = BINFO_TYPE (vec_elt);
+ for (sub_interface_method = TYPE_METHODS (sub_interface);
+ sub_interface_method;
+ sub_interface_method = TREE_CHAIN (sub_interface_method))
+ {
+ found = lookup_java_interface_method2 (interface,
+ sub_interface_method);
+ if (found && (found != sub_interface_method))
+ parse_error_context
+ (lookup_cl (sub_interface_method),
+ "Interface `%s' inherits method `%s' from interface `%s'. This "
+ "method is redefined with a different return "
+ "type in interface `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
+ lang_printable_name (found),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (sub_interface_method)))),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ }
+ }
+}
+
+/* Check the method on all the defined classes. Should be done to the
+ classes declared in the compilation unit only. FIXME */
+
+void
+java_check_methods ()
+{
+
+ tree current;
+ for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+ if (CLASS_FROM_SOURCE_P (TREE_TYPE (current)))
+ {
+ tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (current));
+
+ if (CLASS_INTERFACE (TYPE_NAME (class)))
+ java_check_abstract_methods (class);
+ else
+ java_check_regular_methods (current);
+ }
+}
+
+/* Lookup methods in interfaces using their name and partial
+ signature. Return a matching method only if their types differ. */
+
+static tree
+lookup_java_interface_method2 (class, method_decl)
+ tree class, method_decl;
+{
+ int i, n;
+ tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
+
+ if (!basetype_vec)
+ return NULL_TREE;
+
+ n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; i < n; i++)
+ {
+ tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
+ if ((BINFO_TYPE (vec_elt) != object_type_node)
+ && (to_return =
+ lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
+ return to_return;
+ }
+ for (i = 0; i < n; i++)
+ {
+ to_return = lookup_java_interface_method2
+ (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
+ if (to_return)
+ return to_return;
+ }
+
+ return NULL_TREE;
+}
+
+/* Lookup method using their name and partial signature. Return a
+ matching method only if their types differ. */
+
+static tree
+lookup_java_method2 (clas, method_decl, do_interface)
+ tree clas, method_decl;
+ int do_interface;
+{
+ tree method, method_signature, method_name, method_type;
+ method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
+ method_name = DECL_NAME (method_decl);
+ method_type = TREE_TYPE (TREE_TYPE (method_decl));
+
+ while (clas != NULL_TREE)
+ {
+ for (method = TYPE_METHODS (clas);
+ method != NULL_TREE; method = TREE_CHAIN (method))
+ {
+ tree method_sig = build_java_argument_signature (TREE_TYPE (method));
+ if (DECL_NAME (method) == method_name
+ && method_sig == method_signature
+ && TREE_TYPE (TREE_TYPE (method)) != method_type)
+ {
+ return method;
+ }
+ }
+ clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
+ }
+ return NULL_TREE;
+}
+
+/* Return the line that matches DECL line number. Used during error
+ report */
+
+static tree
+lookup_cl (decl)
+ tree decl;
+{
+ static tree cl = NULL_TREE;
+
+ if (!decl)
+ return NULL_TREE;
+
+ if (cl == NULL_TREE)
+ cl = build_expr_wfl (NULL_TREE, NULL, 0, 0);
+
+ EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl));
+ EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1);
+
+ return cl;
+}
+
+/* Look for a simple name in the single-type import list */
+
+static tree
+find_name_in_single_imports (name)
+ tree name;
+{
+ tree node;
+
+ for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
+ if (TREE_VALUE (node) == name)
+ return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
+
+ return NULL_TREE;
+}
+
+/* Process all single-type import. */
+
+static int
+process_imports ()
+{
+ tree import;
+ int error_found;
+
+ for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
+ {
+ tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
+
+ /* Don't load twice something already defined. */
+ if (IDENTIFIER_CLASS_VALUE (to_be_found))
+ continue;
+ QUALIFIED_P (to_be_found) = 1;
+ load_class (to_be_found, 0);
+ error_found =
+ check_pkg_class_access (to_be_found, TREE_PURPOSE (import));
+ if (!IDENTIFIER_CLASS_VALUE (to_be_found))
+ {
+ parse_error_context (TREE_PURPOSE (import),
+ "Class or interface `%s' not found in import",
+ IDENTIFIER_POINTER (to_be_found));
+ return 1;
+ }
+ if (error_found)
+ return 1;
+ }
+ return 0;
+}
+
+/* Possibly find a class imported by a single-type import statement. Return
+ 1 if an error occured, 0 otherwise. */
+
+static int
+find_in_imports (class_type)
+ tree class_type;
+{
+ tree import;
+
+ for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
+ if (TREE_VALUE (import) == TYPE_NAME (class_type))
+ {
+ TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
+ QUALIFIED_P (TYPE_NAME (class_type)) = 1;
+ return check_pkg_class_access (TYPE_NAME (class_type),
+ TREE_PURPOSE (import));
+ }
+ return 0;
+}
+
+/* Process a import on demand statement (lazy) */
+
+static int
+read_import_entry (jcf, dirp, returned_name)
+ JCF *jcf;
+ DIR *dirp;
+ char **returned_name;
+{
+ if (dirp)
+ {
+ struct dirent *direntp = readdir (dirp);
+ if (!direntp)
+ {
+ *returned_name = NULL;
+ return 0;
+ }
+ else
+ {
+ *returned_name = direntp->d_name;
+ return (strlen (direntp->d_name));
+ }
+ }
+ else
+ {
+ int current_dir_len = strlen (jcf->classname);
+ char *current_entry;
+ int current_entry_len;
+
+ /* Here we read a zip directory as a file directory. The files
+ we're selecting must have the same root than the directory
+ we're examining. */
+
+ ZipDirectory *zipd = (ZipDirectory *)jcf->zipd;
+
+ while (zipd)
+ {
+ current_entry = ZIPDIR_FILENAME (zipd);
+ current_entry_len = zipd->filename_length;
+ while (current_entry_len && current_entry [current_entry_len] != '/')
+ current_entry_len--;
+ /* If the path of the current file doesn't match the directory we're
+ scanning, that the end of the search */
+ current_entry_len++;
+ if (strncmp (jcf->classname, current_entry, current_dir_len))
+ {
+ *returned_name = NULL;
+ return 0;
+ }
+ /* Ok, we have at least the same path. The position of the last '/'
+ of the current file we're examining should match the size of
+ name of the directory we're browsing, otherwise that an entry
+ belonging to a sub directory, we want to skip it. */
+ if (current_entry_len != current_dir_len)
+ zipd = ZIPDIR_NEXT (zipd);
+ else
+ {
+ jcf->zipd = ZIPDIR_NEXT (zipd); /* Prepare next read */
+ *returned_name = ¤t_entry [current_entry_len];
+ return (zipd->filename_length - current_entry_len);
+ }
+ }
+ }
+}
+
+/* Read a import directory, gathering potential match for further type
+ references. Indifferently reads a filesystem or a ZIP archive
+ directory. */
+
+static void
+read_import_dir (wfl)
+ tree wfl;
+{
+ char *name = IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl));
+ int name_len = IDENTIFIER_LENGTH (EXPR_WFL_NODE (wfl)), reclen;
+ DIR *dirp = NULL;
+ tree dirname = ident_subst (name, name_len, "", '.', '/', "");
+ JCF jcfr, *jcf, *saved_jcf = current_jcf;
+ char *founddirname, *d_name;
+ struct ZipFileCache zip_cache;
+
+ jcf = &jcfr;
+ if (!classpath)
+ fix_classpath ();
+ if (!(founddirname = find_class (name, name_len, jcf, 0)))
+ fatal ("Can't import `%s'", name);
+ if (jcf->outofsynch)
+ jcf_out_of_synch (jcf);
+ if (jcf->seen_in_zip)
+ jcf->zipd = ZIPDIR_NEXT ((ZipDirectory *)jcf->zipd);
+
+ else if (founddirname && (dirp = opendir (founddirname)))
+ {
+ readdir (dirp); readdir (dirp);
+ }
+
+ if (!founddirname && !dirp)
+ {
+ static int first = 1;
+ if (first)
+ {
+ char buffer [256];
+ sprintf (buffer, "Can't find default package `%s'. Check "
+ "the CLASSPATH environment variable and the access to the "
+ "archives.", name);
+ error (buffer);
+ java_error_count++;
+ first = 0;
+ }
+ else
+ parse_error_context (wfl, "Package `%s' not found in import", name);
+ current_jcf = saved_jcf;
+ return;
+ }
+
+ /* Here we should have a unified way of retrieving an entry, to be
+ indexed. */
+ while ((reclen = read_import_entry (jcf, dirp, &d_name)))
+ {
+ int java_or_class = 0;
+ int len;
+ if ((reclen > 5)
+ && !strcmp (&d_name [reclen-5], ".java"))
+ {
+ java_or_class = 1;
+ len = reclen - 5;
+ }
+
+ if (!java_or_class && (reclen > 6) &&
+ !strcmp (&d_name [reclen-6], ".class"))
+ {
+ java_or_class = 2;
+ len = reclen - 6;
+ }
+
+ if (java_or_class)
+ {
+ char *id_name;
+ tree node, old;
+
+ obstack_grow (&temporary_obstack, name, name_len);
+ obstack_1grow (&temporary_obstack, '/');
+ obstack_grow0 (&temporary_obstack, d_name, len);
+ id_name = obstack_finish (&temporary_obstack);
+
+ node = get_identifier (id_name);
+ IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
+ QUALIFIED_P (node) = 1; /* As soon as we turn / into . */
+ }
+ }
+ if (dirp)
+ closedir (dirp);
+
+ current_jcf = saved_jcf;
+}
+
+/* Possibly find a type in the import on demands specified
+ types. Returns 1 if an error occured, 0 otherwise. Run throught the
+ entire list, to detected potential double definitions. */
+
+static int
+find_in_imports_on_demand (class_type)
+ tree class_type;
+{
+ tree node, import, node_to_use;
+ int seen_once = -1;
+ tree cl;
+
+ for (import = ctxp->import_demand_list; import; import = TREE_CHAIN (import))
+ {
+ char *id_name;
+ tree found;
+ obstack_grow (&temporary_obstack,
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
+ IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
+ obstack_1grow (&temporary_obstack, '/');
+ obstack_grow0 (&temporary_obstack,
+ IDENTIFIER_POINTER (TYPE_NAME (class_type)),
+ IDENTIFIER_LENGTH (TYPE_NAME (class_type)));
+ id_name = obstack_finish (&temporary_obstack);
+
+ node = maybe_get_identifier (id_name);
+ if (node && IS_A_CLASSFILE_NAME (node))
+ {
+ if (seen_once < 0)
+ {
+ cl = TREE_PURPOSE (import);
+ seen_once = 1;
+ node_to_use = node;
+ }
+ else
+ {
+ seen_once++;
+ parse_error_context
+ (import, "Type `%s' also potentially defined in package `%s'",
+ IDENTIFIER_POINTER (TYPE_NAME (class_type)),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))));
+ }
+ }
+ }
+
+ if (seen_once == 1)
+ {
+ /* Setup lineno so that it refers to the line of the import (in
+ case we parse a class file and encounter errors */
+ tree decl;
+ int saved_lineno = lineno;
+ lineno = EXPR_WFL_LINENO (cl);
+ TYPE_NAME (class_type) = ident_subst (IDENTIFIER_POINTER (node_to_use),
+ IDENTIFIER_LENGTH (node_to_use),
+ "", '/', '.', "");
+ QUALIFIED_P (TYPE_NAME (class_type)) = 1;
+ decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+ /* If there is no DECL set for the class or if the class isn't
+ loaded and not seen in source yet, the load */
+ if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
+ && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
+ load_class (node_to_use, 0);
+ lineno = saved_lineno;
+ return check_pkg_class_access (TYPE_NAME (class_type), cl);
+ }
+ else
+ return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
+}
+
+/* Check that CLASS_NAME refers to a PUBLIC class. Return 0 if no
+ access violations were found, 1 otherwise. */
+
+static int
+check_pkg_class_access (class_name, cl)
+ tree class_name;
+ tree cl;
+{
+ tree type;
+ int access;
+
+ if (!QUALIFIED_P (class_name) || !IDENTIFIER_CLASS_VALUE (class_name))
+ return 0;
+
+ if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
+ return 0;
+
+ if (!CLASS_PUBLIC (TYPE_NAME (type)))
+ {
+ parse_error_context
+ (cl, "Can't access %s `%s'. Only public classes and interfaces in "
+ "other packages can be accessed",
+ (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
+ IDENTIFIER_POINTER (class_name));
+ return 1;
+ }
+ return 0;
+}
+
+/* Local variable declaration. */
+
+static void
+declare_local_variables (modifier, type, vlist)
+ int modifier;
+ tree type;
+ tree vlist;
+{
+ tree decl, current, returned_type, type_wfl, init_stmt = NULL_TREE;
+ int must_chain = 0;
+
+ /* Push a new block if statement were seen between the last time we
+ pushed a block and now. Keep a cound of block to close */
+ if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)))
+ {
+ tree body = DECL_FUNCTION_BODY (current_function_decl);
+ tree b = enter_block ();
+ BLOCK_EXPR_ORIGIN(b) = body;
+ }
+
+ if (modifier)
+ {
+ int i;
+ for (i = 0; i <= 10; i++) if (1 << i & modifier) break;
+ parse_error_context
+ (ctxp->modifier_ctx [i],
+ (modifier == ACC_FINAL ?
+ "Unsupported JDK1.1 `final' locals" :
+ "Only `final' is allowed as a local variables modifier"));
+ return;
+ }
+
+ if (unresolved_type_p (type, &returned_type))
+ {
+ if (returned_type)
+ type = returned_type;
+ else
+ {
+ type_wfl = type;
+ type = obtain_incomplete_type (type);
+ must_chain = 1;
+ }
+ }
+
+ for (current = vlist; current; current = TREE_CHAIN (current))
+ {
+ tree wfl = TREE_PURPOSE (current);
+ tree name = EXPR_WFL_NODE (wfl);
+ tree init = TREE_VALUE (current);
+ tree other = lookup_name_in_blocks (name);
+
+ /* Don't try to use an INIT statement when an error was found */
+ if (init && java_error_count)
+ init = NULL_TREE;
+
+ if (other)
+ parse_error_context
+ (wfl, "Variable `%s' is already defined in this method and was "
+ "declared `%s %s' in line %d",
+ IDENTIFIER_POINTER (name), lang_printable_name (TREE_TYPE (other)),
+ IDENTIFIER_POINTER (name), DECL_SOURCE_LINE (other));
+ else
+ {
+ if (!must_chain && TREE_CODE (type) == RECORD_TYPE)
+ type = promote_type (type);
+ /* Never layout this decl. This will be done when its scope
+ will be entered */
+ decl = build_decl_no_layout (VAR_DECL, name, type);
+ BLOCK_CHAIN_DECL (decl);
+
+ /* Add the initialization function to the current function's code */
+ if (init)
+ {
+ tree wfl;
+ MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
+ java_method_add_stmt
+ (current_function_decl,
+ build_debugable_stmt (EXPR_WFL_LINECOL (init), init));
+ }
+
+ if (must_chain)
+ {
+ jdep *dep;
+ register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
+ dep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
+ }
+ }
+ }
+ SOURCE_FRONTEND_DEBUG (("Defined locals"));
+}
+
+/* Called during parsing. Build decls from argument list. */
+
+static void
+source_start_java_method (fndecl)
+ tree fndecl;
+{
+ tree tem;
+ tree parm_decl;
+ int i;
+
+ extern tree current_binding_level;
+ current_function_decl = fndecl;
+
+ /* New scope for the function */
+ enter_block ();
+ for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
+ tem != NULL_TREE; tem = TREE_CHAIN (tem), i++)
+ {
+ tree type = TREE_VALUE (tem);
+ tree name = TREE_PURPOSE (tem);
+
+ /* If type is incomplete. Layout can't take place
+ now. Create an incomplete decl and ask for the decl to be
+ patched later */
+ if (INCOMPLETE_TYPE_P (type))
+ {
+ jdep *jdep;
+ parm_decl = build_decl_no_layout (PARM_DECL, name, type);
+
+ register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
+ jdep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_MISC (jdep) = name;
+ JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
+ }
+ else
+ parm_decl = build_decl (PARM_DECL, name, type);
+
+ BLOCK_CHAIN_DECL (parm_decl);
+ }
+ tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
+ BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
+ nreverse (tem);
+ DECL_ARG_SLOT_COUNT (current_function_decl) = i;
+}
+
+/* Called during expansion. Push decls formerly built from argument
+ list so they're usable during expansion. */
+
+static void
+expand_start_java_method (fndecl)
+ tree fndecl;
+{
+ tree tem, *ptr;
+ tree parm_decl;
+
+ extern tree current_binding_level;
+ current_function_decl = fndecl;
+
+ announce_function (fndecl);
+ pushlevel (1); /* Push parameters */
+ ptr = &DECL_ARGUMENTS (fndecl);
+ tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
+ while (tem)
+ {
+ tree next = TREE_CHAIN (tem);
+ DECL_ARG_TYPE (tem) = TREE_TYPE (tem);
+ layout_decl (tem, 0);
+ pushdecl (tem);
+ INITIALIZED_P (tem) = 1; /* Parms are initialized */
+ *ptr = tem;
+ ptr = &TREE_CHAIN (tem);
+ tem = next;
+ }
+ *ptr = NULL_TREE;
+ pushdecl_force_head (DECL_ARGUMENTS (fndecl));
+ lineno = DECL_SOURCE_LINE_FIRST (fndecl);
+ complete_start_java_method (fndecl);
+}
+
+/* Terminate a function and expand its body. */
+
+static void
+source_end_java_method ()
+{
+ tree fndecl = current_function_decl;
+
+ java_parser_context_save_global ();
+ lineno = ctxp->last_ccb_indent1;
+
+ /* Generate function's code */
+ if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
+ && ! flag_emit_class_files)
+ expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
+
+ /* pop out of its parameters */
+ pushdecl_force_head (DECL_ARGUMENTS (fndecl));
+ poplevel (1, 0, 1);
+ BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
+
+ /* Generate rtl for function exit. */
+ if (! flag_emit_class_files)
+ {
+ lineno = DECL_SOURCE_LINE_LAST (fndecl);
+ expand_function_end (input_filename, lineno, 0);
+
+ /* Run the optimizers and output assembler code for this function. */
+ rest_of_compilation (fndecl);
+ }
+
+ current_function_decl = NULL_TREE;
+ /* permanent_allocation (1); */
+ java_parser_context_restore_global ();
+}
+
+/* Record EXPR in the current function block. Complements compound
+ expression second operand if necessary. */
+
+tree
+java_method_add_stmt (fndecl, expr)
+ tree fndecl, expr;
+{
+ tree body = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl));
+ tree node;
+
+ if (java_error_count)
+ return body;
+ if ((node = add_stmt_to_compound (body, NULL_TREE, expr)) == body)
+ return body;
+
+ BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = node;
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* Add STMT to EXISTING if possible, otherwise create a new
+ COMPOUND_EXPR and add STMT to it. */
+
+static tree
+add_stmt_to_compound (existing, type, stmt)
+ tree existing, type, stmt;
+{
+ tree node;
+
+ if (existing && (TREE_CODE (existing) == COMPOUND_EXPR)
+ && TREE_OPERAND (existing, 1) == size_zero_node)
+ {
+ TREE_OPERAND (existing, 1) = stmt;
+ TREE_TYPE (existing) = type;
+ return existing;
+ }
+ else if (existing)
+ node = build (COMPOUND_EXPR, type, existing, stmt);
+ else
+ node = build (COMPOUND_EXPR, type, stmt, size_zero_node);
+
+ return node;
+}
+
+/* Hold THIS for the scope of the current public method decl. */
+static tree current_this;
+
+/* Layout all class found during parsing */
+
+void
+java_layout_classes ()
+{
+ tree current;
+ for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+ {
+ current_class = TREE_TYPE (current);
+ TYPE_FIELDS (current_class) = nreverse (TYPE_FIELDS (current_class));
+ if (!TYPE_SIZE (current_class))
+ safe_layout_class (current_class);
+ }
+}
+
+/* Expand all methods in all registered classes. */
+
+void
+java_complete_expand_methods ()
+{
+ tree current;
+
+ for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+ {
+ extern tree current_constant_pool_data_ref;
+ tree class_type = CLASS_TO_HANDLE_TYPE (TREE_TYPE (current));
+ tree decl;
+ int saved_lineno;
+
+ current_class = TREE_TYPE (current);
+
+ /* Initialize a new constant pool */
+ init_outgoing_cpool ();
+
+ /* Don't process function bodies in interfaces */
+ if (!CLASS_INTERFACE (TYPE_NAME (current_class)))
+ for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
+ {
+ current_function_decl = decl;
+ /* Don't generate debug info on line zero when expanding a
+ generated constructor. */
+ if (DECL_CONSTRUCTOR_P (decl) && !DECL_FUNCTION_BODY (decl))
+ {
+ /* If we found errors, it's too dangerous to try to generate
+ and expand a constructor */
+ if (!java_error_count)
+ {
+ restore_line_number_status (1);
+ java_complete_expand_method (decl);
+ restore_line_number_status (0);
+ }
+ }
+ else
+ java_complete_expand_method (decl);
+ }
+
+ /* Make the class data, register it and run the rest of decl
+ compilation on it */
+ if (!java_error_count && ! flag_emit_class_files)
+ {
+ make_class_data (current_class);
+ register_class ();
+ rest_of_decl_compilation (TYPE_NAME (current_class), (char*) 0, 1, 0);
+ }
+ }
+}
+
+/* Complete and expand a method. */
+
+static void
+java_complete_expand_method (mdecl)
+ tree mdecl;
+{
+ tree node;
+ jdep *current;
+ int no_ac_found = 1;
+
+ /* We generate some code for an empty constructor */
+ if (DECL_CONSTRUCTOR_P (mdecl) && !DECL_FUNCTION_BODY (mdecl))
+ {
+ tree arg_list, func, call;
+ tree method_type = TREE_TYPE (mdecl);
+ tree class_type = CLASS_TO_HANDLE_TYPE (current_class);
+ tree self_type = (CLASSTYPE_SUPER (class_type) ?
+ CLASSTYPE_SUPER (class_type) : class_type);
+ tree method_signature =
+ TYPE_LANG_SPECIFIC (method_type)->signature;
+ tree method =
+ lookup_java_constructor (CLASS_TO_HANDLE_TYPE (self_type),
+ method_signature);
+ tree block, compound;
+
+ /* Fixe the begining/ending lines of the method so that with
+ no_line_numbers set to 1 it doesn't generate debug info at
+ line 1 for this artificial constructor. */
+ DECL_SOURCE_LINE (mdecl) = 1;
+ DECL_SOURCE_LINE_MERGE (mdecl, 1);
+ source_start_java_method (mdecl);
+ arg_list = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl));
+ enter_block ();
+ func = build_known_method_ref (method, method_type, self_type,
+ method_signature, arg_list);
+
+ if (! flag_emit_class_files)
+ func = build1 (NOP_EXPR, build_pointer_type (method_type), func);
+ call = build (CALL_EXPR, TREE_TYPE (method_type), func,
+ build_tree_list (NULL_TREE, arg_list), NULL_TREE);
+ TREE_SIDE_EFFECTS (call) = 1;
+ call = build_class_init (self_type, call);
+ compound = java_method_add_stmt (mdecl, call);
+ block = exit_block ();
+ BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = block;
+ /* The function decl, its block and the compound statement
+ within this block are all of void type. */
+ TREE_TYPE (block) = TREE_TYPE (compound) =
+ TREE_TYPE (DECL_FUNCTION_BODY (mdecl)) = void_type_node;
+ exit_block ();
+ no_ac_found = 0;
+ }
+
+ if (DECL_FUNCTION_BODY (mdecl))
+ {
+ expand_start_java_method (mdecl);
+
+ current_this
+ = (!METHOD_STATIC (mdecl) ?
+ BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
+
+ if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) && no_ac_found)
+ java_complete_tree (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)));
+ /* Don't go any further if we've found error(s) during the
+ expansion */
+ if (!java_error_count)
+ source_end_java_method ();
+ }
+}
+
+/* Expand finals. */
+
+void
+java_expand_finals ()
+{
+}
+
+/* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
+ a tree list node containing RIGHT. Fore coming RIGHTs will be
+ chained to this hook. LOCATION contains the location of the
+ separating `.' operator. */
+
+static tree
+make_qualified_primary (primary, right, location)
+ tree primary, right;
+ int location;
+{
+ tree wfl;
+
+ /* We want to process THIS . xxx symbolicaly, to keep it consistent
+ with the way we're processing SUPER. A THIS from a primary as a
+ different form than a SUPER. Turn THIS into something symbolic */
+ if (TREE_CODE (primary) == JAVA_THIS_EXPR)
+ {
+ wfl = build_wfl_node (this_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary);
+ wfl = make_qualified_name (wfl, right, location);
+ PRIMARY_P (wfl) = 1;
+ return wfl;
+ }
+ /* Other non WFL node are wrapped around a WFL */
+ else if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
+ {
+ wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary);
+ EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (primary, NULL_TREE);
+ }
+ else
+ {
+ wfl = primary;
+ if (!EXPR_WFL_QUALIFICATION (primary))
+ EXPR_WFL_QUALIFICATION (primary) =
+ build_tree_list (primary, NULL_TREE);
+ }
+
+ EXPR_WFL_LINECOL (right) = location;
+ chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
+ PRIMARY_P (wfl) = 1;
+ return wfl;
+}
+
+/* Simple merge of two name separated by a `.' */
+
+static tree
+merge_qualified_name (left, right)
+ tree left, right;
+{
+ tree node;
+ obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
+ IDENTIFIER_LENGTH (left));
+ obstack_1grow (&temporary_obstack, '.');
+ obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
+ IDENTIFIER_LENGTH (right));
+ node = get_identifier (obstack_base (&temporary_obstack));
+ obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
+ QUALIFIED_P (node) = 1;
+ return node;
+}
+
+/* Merge the two parts of a qualified name into LEFT. Set the
+ location information of the resulting node to LOCATION, usually
+ inherited from the location information of the `.' operator. */
+
+static tree
+make_qualified_name (left, right, location)
+ tree left, right;
+ int location;
+{
+ int qualified;
+ tree left_id = EXPR_WFL_NODE (left);
+ tree right_id = EXPR_WFL_NODE (right);
+ tree wfl, merge;
+
+ merge = merge_qualified_name (left_id, right_id);
+
+ /* Left wasn't qualified and is now qualified */
+ if (!QUALIFIED_P (left_id))
+ {
+ tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
+ EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
+ }
+
+ wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = location;
+ chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
+
+ EXPR_WFL_NODE (left) = merge;
+ return left;
+}
+
+/* Extract the last identifier component of the qualified in WFL. The
+ last identifier is removed from the linked list */
+
+static tree
+cut_identifier_in_qualified (wfl)
+ tree wfl;
+{
+ tree q;
+ tree previous = NULL_TREE;
+ for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
+ if (!TREE_CHAIN (q))
+ {
+ if (!previous)
+ fatal ("Operating on a non qualified qualified WFL - "
+ "cut_identifier_in_qualified");
+ TREE_CHAIN (previous) = NULL_TREE;
+ return TREE_PURPOSE (q);
+ }
+}
+
+/* Resolve the expression name NAME. Return its decl. */
+
+static tree
+resolve_expression_name (id)
+ tree id;
+{
+ tree name = EXPR_WFL_NODE (id);
+ tree decl;
+
+ /* 6.5.5.1: Simple expression names */
+ if (!PRIMARY_P (id) && !QUALIFIED_P (name))
+ {
+ /* 15.13.1: NAME can appear within the scope of a local variable
+ declaration */
+ if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
+ return decl;
+
+ /* 15.13.1: NAME can appear within a class declaration */
+ else
+ {
+ decl = lookup_field_wrapper (current_class, name);
+ if (decl)
+ {
+ int fs = FIELD_STATIC (decl);
+ /* Instance variable (8.3.1.1) can't appear within
+ static method, static initializer or initializer for
+ a static variable. */
+ if (!fs && METHOD_STATIC (current_function_decl))
+ {
+ parse_error_context
+ (id, "Can't make a static reference to nonstatic variable "
+ "`%s' in class `%s'",
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (DECL_NAME
+ (TYPE_NAME (current_class))));
+ return error_mark_node;
+ }
+ decl = build_field_ref ((fs ? NULL_TREE : current_this),
+ current_class, name);
+ return (fs ? build_class_init (current_class, decl) : decl);
+ }
+ /* Fall down to error report on undefined variable */
+ }
+ }
+ /* 6.5.5.2 Qualified Expression Names */
+ else
+ {
+ qualify_ambiguous_name (id);
+ /* 15.10.1 Field Access Using a Primary and/or Expression Name */
+ /* 15.10.2: Accessing Superclass Members using super */
+ return resolve_field_access (id, NULL, NULL);
+ }
+
+ /* We've got an error here */
+ parse_error_context (id, "Undefined variable `%s'",
+ IDENTIFIER_POINTER (name));
+
+ return error_mark_node;
+}
+
+/* 15.10.1 Field Acess Using a Primary and/or Expression Name.
+ We return something suitable to generate the field access. We also
+ return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
+ recipient's address can be null. */
+
+static tree
+resolve_field_access (qual_wfl, field_decl, field_type)
+ tree qual_wfl;
+ tree *field_decl, *field_type;
+{
+ int is_static = 0;
+ tree field_ref;
+ tree decl, where_found, type_found;
+
+ if (resolve_qualified_expression_name (qual_wfl, &decl,
+ &where_found, &type_found))
+ return error_mark_node;
+
+ /* Resolve the LENGTH field of an array here */
+ if (DECL_NAME (decl) == length_identifier_node && TYPE_ARRAY_P (type_found)
+ && ! flag_emit_class_files)
+ {
+ tree length = build_java_array_length_access (where_found);
+ field_ref =
+ build_java_arraynull_check (type_found, length, int_type_node);
+ }
+ /* We might have been trying to resolve field.method(). In which
+ case, the resolution is over and decl is the answer */
+ else if (DECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
+ field_ref = decl;
+ else if (DECL_P (decl))
+ {
+ is_static = DECL_P (decl) && FIELD_STATIC (decl);
+ field_ref = build_field_ref ((is_static ? NULL_TREE : where_found),
+ type_found, DECL_NAME (decl));
+ if (field_ref == error_mark_node)
+ return error_mark_node;
+ if (is_static)
+ {
+ field_ref = build_class_init (type_found, field_ref);
+ /* If the static field was identified by an expression that
+ needs to be generated, make the field access a compound
+ expression whose first part of the evaluation of the
+ field selector part. */
+ if (where_found && TREE_CODE (where_found) != TYPE_DECL)
+ {
+ tree type = QUAL_DECL_TYPE (field_ref);
+ field_ref = build (COMPOUND_EXPR, type, where_found, field_ref);
+ }
+ }
+ }
+ else
+ field_ref = decl;
+
+ if (field_decl)
+ *field_decl = decl;
+ if (field_type)
+ *field_type = QUAL_DECL_TYPE (decl);
+ return field_ref;
+}
+
+/* 6.5.5.2: Qualified Expression Names */
+
+static int
+resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
+ tree wfl;
+ tree *found_decl, *type_found, *where_found;
+{
+ int from_type = 0; /* Field search initiated from a type */
+ int from_super = 0, from_cast = 0;
+ int previous_call_static = 0;
+ int is_static;
+ tree decl = NULL_TREE, type = NULL_TREE, q;
+ *where_found = NULL_TREE;
+
+ for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
+ {
+ tree qual_wfl = QUAL_WFL (q);
+
+ /* 15.10.1 Field Access Using a Primary */
+
+ switch (TREE_CODE (qual_wfl))
+ {
+ case CALL_EXPR:
+ case JAVA_NEW_CLASS_EXPR:
+ /* If the access to the function call is a non static field,
+ build the code to access it. */
+ if (DECL_P (decl) && !FIELD_STATIC (decl))
+ {
+ decl = maybe_access_field (decl, *where_found, type);
+ if (decl == error_mark_node)
+ return 1;
+ }
+ /* And code for the function call */
+ if (complete_function_arguments (qual_wfl))
+ return 1;
+ *where_found =
+ patch_method_invocation_stmt (qual_wfl, decl, type, &is_static);
+ if (*where_found == error_mark_node)
+ return 1;
+ *type_found = type = QUAL_DECL_TYPE (*where_found);
+
+ /* If the previous call was static and this one is too,
+ build a compound expression to hold the two (because in
+ that case, previous function calls aren't transported as
+ forcoming function's argument. */
+ if (previous_call_static && is_static)
+ {
+ decl = build (COMPOUND_EXPR, type, decl, *where_found);
+ TREE_SIDE_EFFECTS (decl) = 1;
+ }
+ else
+ {
+ previous_call_static = is_static;
+ decl = *where_found;
+ }
+ continue;
+
+ case CONVERT_EXPR:
+ *where_found = decl = java_complete_tree (qual_wfl);
+ if (decl == error_mark_node)
+ return 1;
+ *type_found = type = QUAL_DECL_TYPE (decl);
+ from_cast = 1;
+ continue;
+
+ case ARRAY_REF:
+ /* If the access to the function call is a non static field,
+ build the code to access it. */
+ if (DECL_P (decl) && !FIELD_STATIC (decl))
+ {
+ decl = maybe_access_field (decl, *where_found, type);
+ if (decl == error_mark_node)
+ return 1;
+ }
+ /* And code for the array reference expression */
+ decl = java_complete_tree (qual_wfl);
+ if (decl == error_mark_node)
+ return 1;
+ type = QUAL_DECL_TYPE (decl);
+ continue;
+ }
+
+ /* If we fall here, we weren't processing a (static) function call. */
+ previous_call_static = 0;
+
+ /* It can be the keyword THIS */
+ if (EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
+ {
+ if (!current_this)
+ {
+ parse_error_context
+ (wfl, "Keyword `this' used outside allowed context");
+ return 1;
+ }
+ /* We have to generate code for intermediate acess */
+ *where_found = decl = current_this;
+ type = QUAL_DECL_TYPE (decl);
+ continue;
+ }
+
+ /* 15.10.2 Accessing Superclass Members using SUPER */
+ if (EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
+ {
+ tree node;
+ /* Check on the restricted use of SUPER */
+ if (METHOD_STATIC (current_function_decl)
+ || current_class == object_type_node)
+ {
+ parse_error_context
+ (wfl, "Keyword `super' used outside allowed context");
+ return 1;
+ }
+ /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
+ node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
+ CLASSTYPE_SUPER (current_class),
+ build_this (EXPR_WFL_LINECOL (qual_wfl)));
+ *where_found = decl = java_complete_tree (node);
+ *type_found = type = QUAL_DECL_TYPE (decl);
+ from_super = from_type = 1;
+ continue;
+ }
+
+ /* 15.13.1: Can't search for field name in packages, so we
+ assume a variable/class name was meant. */
+ if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
+ {
+ if (from_super || from_cast)
+ parse_error_context
+ ((from_cast ? qual_wfl : wfl),
+ "No variable `%s' defined in class `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
+ lang_printable_name (type));
+ else
+ parse_error_context
+ (qual_wfl, "Undefined variable or class name: `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)));
+ return 1;
+ }
+
+ /* We have a type name. It's been already resolved when the
+ expression was qualified. */
+ else if (RESOLVE_TYPE_NAME_P (qual_wfl))
+ {
+ if (!(decl = QUAL_RESOLUTION (q)))
+ return 1; /* Error reported already */
+
+ if (not_accessible_p (TREE_TYPE (decl), decl, 0))
+ {
+ parse_error_context
+ (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
+ java_accstring_lookup (get_access_flags_from_decl (decl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))),
+ IDENTIFIER_POINTER (DECL_NAME (decl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
+ return 1;
+ }
+
+ type = TREE_TYPE (decl);
+ from_type = 1;
+ }
+ /* We resolve and expression name */
+ else
+ {
+ tree field_decl;
+
+ /* If there exists an early resolution, use it. That occurs
+ only once and we know that there are more things to
+ come. Don't do that when processing something after SUPER
+ (we need more thing to be put in place below */
+ if (!from_super && QUAL_RESOLUTION (q))
+ decl = QUAL_RESOLUTION (q);
+
+ /* We have to search for a field, knowing the type of its
+ container. The flag FROM_TYPE indicates that we resolved
+ the last member of the expression as a type name, which
+ means that for the resolution of this field, will check
+ on other errors than if the it was resolved as a member
+ of an other field. */
+ else
+ {
+ int is_static;
+ if (!from_type && !JREFERENCE_TYPE_P (type))
+ {
+ parse_error_context
+ (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
+ lang_printable_name (type),
+ IDENTIFIER_POINTER (DECL_NAME (field_decl)));
+ return 1;
+ }
+
+ if (!(field_decl =
+ lookup_field_wrapper (type, EXPR_WFL_NODE (qual_wfl))))
+ {
+ parse_error_context
+ (qual_wfl, "No variable `%s' defined in class `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
+ return 1;
+ }
+
+ /* Check on accessibility here */
+ if (not_accessible_p (type, field_decl, from_super))
+ {
+ parse_error_context
+ (qual_wfl,
+ "Can't access %s field `%s.%s' from `%s'",
+ java_accstring_lookup
+ (get_access_flags_from_decl (field_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))),
+ IDENTIFIER_POINTER (DECL_NAME (field_decl)),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (current_class))));
+ return 1;
+ }
+
+ /* There are things to check when fields are accessed
+ from type. There are no restrictions on a static
+ declaration of the field when it is accessed from an
+ interface */
+ is_static = FIELD_STATIC (field_decl);
+ if (!from_super && from_type
+ && !TYPE_INTERFACE_P (type) && !is_static)
+ {
+ parse_error_context
+ (qual_wfl, "Can't make a static reference to nonstatic "
+ "variable `%s' in class `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
+ return 1;
+ }
+ from_cast = from_super = 0;
+
+ /* If we need to generate something to get a proper handle
+ on what this field is accessed from, do it now. */
+ if (!is_static)
+ {
+ decl = maybe_access_field (decl, *where_found, type);
+ if (decl == error_mark_node)
+ return 1;
+ }
+
+ /* We want to keep the location were found it, and the type
+ we found. */
+ *where_found = decl;
+ *type_found = type;
+
+ /* This is the decl found and eventually the next one to
+ search from */
+ decl = field_decl;
+ }
+
+ from_type = 0;
+ type = QUAL_DECL_TYPE (decl);
+ }
+ }
+ *found_decl = decl;
+ return 0;
+}
+
+/* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
+ can't be accessed from REFERENCE (a record type). */
+
+int not_accessible_p (reference, member, from_super)
+ tree reference, member;
+ int from_super;
+{
+ int access_flag = get_access_flags_from_decl (member);
+
+ /* Access always granted for members declared public */
+ if (access_flag & ACC_PUBLIC)
+ return 0;
+
+ /* Check access on protected members */
+ if (access_flag & ACC_PROTECTED)
+ {
+ /* Access granted if it occurs from within the package
+ containing the class in which the protected member is
+ declared */
+ if (class_in_current_package (DECL_CONTEXT (member)))
+ return 0;
+
+ if (TREE_CODE (member) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (member))
+ {
+ /* Access from SUPER is granted */
+ if (from_super)
+ return 0;
+ /* Otherwise, access isn't granted */
+ return 1;
+ }
+ else
+ {
+ /* If accessed with the form `super.member', then access is
+ granted */
+ if (from_super)
+ return 0;
+
+ /* Otherwise, access is granted if occuring from the class where
+ member is declared or a subclass of it */
+ if (inherits_from_p (reference, current_class))
+ return 0;
+ }
+ return 1;
+ }
+
+ /* Check access on private members. Access is granted only if it
+ occurs from within the class in witch it is declared*/
+
+ if (access_flag & ACC_PRIVATE)
+ return (current_class == DECL_CONTEXT (member) ? 0 : 1);
+
+ /* Default access are permitted only when occuring within the
+ package in which the type (REFERENCE) is declared. In other words,
+ REFERENCE is defined in the current package */
+ if (ctxp->package)
+ return !class_in_current_package (reference);
+
+ /* Otherwise, access is granted */
+ return 0;
+}
+
+/* Returns 1 if class was declared in the current package, 0 otherwise */
+
+static int
+class_in_current_package (class)
+ tree class;
+{
+ static tree cache = NULL_TREE;
+ int qualified_flag;
+ tree left;
+
+ if (cache == class)
+ return 1;
+
+ qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
+
+ /* If the current package is empty and the name of CLASS is
+ qualified, class isn't in the current package. If there is a
+ current package and the name of the CLASS is not qualified, class
+ isn't in the current package */
+ if (!ctxp->package && qualified_flag || ctxp->package && !qualified_flag)
+ return 0;
+
+ /* If there is not package and the name of CLASS isn't qualified,
+ they belong to the same unnamed package */
+ if (!ctxp->package && !qualified_flag)
+ return 1;
+
+ /* Compare the left part of the name of CLASS with the package name */
+ breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
+ if (ctxp->package == left)
+ {
+ cache = class;
+ return 1;
+ }
+ return 0;
+}
+
+/* This function may generate code to access DECL from WHERE. This is
+ done only if certain conditions meet. */
+
+static tree
+maybe_access_field (decl, where, type)
+ tree decl, where, type;
+{
+ if (DECL_P (decl) && decl != current_this
+ && (!(TREE_CODE (decl) != PARM_DECL
+ && FIELD_STATIC (decl)))
+ && !IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)))
+ decl = build_field_ref (where ? where : current_this,
+ type, DECL_NAME (decl));
+ return decl;
+}
+
+/* Build a method invocation statement, by patching PATCH. If non NULL
+ and according to the situation, PRIMARY and WHERE may be
+ used. IS_STATIC is set to 1 if the invoked function is static. */
+
+static tree
+patch_method_invocation_stmt (patch, primary, where, is_static)
+ tree patch, primary, where;
+ int *is_static;
+{
+ tree wfl = TREE_OPERAND (patch, 0);
+ tree args = TREE_OPERAND (patch, 1);
+ tree name = EXPR_WFL_NODE (wfl);
+ tree list, class_type;
+
+ /* Should be overriden if everything goes well. Otherwise, if
+ something fails, it should keep this value. It stop the
+ evaluation of a bogus assignment. See java_complete_tree,
+ MODIFY_EXPR: for the reasons why we sometimes want to keep on
+ evaluating an assignment */
+ TREE_TYPE (patch) = error_mark_node;
+
+ /* Since lookup functions are messing with line numbers, save the
+ context now. */
+ java_parser_context_save_global ();
+
+ /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
+
+ /* Resolution of qualified name, excluding constructors */
+ if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
+ {
+ tree class_decl, identifier, identifier_wfl;
+ /* Extract the last IDENTIFIER of the qualified
+ expression. This is a wfl and we will use it's location
+ data during error report. */
+ identifier_wfl = cut_identifier_in_qualified (wfl);
+ identifier = EXPR_WFL_NODE (identifier_wfl);
+
+ /* Given the context, IDENTIFIER is syntactically qualified
+ as a MethodName. We need to qualify what's before */
+ qualify_ambiguous_name (wfl);
+
+ /* Package resolution are erroneous */
+ if (RESOLVE_PACKAGE_NAME_P (wfl))
+ {
+ tree remainder;
+ breakdown_qualified (&remainder, NULL, EXPR_WFL_NODE (wfl));
+ parse_error_context (wfl, "Can't search method `%s' in package "
+ "`%s'",IDENTIFIER_POINTER (identifier),
+ IDENTIFIER_POINTER (remainder));
+ return error_mark_node;
+ }
+ /* We're resolving a call from a type */
+ else if (RESOLVE_TYPE_NAME_P (wfl))
+ {
+ tree decl = QUAL_RESOLUTION (EXPR_WFL_QUALIFICATION (wfl));
+ tree name = DECL_NAME (decl);
+ tree type;
+
+ class_decl = resolve_and_layout (name, wfl);
+ if (CLASS_INTERFACE (decl))
+ {
+ parse_error_context
+ (identifier_wfl, "Can't make static reference to method "
+ "`%s' in interface `%s'", IDENTIFIER_POINTER (identifier),
+ IDENTIFIER_POINTER (name));
+ return error_mark_node;
+ }
+ /* Look the method up in the type selector. The method ought
+ to be static. */
+ type = TREE_TYPE (class_decl);
+ list = lookup_method_invoke (0, wfl, type, identifier, args);
+ if (list && !METHOD_STATIC (list))
+ {
+ char *fct_name = strdup ((char *)lang_printable_name (list));
+ parse_error_context
+ (identifier_wfl,
+ "Can't make static reference to method `%s %s' in class `%s'",
+ lang_printable_name (TREE_TYPE (TREE_TYPE (list))), fct_name,
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
+ free (fct_name);
+ return error_mark_node;
+ }
+ }
+ /* We're resolving an expression name */
+ else
+ {
+ tree field, type;
+
+ /* 1- Find the field to which the call applies */
+ field = resolve_field_access (wfl, NULL, &type);
+ if (field == error_mark_node)
+ return error_mark_node;
+
+ /* 2- Do the layout of the class where the last field
+ was found, so we can search it. */
+ class_decl =
+ resolve_and_layout (DECL_NAME (TYPE_NAME (type)), NULL_TREE);
+
+ /* 3- Retrieve a filtered list of method matches, Refine
+ if necessary. In any cases, point out errors. */
+ list = lookup_method_invoke (0, identifier_wfl, type,
+ identifier, args);
+
+ /* 4- Add the field as an argument */
+ args = tree_cons (NULL_TREE, field, args);
+ }
+
+ /* CLASS_TYPE is used during the call to not_accessible_p and
+ IDENTIFIER_WFL will be used to report any problem further */
+ class_type = TREE_TYPE (class_decl);
+ wfl = identifier_wfl;
+ }
+ /* Resolution of simple names, names generated after a primary: or
+ constructors */
+ else
+ {
+ tree class_to_search;
+ int lc; /* Looking for Constructor */
+
+ /* We search constructor in their target class */
+ if (CALL_CONSTRUCTOR_P (patch))
+ {
+ class_to_search = resolve_no_layout (EXPR_WFL_NODE (wfl), NULL_TREE);
+ if (!class_to_search)
+ {
+ parse_error_context
+ (wfl, "Class `%s' not found in type declaration",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
+ return error_mark_node;
+ }
+
+ /* Can't instantiate an abstract class */
+ if (CLASS_ABSTRACT (class_to_search))
+ {
+ parse_error_context
+ (wfl, "Class `%s' is an abstract class. It can't be "
+ "instantiated", IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
+ return error_mark_node;
+ }
+ class_to_search = TREE_TYPE (class_to_search);
+ lc = 1;
+ }
+ /* This is a regular search in the local class, unless an
+ alternate class is specified. */
+ else
+ {
+ class_to_search = (where ? where : current_class);
+ lc = 0;
+ }
+
+ /* NAME is a simple identifier or comes from a primary. Search
+ in the class whose declaration contain the method being
+ invoked. */
+ list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
+
+ /* Don't continue if no method were found, as the next statement
+ can't be executed then. */
+ if (!list) return error_mark_node;
+
+ /* Check for static reference if non static methods */
+ if (check_for_static_method_reference (wfl, patch, list,
+ class_to_search, primary))
+ return error_mark_node;
+
+ /* Non static/constructor methods are called with the current
+ object extra argument. If method is resolved as a primary,
+ use the primary otherwise use the current THIS. */
+ if (!CALL_CONSTRUCTOR_P (patch) && !METHOD_STATIC (list))
+ args = tree_cons (NULL_TREE, primary ? primary : current_this, args);
+
+ class_type = class_to_search;
+ }
+
+ /* Merge point of all resolution schemes. If we have nothing, this
+ is an error, already signaled */
+ if (!list) return error_mark_node;
+
+ /* Check accessibility, position the is_static flag, build and
+ return the call */
+ if (not_accessible_p (class_type, list, 0))
+ {
+ char *fct_name = strdup ((char *)lang_printable_name (list));
+ parse_error_context
+ (wfl, "Can't access %s method `%s %s.%s' from `%s'",
+ java_accstring_lookup (get_access_flags_from_decl (list)),
+ lang_printable_name (TREE_TYPE (TREE_TYPE (list))),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))), fct_name,
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
+ free (fct_name);
+ return error_mark_node;
+ }
+
+ if (is_static)
+ *is_static = METHOD_STATIC (list);
+ java_parser_context_restore_global ();
+ return patch_invoke (patch, list, args, wfl);
+}
+
+/* Check that we're not trying to do a static reference to a method in
+ non static method. Return 1 if it's the case, 0 otherwise. */
+
+static int
+check_for_static_method_reference (wfl, node, method, where, primary)
+ tree wfl, node, method, where, primary;
+{
+ if (METHOD_STATIC (current_function_decl)
+ && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
+ {
+ char *fct_name = strdup ((char *)lang_printable_name (method));
+ parse_error_context
+ (wfl, "Can't make static reference to method `%s %s' in class `%s'",
+ lang_printable_name (TREE_TYPE (TREE_TYPE (method))), fct_name,
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
+ free (fct_name);
+ return 1;
+ }
+ return 0;
+}
+
+/* Patch an invoke expression METHOD and ARGS, based on its invocation
+ mode. */
+
+static tree
+patch_invoke (patch, method, args, cl)
+ tree patch, method, args;
+ tree cl;
+{
+ tree dtable, func;
+ tree signature = build_java_signature (TREE_TYPE (method));
+ tree original_call;
+
+ switch (invocation_mode (method, 0))
+ {
+ case INVOKE_VIRTUAL:
+ dtable = invoke_build_dtable (0, args);
+ func = build_invokevirtual (dtable, method);
+ break;
+ case INVOKE_STATIC:
+ func = build_known_method_ref (method, TREE_TYPE (method),
+ DECL_CONTEXT (method),
+ signature, args);
+ args = nreverse (args);
+ break;
+
+ default:
+ fatal ("Unknown invocation mode - build_invoke");
+ return NULL_TREE;
+ }
+
+
+ /* Ensure self_type is initialized, (invokestatic). FIXME */
+ func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
+ TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
+ TREE_OPERAND (patch, 0) = func;
+ TREE_OPERAND (patch, 1) = args;
+ original_call = patch;
+
+ /* We're calling a constructor. New is called an its returned value
+ is an argument to the constructor. We build a COMPOUND_EXPR and
+ use saved expression so that the overall NEW expression value is
+ a pointer to a newly created and initialized class. */
+ if (CALL_CONSTRUCTOR_P (original_call))
+ {
+ tree class = DECL_CONTEXT (method);
+ tree c1, saved_new, size, new;
+ if (!TYPE_SIZE (class))
+ safe_layout_class (class);
+ size = size_in_bytes (class);
+ new = build (CALL_EXPR, promote_type (class),
+ build_address_of (alloc_object_node),
+ tree_cons (NULL_TREE, build_class_ref (class),
+ build_tree_list (NULL_TREE,
+ size_in_bytes (class))),
+ NULL_TREE);
+ saved_new = save_expr (new);
+ c1 = build_tree_list (NULL_TREE, saved_new);
+ TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
+ TREE_OPERAND (original_call, 1) = c1;
+ TREE_SET_CODE (original_call, CALL_EXPR);
+ patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
+ }
+ return patch;
+}
+
+static int
+invocation_mode (method, super)
+ tree method;
+ int super;
+{
+ int access = get_access_flags_from_decl (method);
+
+ if (access & ACC_STATIC)
+ return INVOKE_STATIC;
+
+ if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
+ return INVOKE_STATIC;
+
+ if (super)
+ return INVOKE_SUPER;
+
+ if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
+ return INVOKE_INTERFACE;
+
+ if (DECL_CONSTRUCTOR_P (method))
+ return INVOKE_STATIC;
+
+ return INVOKE_VIRTUAL;
+}
+
+/* Retrieve a refined list of matching methods. */
+
+static tree
+lookup_method_invoke (lc, cl, class, name, arg_list)
+ int lc;
+ tree cl;
+ tree class, name, arg_list;
+{
+ tree method = make_node (FUNCTION_TYPE);
+ tree arg_type_list = NULL_TREE;
+ tree signature, list, node, scratch;
+
+ for (node = arg_list; node; node = TREE_CHAIN (node))
+ {
+ tree current_arg;
+ current_arg =
+ build_tree_list (NULL_TREE,
+ promote_type (TREE_TYPE (TREE_VALUE (node))));
+ arg_type_list = chainon (current_arg, arg_type_list);
+ }
+ TYPE_ARG_TYPES (method) = arg_type_list;
+
+ if (!lc)
+ {
+ signature = build_java_argument_signature (method);
+ list = match_java_method (class, name, signature);
+ list = refine_accessible_methods_list (lc, list);
+ }
+ else
+ {
+ TREE_TYPE (method) = void_type_node;
+ signature = build_java_signature (method);
+ list = lookup_java_constructor (class, signature);
+ }
+
+ if (!list)
+ {
+ parse_error_context (cl, "Can't find method `%s(%s)' in class `%s'",
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (signature),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class))));
+ return NULL_TREE;
+ }
+
+ if (lc)
+ return list;
+
+ if (TREE_CHAIN (list))
+ {
+ tree most_specific_list = NULL_TREE;
+ tree current;
+ /* 15.11.2.2 Choose the Most Specific Method */
+ for (current = list; current; current = TREE_CHAIN (current))
+ {
+ tree rest;
+ tree method = TREE_VALUE (list);
+ tree class_from = DECL_CONTEXT (method);
+ for (rest = TREE_CHAIN (current); rest; rest = TREE_CHAIN (rest))
+ {
+ tree other = TREE_VALUE (rest);
+
+ /* METHOD can be declared more specific with regard to OTHER iif:
+
+ - The class METHOD belongs can be converted to the
+ class OTHER belongs by method invocation conversion
+ (5.3). Since we're dealing with classes here, it is
+ covered by the identity conversion or the windening
+ primitive conversion.
+
+ - The types of the arguments of METHOD can be
+ converted to the types of the arguments of OTHER by
+ method invocation conversion (5.3). */
+
+ if (valid_ref_assignconv_cast_p (class_from,
+ DECL_CONTEXT (other), 0)
+ && 1) /* Test on args non implemented */
+ most_specific_list = tree_cons (NULL_TREE, method,
+ most_specific_list);
+ }
+ }
+ list = most_specific_list;
+ }
+
+ if (!list || TREE_CHAIN (list))
+ {
+ parse_error_context (cl, "Can't find method `%s(%s)' in class `%s'",
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (signature),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class))));
+ return NULL_TREE;
+ }
+
+ /* 15.11.3 Is the Chosen Method Appropriate ? */
+ else
+ return TREE_VALUE (list);
+}
+
+/* Refine accessible methods from the raw matching method list, as
+ specified in 15.11.4.3. Return a (possibly empty) new method
+ list. */
+
+static tree
+refine_accessible_methods_list (lc, list)
+ int lc; /* Looking for Constructor */
+ tree list;
+{
+#define ADD_TO_LIST_AND_CONTINUE \
+ { \
+ refined_list = tree_cons (NULL_TREE, method, refined_list); \
+ continue; \
+ }
+ tree node, refined_list = NULL_TREE;
+ tree current_class_name = DECL_NAME (TYPE_NAME (current_class));
+
+ for (node = list; node; node = TREE_CHAIN (node))
+ {
+ int access, identical;
+ tree class_from, method, class_from_name;
+
+ method = TREE_VALUE (node);
+
+ /* Constructor not retained here, unless were specifically
+ looking for them. */
+ if (lc && DECL_CONSTRUCTOR_P (method))
+ ADD_TO_LIST_AND_CONTINUE;
+
+ access = get_access_flags_from_decl (method);
+ class_from = DECL_CONTEXT (method);
+ class_from_name = DECL_NAME (TYPE_NAME (class_from));
+
+ identical = identical_subpath_p (current_class_name, class_from_name);
+
+ /* Check accessibility of class_from from the current one: This
+ test has been already carried out when qualify_ambiguous_name
+ tried to resolve a type found in an other package. It is not
+ necessary to retest things here, the error has been already
+ reported. */
+
+ /* Public method are always OK */
+ if (access & ACC_PUBLIC)
+ ADD_TO_LIST_AND_CONTINUE;
+
+ /* Protected method access is OK if classes are from the
+ same package or part of the same inheritance lineage */
+ if ((access & ACC_PROTECTED)
+ && (inherits_from_p (current_class, class_from) || identical))
+ ADD_TO_LIST_AND_CONTINUE;
+
+ /* Methods with default (package) access are OK if classes are
+ from the same default package. */
+ if (identical ||
+ (!QUALIFIED_P (class_from_name) && !QUALIFIED_P (current_class_name)))
+ ADD_TO_LIST_AND_CONTINUE;
+
+ /* Private method accessible iff current class is the node where
+ the method is defined */
+ if ((access & ACC_PRIVATE) && (class_from == current_class))
+ ADD_TO_LIST_AND_CONTINUE;
+ }
+#undef ADD_TO_LIST_AND_CONTINUE
+ return refined_list;
+}
+
+/* Qualification routines */
+
+static void
+qualify_ambiguous_name (id)
+ tree id;
+{
+ tree qual, qual_wfl, name, decl, ptr_type, saved_current_class;
+ int again, super_found = 0, this_found = 0;
+
+ /* We first qualify the first element, then derive qualification of
+ others based on the first one. If the first element is qualified
+ by a resolution (field or type), this resolution is stored in the
+ QUAL_RESOLUTION of the qual element being examined. We need to
+ save the current_class since the use of SUPER might change the
+ its value. */
+ saved_current_class = current_class;
+ qual = EXPR_WFL_QUALIFICATION (id);
+ do {
+
+ /* Simple qualified expression feature a qual_wfl that is a
+ WFL. Expression derived from a primary feature more complicated
+ things like a CALL_EXPR. Expression from primary need to be
+ worked out to extract the part on which the qualification will
+ take place. */
+ qual_wfl = QUAL_WFL (qual);
+ switch (TREE_CODE (qual_wfl))
+ {
+ case CALL_EXPR:
+ qual_wfl = TREE_OPERAND (qual_wfl, 0);
+ if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
+ {
+ qual = EXPR_WFL_QUALIFICATION (qual_wfl);
+ qual_wfl = QUAL_WFL (qual);
+ }
+ break;
+ case JAVA_NEW_CLASS_EXPR:
+ case CONVERT_EXPR:
+ case ARRAY_REF:
+ qual_wfl = TREE_OPERAND (qual_wfl, 0);
+ break;
+ }
+ name = EXPR_WFL_NODE (qual_wfl);
+ ptr_type = current_class;
+ again = 0;
+ /* If we have a THIS (from a primary), we set the context accordingly */
+ if (name == this_identifier_node)
+ {
+ qual = TREE_CHAIN (qual);
+ qual_wfl = QUAL_WFL (qual);
+ name = EXPR_WFL_NODE (qual_wfl);
+ this_found = 1;
+ }
+ /* If we have a SUPER, we set the context accordingly */
+ if (name == super_identifier_node)
+ {
+ current_class = CLASSTYPE_SUPER (ptr_type);
+ /* Check that there is such a thing as a super class. If not,
+ return. The error will be caught later on, during the
+ resolution */
+ if (!current_class)
+ {
+ current_class = saved_current_class;
+ return;
+ }
+ qual = TREE_CHAIN (qual);
+ /* Do one more interation to set things up */
+ super_found = again = 1;
+ }
+ } while (again);
+
+ /* If name appears within the scope of a location variable
+ declaration or parameter declaration, then it is an expression
+ name. We don't carry this test out if we're in the context of the
+ use of SUPER or THIS */
+
+ if (!this_found && !super_found && (decl = IDENTIFIER_LOCAL_VALUE (name)))
+ {
+ RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+ QUAL_RESOLUTION (qual) = decl;
+ }
+
+ /* If within the class/interface NAME was found to be used there
+ exists a (possibly inherited) field named NAME, then this is an
+ expression name. */
+ else if ((decl = lookup_field_wrapper (ptr_type, name)))
+ {
+ RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+ QUAL_RESOLUTION (qual) = decl;
+ }
+
+ /* We reclassify NAME as a type name if:
+ - NAME is a class/interface declared within the compilation
+ unit containing NAME,
+ - NAME is imported via a single-type-import declaration,
+ - NAME is declared in an another compilation unit of the package
+ of the compilation unit containing NAME,
+ - NAME is declared by exactly on type-import-on-demand declaration
+ of the compilation unit containing NAME. */
+ else if ((decl = resolve_and_layout (name, NULL_TREE)))
+ {
+ RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
+ QUAL_RESOLUTION (qual) = decl;
+ }
+
+ /* Method call are expression name */
+ else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR)
+ RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+
+ /* Check here that NAME isn't declared by more than one
+ type-import-on-demand declaration of the compilation unit
+ containing NAME. FIXME */
+
+ /* Otherwise, NAME is reclassified as a package name */
+ else
+ RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
+
+ /* Propagate the qualification accross other components of the
+ qualified name */
+ for (qual = TREE_CHAIN (qual); qual;
+ qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
+ {
+ if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
+ RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
+ else
+ RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
+ }
+
+ /* Store the global qualification for the ambiguous part of ID back
+ into ID fields */
+ if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
+ RESOLVE_EXPRESSION_NAME_P (id) = 1;
+ else if (RESOLVE_TYPE_NAME_P (qual_wfl))
+ RESOLVE_TYPE_NAME_P (id) = 1;
+ else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
+ RESOLVE_PACKAGE_NAME_P (id) = 1;
+
+ /* Restore the current class */
+ current_class = saved_current_class;
+}
+
+static int
+breakdown_qualified (left, right, source)
+ tree *left, *right, source;
+{
+ char *p = IDENTIFIER_POINTER (source), *base;
+ int l = IDENTIFIER_LENGTH (source);
+
+ /* Breakdown NAME into REMAINDER . IDENTIFIER */
+ base = p;
+ p += (l-1);
+ while (*p != '.' && p != base)
+ p--;
+
+ /* We didn't find a '.'. Return an error */
+ if (p == base)
+ return 1;
+
+ *p = '\0';
+ if (right)
+ *right = get_identifier (p+1);
+ *left = get_identifier (IDENTIFIER_POINTER (source));
+ *p = '.';
+
+ return 0;
+}
+
+/* Return 1 if N1 and N2 have identical sub-path. */
+
+static int
+identical_subpath_p (n1, n2)
+ tree n1, n2;
+{
+ tree left1, left2;
+
+ if (!QUALIFIED_P (n1) || !QUALIFIED_P (n2))
+ return n1 == n2;
+
+ breakdown_qualified (&left1, NULL, n1);
+ breakdown_qualified (&left2, NULL, n2);
+
+ return left1 == left2;
+}
+
+static int
+not_initialized_as_it_should_p (decl)
+ tree decl;
+{
+ if (DECL_P (decl))
+ {
+ if (TREE_CODE (decl) == FIELD_DECL
+ && METHOD_STATIC (current_function_decl))
+ return 0;
+ return DECL_P (decl) && !INITIALIZED_P (decl);
+ }
+ return 0;
+}
+
+/* Patch tree nodes in a function body. When a BLOCK is found, push
+ local variable decls if present. */
+
+static tree
+java_complete_tree (node)
+ tree node;
+{
+ tree nn, cn, wfl_op1, wfl_op2;
+ int flag, location;
+
+ /* CONVERT_EXPR always has its type set, even though it needs to be
+ worked out */
+ if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
+ return node;
+
+ /* The switch block implements cases processing container nodes
+ first. Contained nodes are always written back. Leaves come
+ next and return a value. */
+ switch (TREE_CODE (node))
+ {
+ case BLOCK:
+
+ /* 1- Block section.
+ Set the local values on decl names so we can identify them
+ faster when they're referenced. At that stage, identifiers
+ are legal so we don't check for declaration errors. */
+ for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
+ {
+ DECL_CONTEXT (cn) = current_function_decl;
+ IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
+ INITIALIZED_P (cn) = 0;
+ }
+ if (BLOCK_EXPR_BODY (node))
+ {
+ BLOCK_EXPR_BODY (node) = java_complete_tree (BLOCK_EXPR_BODY (node));
+ if (BLOCK_EXPR_BODY (node) == error_mark_node)
+ return error_mark_node;
+ }
+ /* Turn local bindings to null */
+ for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
+ IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
+
+ TREE_TYPE (node) = void_type_node;
+ break;
+
+ /* 2- They are expressions but ultimately deal with statements */
+ case LABELED_BLOCK_EXPR:
+ PUSH_LABELED_BLOCK (node);
+ if (LABELED_BLOCK_BODY (node))
+ COMPLETE_CHECK_OP_1 (node);
+ TREE_TYPE (node) = void_type_node;
+ POP_LABELED_BLOCK ();
+ return node;
+
+ case EXIT_BLOCK_EXPR:
+ /* We don't complete operand 1, because it's the return value of
+ the EXIT_BLOCK_EXPR which doesn't exist it Java */
+ return patch_bc_statement (node);
+
+ case LOOP_EXPR:
+ PUSH_LOOP (node);
+ /* Check whether the loop was enclosed in a labeled
+ statement. If not, create one, insert the loop in it and
+ return the node */
+ nn = patch_loop_statement (node);
+ /* Anyways, walk the body of the loop */
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
+ /* If we returned something different, that's because we
+ inserted a label. Pop the label too. */
+ if (nn != node)
+ POP_LABELED_BLOCK ();
+ POP_LOOP ();
+ return nn;
+
+ case EXIT_EXPR:
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ return patch_exit_expr (node);
+
+ case COND_EXPR:
+ /* Condition */
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ /* then-else branches */
+ TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
+ if (TREE_OPERAND (node, 2) == error_mark_node)
+ return error_mark_node;
+ return patch_if_else_statement (node);
+ break;
+
+ /* 3- Expression section */
+ case COMPOUND_EXPR:
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
+ break;
+
+ case RETURN_EXPR:
+ return patch_return (node);
+
+ case EXPR_WITH_FILE_LOCATION:
+ if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
+ || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
+ return resolve_expression_name (node);
+ else
+ {
+ EXPR_WFL_NODE (node) = java_complete_tree (EXPR_WFL_NODE (node));
+ TREE_SIDE_EFFECTS (node) = 1;
+ if (EXPR_WFL_NODE (node) == error_mark_node)
+ {
+ /* Its important for the evaluation of assignment that
+ this mark on the TREE_TYPE is propagated. */
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+ else
+ TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
+ }
+ break;
+
+ case JAVA_NEW_ARRAY_EXPR:
+ /* Patch all the dimensions */
+ flag = 0;
+ for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
+ {
+ int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
+ tree dim = java_complete_tree (TREE_VALUE (cn));
+ if (dim == error_mark_node)
+ {
+ flag = 1;
+ continue;
+ }
+ else
+ {
+ TREE_VALUE (cn) = save_expr (dim);
+ /* Setup the location of the current dimension, for
+ later error report. */
+ TREE_PURPOSE (cn) =
+ build_expr_wfl (NULL_TREE, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
+ }
+ }
+ /* They complete the array creation expression, if no errors
+ were found. */
+ return (flag ? error_mark_node : patch_newarray (node));
+
+ case JAVA_NEW_CLASS_EXPR:
+ case CALL_EXPR:
+ /* Complete function's argument first */
+ if (complete_function_arguments (node))
+ return error_mark_node;
+ else
+ return patch_method_invocation_stmt (node, NULL_TREE, NULL_TREE, NULL);
+
+ case MODIFY_EXPR:
+ /* Save potential wfls */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ wfl_op2 = TREE_OPERAND (node, 1);
+ TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+
+ if (COMPOUND_ASSIGN_P (wfl_op2))
+ {
+ tree lvalue;
+ tree other =
+ java_complete_tree (TREE_OPERAND (wfl_op2, 0));
+
+ /* Hand stablize the lhs on both places */
+ lvalue = stabilize_reference (other);
+ TREE_OPERAND (node, 0) = lvalue;
+ TREE_OPERAND (TREE_OPERAND (node, 1), 0) = lvalue;
+ }
+
+ /* There are cases where the type of RHS is fixed. In those
+ cases, if the evaluation of the RHS fails, we further the
+ evaluation of the assignment to detect more errors. */
+ nn = java_complete_tree (TREE_OPERAND (node, 1));
+ if (nn == error_mark_node)
+ {
+ /* It's hopeless, but we can further things on to discover
+ an error during the assignment. In any cases, the
+ assignment operation fails. */
+ if (TREE_CODE (TREE_OPERAND (node, 1)) != EXPR_WITH_FILE_LOCATION
+ && TREE_TYPE (TREE_OPERAND (node, 1)) != error_mark_node)
+ patch_assignment (node, wfl_op1, wfl_op2);
+
+ /* Now, we still mark the lhs as initialized */
+ if (DECL_P (TREE_OPERAND (node, 0)))
+ INITIALIZED_P (TREE_OPERAND (node, 0)) = 1;
+
+ return error_mark_node;
+ }
+ TREE_OPERAND (node, 1) = nn;
+ return patch_assignment (node, wfl_op1, wfl_op2);
+
+ case MULT_EXPR:
+ case PLUS_EXPR:
+ case MINUS_EXPR:
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ case URSHIFT_EXPR:
+ case BIT_AND_EXPR:
+ case BIT_XOR_EXPR:
+ case BIT_IOR_EXPR:
+ case TRUNC_MOD_EXPR:
+ case RDIV_EXPR:
+ case TRUTH_ANDIF_EXPR:
+ case TRUTH_ORIF_EXPR:
+ case EQ_EXPR:
+ case NE_EXPR:
+ case GT_EXPR:
+ case GE_EXPR:
+ case LT_EXPR:
+ case LE_EXPR:
+ /* Operands 0 and 1 are WFL in certain cases only. patch_binop
+ knows how to handle those cases. */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ wfl_op2 = TREE_OPERAND (node, 1);
+ TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ return patch_binop (node, wfl_op1, wfl_op2);
+
+ case JAVA_UNARY_PLUS_EXPR:
+ case NEGATE_EXPR:
+ case TRUTH_NOT_EXPR:
+ case BIT_NOT_EXPR:
+ case PREDECREMENT_EXPR:
+ case PREINCREMENT_EXPR:
+ case POSTDECREMENT_EXPR:
+ case POSTINCREMENT_EXPR:
+ case CONVERT_EXPR:
+ /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
+ how to handle those cases. */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ return patch_unaryop (node, wfl_op1);
+
+ case ARRAY_REF:
+ /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
+ how to handle those cases. */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ /* The same applies to wfl_op2 */
+ wfl_op2 = TREE_OPERAND (node, 1);
+ TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ return patch_array_ref (node, wfl_op1, wfl_op2);
+
+ case JAVA_THIS_EXPR:
+ /* Can't use THIS in a static environment */
+ if (!current_this)
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+ parse_error_context (wfl_operator, "Keyword `this' used outside "
+ "allowed context");
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+ return current_this;
+
+ case STRING_CST:
+ /* Build the internal string representation */
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ node = get_identifier (TREE_STRING_POINTER (node));
+ location = alloc_name_constant (CONSTANT_String, node);
+ node = build_ref_from_constant_pool (location);
+ TREE_TYPE (node) = promote_type (string_type_node);
+ return node;
+
+ default:
+ fatal ("No case for tree code `%s' - java_complete_tree\n",
+ tree_code_name [TREE_CODE (node)]);
+ }
+ return node;
+}
+
+/* Complete function call's argument. Return a non zero value is an
+ error was found. */
+
+static int
+complete_function_arguments (node)
+ tree node;
+{
+ int flag = 0;
+ tree cn;
+
+ for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
+ {
+ tree wfl = TREE_VALUE (cn), parm;
+ parm = java_complete_tree (wfl);
+ if (parm == error_mark_node)
+ {
+ flag = 1;
+ continue;
+ }
+ if (TREE_CODE (TREE_TYPE (parm)) == RECORD_TYPE)
+ TREE_VALUE (cn) = convert (promote_type (TREE_TYPE (parm)), parm);
+ else
+ TREE_VALUE (cn) = save_expr (parm);
+ if (not_initialized_as_it_should_p (parm))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl, EXPR_WFL_NODE (wfl));
+ INITIALIZED_P (parm) = 1;
+ }
+ }
+ return flag;
+}
+
+/* Sometimes (for loops and variable initialized during their
+ declaration), we want to wrap a statement around a WFL and turn it
+ debugable. */
+
+static tree
+build_debugable_stmt (location, stmt)
+ int location;
+ tree stmt;
+{
+ if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
+ {
+ stmt = build_expr_wfl (stmt, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (stmt) = location;
+ }
+ JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
+ return stmt;
+}
+
+static tree
+build_expr_block (body, decls)
+ tree body, decls;
+{
+ tree node = make_node (BLOCK);
+ BLOCK_EXPR_DECLS (node) = decls;
+ BLOCK_EXPR_BODY (body);
+ if (body)
+ TREE_TYPE (node) = TREE_TYPE (body);
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* Create a new function block and link its supercontext to the
+ previous block. The current function DECL is used as supercontext
+ when enter_block is called for the first time for a given
+ function. The current function body (DECL_FUNCTION_BODY) is set to
+ the newly created block. */
+
+static block_level = 0;
+
+static tree
+enter_block ()
+{
+ tree b = build_expr_block (NULL_TREE, NULL_TREE);
+ tree fndecl = current_function_decl;
+
+ if (!DECL_FUNCTION_BODY (fndecl))
+ {
+ BLOCK_SUPERCONTEXT (b) = fndecl;
+ DECL_FUNCTION_BODY (fndecl) = b;
+ }
+ else
+ {
+ BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
+ DECL_FUNCTION_BODY (fndecl) = b;
+ }
+ return b;
+}
+
+/* Exit a block by changing the current function body
+ (DECL_FUNCTION_BODY) to the current block super context, only if
+ the block being exited isn't the method's top level one. */
+
+static tree
+exit_block ()
+{
+ tree b = DECL_FUNCTION_BODY (current_function_decl);
+
+ if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
+ DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
+
+ return b;
+}
+
+/* Lookup for NAME in the nested function's blocks, all the way up to
+ the current toplevel one. It complies with Java's local variable
+ scoping rules. */
+
+static tree
+lookup_name_in_blocks (name)
+ tree name;
+{
+ tree b = DECL_FUNCTION_BODY (current_function_decl);
+
+ while (b != current_function_decl)
+ {
+ tree current;
+
+ /* Paranoid sanity check. To be removed */
+ if (TREE_CODE (b) != BLOCK)
+ fatal ("non block expr function body - lookup_name_in_blocks");
+
+ for (current = BLOCK_EXPR_DECLS (b); current;
+ current = TREE_CHAIN (current))
+ if (DECL_NAME (current) == name)
+ return current;
+ b = BLOCK_SUPERCONTEXT (b);
+ }
+ return NULL_TREE;
+}
+
+static void
+maybe_absorb_scoping_blocks ()
+{
+ while (BLOCK_EXPR_ORIGIN (DECL_FUNCTION_BODY (current_function_decl)))
+ {
+ tree b = exit_block ();
+ java_method_add_stmt (current_function_decl, b);
+ SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
+ }
+}
+
+\f
+/* This section of the source is reserved to build_* functions that
+ are building incomplete tree nodes and the patch_* functions that
+ are completing them. */
+
+/* Build an incomplete CALL_EXPR node. Encapsulate it within a WFL */
+
+static tree
+build_method_invocation (name, args)
+ tree name;
+ tree args;
+{
+ tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
+ TREE_SIDE_EFFECTS (call) = 1;
+ /* Check on cases where NAME isn't a WFL. FIXME */
+ EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
+ return call;
+}
+
+/* Build an incomplete assignment expression. */
+
+static tree
+build_assignment (op, op_location, lhs, rhs)
+ int op, op_location;
+ tree lhs, rhs;
+{
+ tree assignment;
+ /* Build the corresponding binop if we deal with a Compound
+ Assignment operator. Mark the binop sub-tree as part of a
+ Compound Assignment expression */
+ if (op != ASSIGN_TK)
+ {
+ rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
+ COMPOUND_ASSIGN_P (rhs) = 1;
+ }
+ assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
+ TREE_SIDE_EFFECTS (assignment) = 1;
+ EXPR_WFL_LINECOL (assignment) = op_location;
+ return assignment;
+}
+
+/* Print an INTEGER_CST node in a static buffer, and return the buffer. */
+
+static char *
+print_int_node (node)
+ tree node;
+{
+ static char buffer [80];
+ if (TREE_CONSTANT_OVERFLOW (node))
+ sprintf (buffer, "<overflow>");
+
+ if (TREE_INT_CST_HIGH (node) == 0)
+ sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
+ TREE_INT_CST_LOW (node));
+ else if (TREE_INT_CST_HIGH (node) == -1
+ && TREE_INT_CST_LOW (node) != 0)
+ {
+ buffer [0] = '-';
+ sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
+ -TREE_INT_CST_LOW (node));
+ }
+ else
+ sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
+ TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
+
+ return buffer;
+}
+
+/* 15.25 Assignment operators. */
+
+static tree
+patch_assignment (node, wfl_op1, wfl_op2)
+ tree node;
+ tree wfl_op1;
+ tree wfl_op2;
+{
+ tree rhs = TREE_OPERAND (node, 1);
+ tree lvalue = TREE_OPERAND (node, 0);
+ tree lhs_type, rhs_type, new_rhs = NULL_TREE;
+ int all_primitive;
+ int error_found = 0;
+ int lvalue_from_array = 0;
+
+ /* Can't assign to a final. */
+ if (DECL_P (lvalue) && FIELD_FINAL (lvalue))
+ {
+ parse_error_context
+ (wfl_op1, "Can't assign a value to the final variable `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl_op1)));
+ error_found = 1;
+ }
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* Lhs can be a named variable */
+ if (DECL_P (lvalue))
+ {
+ INITIALIZED_P (lvalue) = 1;
+ lhs_type = TREE_TYPE (lvalue);
+ }
+ /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME +
+ comment on reason why */
+ else if (TREE_CODE (wfl_op1) == ARRAY_REF)
+ {
+ lhs_type = TREE_TYPE (lvalue);
+ lvalue_from_array = 1;
+ }
+ /* Or a field access */
+ else if (TREE_CODE (lvalue) == COMPONENT_REF)
+ lhs_type = TREE_TYPE (lvalue);
+ /* Or a function return slot */
+ else if (TREE_CODE (lvalue) == RESULT_DECL)
+ lhs_type = TREE_TYPE (lvalue);
+ /* Otherwise, this is an error */
+ else
+ {
+ parse_error_context (wfl_op1, "Invalid left hand side of assignment");
+ error_found = 1;
+ }
+
+ rhs_type = TREE_TYPE (rhs);
+
+ /* 5.2 Begin Assignment conversion */
+
+ /* 5.1.1 Try Identity Conversion */
+ if (lhs_type == rhs_type)
+ new_rhs = rhs;
+
+ /* 5.1.2 Try Widening Primitive Conversion */
+ all_primitive = JPRIMITIVE_TYPE_P (lhs_type) && JPRIMITIVE_TYPE_P (rhs_type);
+ if (all_primitive && JINTEGRAL_TYPE_P (rhs_type)
+ && ((TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type))
+ || (JFLOAT_TYPE_P (lhs_type) &&
+ TYPE_PRECISION (rhs_type) == TYPE_PRECISION (lhs_type))))
+ new_rhs = convert (lhs_type, rhs);
+ else if (all_primitive && JFLOAT_TYPE_P (rhs_type)
+ && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
+ new_rhs = convert (lhs_type, rhs);
+
+ /* Try a narrowing primitive conversion:
+ - expression is a constant expression of type int AND
+ - variable is byte, short or char AND
+ - The value of the expression is representable in the type of the
+ variable */
+ else if (rhs_type == int_type_node && TREE_CONSTANT (rhs)
+ && (lhs_type == byte_type_node || lhs_type == char_type_node
+ || lhs_type == short_type_node))
+ {
+ if (int_fits_type_p (rhs, lhs_type))
+ new_rhs = convert (lhs_type, rhs);
+ else
+ parse_warning_context
+ (wfl_op1, "Constant expression `%s' to wide for narrowing "
+ "primitive conversion to `%s'",
+ print_int_node (rhs), lang_printable_name (lhs_type));
+ /* Reported a warning that will turn into an error further
+ down, so we don't return */
+ }
+
+ /* 5.2 Try a reference conversion */
+ else if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
+ {
+ /* `null' may be assigned to any reference type */
+ if (rhs == null_pointer_node)
+ new_rhs = null_pointer_node;
+ /* Try the reference assignment conversion */
+ else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
+ new_rhs = rhs;
+ if (new_rhs)
+ lhs_type = promote_type (rhs_type);
+ }
+
+ /* 15.25.2 If we have a compound assignment, convert RHS into the
+ type of the LHS */
+ else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
+ new_rhs = convert (lhs_type, rhs);
+
+ /* Explicit cast required. This is an error */
+ if (!new_rhs)
+ {
+ char *t1 = strdup ((char *)lang_printable_name (TREE_TYPE (rhs)));
+ char *t2 = strdup ((char *)lang_printable_name (lhs_type));
+ tree wfl;
+ char operation [32]; /* Max size known */
+
+ /* If the assignment is part of a declaration, we use the WFL of
+ the declared variable to point out the error and call it a
+ declaration problem. If the assignment is a genuine =
+ operator, we call is a operator `=' problem, otherwise we
+ call it an assignment problem. In both of these last cases,
+ we use the WFL of the operator to indicate the error. */
+
+ if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
+ {
+ wfl = wfl_op1;
+ strcpy (operation, "declaration");
+ }
+ else
+ {
+ wfl = wfl_operator;
+ if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
+ strcpy (operation, "assignment");
+ else if (TREE_CODE (TREE_OPERAND (node, 0)) == RESULT_DECL)
+ strcpy (operation, "`return'");
+ else
+ strcpy (operation, "`='");
+ }
+
+ parse_error_context
+ (wfl, (!can_cast_to_p (rhs_type, lhs_type) ?
+ "Incompatible type for %s. Can't convert `%s' to `%s'" :
+ "Incompatible type for %s. Explicit cast "
+ "needed to convert `%s' to `%s'"), operation, t1, t2);
+ free (t1); free (t2);
+ error_found = 1;
+ }
+
+ /* Before reporting type incompatibility errors, check that the rhs
+ is initialized, if a variable */
+ if (not_initialized_as_it_should_p (rhs))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl_op2, DECL_NAME (rhs));
+ INITIALIZED_P (rhs) = 1;
+ }
+
+ if (error_found)
+ return error_mark_node;
+
+ /* If we built a compound expression as the result of a reference
+ assignment into an array element, return it here. */
+ if (TREE_CODE (node) == COMPOUND_EXPR)
+ return node;
+
+ TREE_OPERAND (node, 0) = lvalue;
+ TREE_OPERAND (node, 1) = new_rhs;
+ TREE_TYPE (node) = lhs_type;
+ return node;
+}
+
+/* Check that SOURCE can be converted into DEST, at least with a
+ cast. If the convertion can't occur at all, return 0 otherwise
+ 1. This function is used to produce accurate error messages on the
+ reasons why an assignment failed. */
+
+static int
+can_cast_to_p (source, dest)
+ tree source;
+ tree dest;
+{
+ if (TREE_CODE (source) == POINTER_TYPE)
+ source = TREE_TYPE (source);
+ if (TREE_CODE (dest) == POINTER_TYPE)
+ dest = TREE_TYPE (dest);
+
+ if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
+ return valid_ref_assignconv_cast_p (source, dest, 1);
+
+ else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
+ return 1;
+
+ return 0;
+}
+
+/* Check that something of SOURCE type can be assigned or cast to
+ something of DEST type at runtime. Return 1 if the operation is
+ valid, 0 otherwise. If CAST is set to 1, we're treating the case
+ were SOURCE is cast into DEST, which borrows a lot of the
+ assignment check. */
+
+static int
+valid_ref_assignconv_cast_p (source, dest, cast)
+ tree source;
+ tree dest;
+ int cast;
+{
+ if (TREE_CODE (source) == POINTER_TYPE)
+ source = TREE_TYPE (source);
+ if (TREE_CODE (dest) == POINTER_TYPE)
+ dest = TREE_TYPE (dest);
+ /* Case where SOURCE is a class type */
+ if (TYPE_CLASS_P (source))
+ {
+ if (TYPE_CLASS_P (dest))
+ return source == dest || inherits_from_p (source, dest)
+ || cast && inherits_from_p (dest, source);
+ if (TYPE_INTERFACE_P (dest))
+ {
+ /* If doing a cast and SOURCE is final, the operation is
+ always correct a compile time (because even if SOURCE
+ does not implement DEST, a subclass of SOURCE might). */
+ if (cast && !CLASS_FINAL (TYPE_NAME (source)))
+ return 1;
+ /* Otherwise, SOURCE must implement DEST */
+ return interface_of_p (dest, source);
+ }
+ /* DEST is an array, cast permited if SOURCE is of Object type */
+ return (cast && source == object_type_node ? 1 : 0);
+ }
+ if (TYPE_INTERFACE_P (source))
+ {
+ if (TYPE_CLASS_P (dest))
+ {
+ /* If not casting, DEST must be the Object type */
+ if (!cast)
+ return dest == object_type_node;
+ /* We're doing a cast. The cast is always valid is class
+ DEST is not final, otherwise, DEST must implement SOURCE */
+ else if (!CLASS_FINAL (TYPE_NAME (source)))
+ return 1;
+ else
+ return interface_of_p (source, dest);
+ }
+ if (TYPE_INTERFACE_P (dest))
+ {
+ /* If doing a cast, then if SOURCE and DEST contain method
+ with the same signature but different return type, then
+ this is a (compile time) error */
+ if (cast)
+ {
+ tree method_source, method_dest;
+ tree source_type;
+ tree source_sig, dest_sig;
+ tree source_name;
+ for (method_source = TYPE_METHODS (source); method_source;
+ method_source = TREE_CHAIN (method_source))
+ {
+ source_sig =
+ build_java_argument_signature (TREE_TYPE (method_source));
+ source_type = TREE_TYPE (TREE_TYPE (method_source));
+ source_name = DECL_NAME (method_source);
+ for (method_dest = TYPE_METHODS (dest);
+ method_dest; method_dest = TREE_CHAIN (method_dest))
+ if (source_sig ==
+ build_java_argument_signature (TREE_TYPE (method_dest))
+ && source_name == DECL_NAME (method_dest)
+ && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
+ return 0;
+ }
+ return 1;
+ }
+ else
+ return source == dest || interface_of_p (dest, source);
+ }
+ else /* Array */
+ return 0;
+ }
+ if (TYPE_ARRAY_P (source))
+ {
+ if (TYPE_CLASS_P (dest))
+ return dest == object_type_node;
+ if (TYPE_INTERFACE_P (dest))
+ return 0; /* Install test on Clonable. FIXME */
+ else /* Arrays */
+ {
+ tree source_element_type = TYPE_ARRAY_ELEMENT (source);
+ tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
+
+ if (source_element_type == dest_element_type)
+ return 1;
+ return valid_ref_assignconv_cast_p (source_element_type,
+ dest_element_type, cast);
+ }
+ return 0;
+ }
+ return 0;
+}
+
+/* Build an incomplete binop expression. */
+
+static tree
+build_binop (op, op_location, op1, op2)
+ enum tree_code op;
+ int op_location;
+ tree op1, op2;
+{
+ tree wfl;
+
+ /* URSHIFT_EXPR is not part of what GCC understands, we can't directly build
+ a node with it */
+ tree binop =
+ build ((op == URSHIFT_EXPR ? RSHIFT_EXPR : op), NULL_TREE, op1, op2);
+ if (op == URSHIFT_EXPR)
+ TREE_SET_CODE (binop, op);
+
+ TREE_SIDE_EFFECTS (binop) = 1;
+ /* Store the location of the operator, for better error report. The
+ string of the operator will be rebuild based on the OP value. */
+ EXPR_WFL_LINECOL (binop) = op_location;
+ return binop;
+}
+
+/* Build the string of the operator retained by NODE. If NODE is part
+ of a compound expression, add an '=' at the end of the string. This
+ function is called when an error needs to be reported on an
+ operator. The string is returned as a pointer to a static character
+ buffer. */
+
+static char *
+operator_string (node)
+ tree node;
+{
+#define BUILD_OPERATOR_STRING(S) \
+ { \
+ sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
+ return buffer; \
+ }
+
+ static char buffer [10];
+ switch (TREE_CODE (node))
+ {
+ case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
+ case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
+ case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
+ case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
+ case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
+ case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
+ case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
+ case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
+ case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
+ case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
+ case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
+ case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
+ case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
+ case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
+ case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
+ case GT_EXPR: BUILD_OPERATOR_STRING (">");
+ case GE_EXPR: BUILD_OPERATOR_STRING (">=");
+ case LT_EXPR: BUILD_OPERATOR_STRING ("<");
+ case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
+ case JAVA_UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
+ case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
+ case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
+ case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
+ case PREINCREMENT_EXPR: /* Fall through */
+ case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
+ case PREDECREMENT_EXPR: /* Fall through */
+ case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
+ default:
+ fatal ("unregistered operator %s - operator_string",
+ tree_code_name [TREE_CODE (node)]);
+ }
+ return NULL;
+#undef BUILD_OPERATOR_STRING
+}
+
+/* Binary operators (15.16 up to 15.18). We return error_mark_node on
+ errors but we modify NODE so that it contains the type computed
+ according to the expression, when it's fixed. Otherwise, we write
+ error_mark_node as the type. It allows us to further the analysis
+ of remaining nodes and detects more errors in certain cases. */
+
+static tree
+patch_binop (node, wfl_op1, wfl_op2)
+ tree node;
+ tree wfl_op1;
+ tree wfl_op2;
+{
+ tree op1 = TREE_OPERAND (node, 0);
+ tree op2 = TREE_OPERAND (node, 1);
+ tree op1_type = TREE_TYPE (op1);
+ tree op2_type = TREE_TYPE (op2);
+ tree prom_type;
+ int code = TREE_CODE (node);
+ /* If 1, tell the routine that we have to return error_mark_node
+ after checking for the initialization of the RHS */
+ int error_found = 0;
+
+ /* Figure what is going to be checked first for initialization prior
+ its use. If NODE is part of a compound assignment, we check the
+ second operand first, otherwise the first one first. We also
+ initialize the matching WFL for the error report. `cfi' stands
+ for Check For Initialization */
+ tree cfi = (COMPOUND_ASSIGN_P (node) ? op2 : op1);
+ tree cfi_wfl = (COMPOUND_ASSIGN_P (node) ? wfl_op2 : wfl_op1);
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* Check initialization of LHS first. We then silence further error
+ message if the variable wasn't initialized */
+ if (not_initialized_as_it_should_p (cfi))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (cfi_wfl, DECL_NAME (cfi));
+ INITIALIZED_P (op1) = 1;
+ }
+
+ switch (code)
+ {
+ /* 15.16 Multiplicative operators */
+ case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
+ case RDIV_EXPR: /* 15.16.2 Division Operator / */
+ case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
+ if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
+ {
+ if (!JPRIMITIVE_TYPE_P (op1_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
+ if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ break;
+ }
+ prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+ /* Change the division operator if necessary */
+ if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
+ TREE_SET_CODE (node, TRUNC_DIV_EXPR);
+ /* This one is more complicated. FLOATs are processed by a function
+ call to soft_fmod. */
+ if (code == TRUNC_MOD_EXPR)
+ return build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
+ break;
+
+ /* 15.17 Additive Operators */
+ case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
+ if (JSTRING_TYPE_P (op1_type) || JSTRING_TYPE_P (op2_type))
+ fatal ("operator `+' non implemented on String - patch_binop");
+ case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
+ Numeric Types */
+ if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
+ {
+ if (!JPRIMITIVE_TYPE_P (op1_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
+ if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ break;
+ }
+ prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+ break;
+
+ /* 15.18 Shift Operators */
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ case URSHIFT_EXPR:
+ if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
+ {
+ if (!JINTEGRAL_TYPE_P (op1_type))
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
+ else
+ parse_error_context
+ (wfl_operator, (JPRIMITIVE_TYPE_P (op2_type) ?
+ "Incompatible type for `%s'. Explicit cast needed to convert "
+ "shift distance from `%s' to integral" :
+ "Incompatible type for `%s'. Can't convert shift distance from "
+ "`%s' to integral"),
+ operator_string (node), lang_printable_name (op2_type));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ break;
+ }
+
+ /* Unary numeric promotion (5.6.1) is performed on each operand
+ separatly */
+ op1 = convert (promote_type (op1_type), op1);
+ op2 = convert (promote_type (op2_type), op2);
+
+ /* The type of the shift expression is the type of the promoted
+ type of the left-hand operand */
+ prom_type = TREE_TYPE (op1);
+
+ /* Shift int only up to 0x1f and long up to 0x3f */
+ if (prom_type == int_type_node)
+ op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
+ build_int_2 (0x1f, 0)));
+ else
+ op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
+ build_int_2 (0x3f, 0)));
+
+ /* The >>> operator is a >> operating on unsigned quantities */
+ if (code == URSHIFT_EXPR)
+ {
+ op1 = convert (unsigned_type (prom_type), op1);
+ TREE_SET_CODE (node, RSHIFT_EXPR);
+ }
+ break;
+
+
+ /* 15.21 Bitwise and Logical Operators */
+ case BIT_AND_EXPR:
+ case BIT_XOR_EXPR:
+ case BIT_IOR_EXPR:
+ if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
+ /* Binary numeric promotion is performed on both operand and the
+ expression retain that type */
+ prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+
+ else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
+ && TREE_CODE (op1_type) == BOOLEAN_TYPE)
+ /* The type of the bitwise operator expression is BOOLEAN */
+ prom_type = boolean_type_node;
+ else
+ {
+ if (!JINTEGRAL_TYPE_P (op1_type))
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
+ if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ /* Insert a break here if adding thing before the switch's
+ break for this case */
+ }
+ break;
+
+ /* 15.22 Conditional-And Operator */
+ case TRUTH_ANDIF_EXPR:
+ /* 15.23 Conditional-Or Operator */
+ case TRUTH_ORIF_EXPR:
+ /* Operands must be of BOOLEAN type */
+ if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
+ TREE_CODE (op2_type) != BOOLEAN_TYPE)
+ {
+ if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
+ ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
+ if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ break;
+ }
+ /* The type of the conditional operators is BOOLEAN */
+ prom_type = boolean_type_node;
+ break;
+
+ /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
+ case LT_EXPR:
+ case GT_EXPR:
+ case LE_EXPR:
+ case GE_EXPR:
+ /* The type of each of the operands must be a primitive numeric
+ type */
+ if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
+ {
+ if (!JNUMERIC_TYPE_P (op1_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
+ if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ break;
+ }
+ /* Binary numeric promotion is performed on the operands */
+ binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+ /* The type of the relation expression is always BOOLEAN */
+ prom_type = boolean_type_node;
+ break;
+
+ /* 15.20 Equality Operator */
+ case EQ_EXPR:
+ case NE_EXPR:
+ /* 15.20.1 Numerical Equality Operators == and != */
+ /* Binary numeric promotion is performed on the operands */
+ if (JPRIMITIVE_TYPE_P (op1_type) && JPRIMITIVE_TYPE_P (op2_type))
+ binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+
+ /* 15.20.2 Boolean Equality Operators == and != */
+ else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
+ TREE_CODE (op2_type) == BOOLEAN_TYPE)
+ ; /* Nothing to do here */
+
+ /* 15.20.3 Reference Equality Operators == and != */
+ /* Types have to be either references or the null type */
+ else if ((op1 == null_pointer_node || op2 == null_pointer_node
+ || JREFERENCE_TYPE_P (op1_type)
+ || JREFERENCE_TYPE_P (op2_type))
+ && ((op1_type == op2_type)
+ /* The should use a can_cast_to_p() */
+ ))
+ ; /* Nothing to do here */
+
+ /* Else we have an error figure what can't be converted into
+ what and report the error */
+ else
+ {
+ char *t1;
+ t1 = strdup ((char *)lang_printable_name (op1_type));
+ parse_error_context
+ (wfl_operator, "Incompatible type for `%s'. Can't convert `%s' "
+ "to `%s'", operator_string (node), t1,
+ lang_printable_name (op2_type));
+ free (t1);
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ break;
+ }
+ prom_type = boolean_type_node;
+ break;
+ }
+
+ /* Then check the initialization of the RHS. We don't do that if
+ we're dealing with a node that is part of a compound
+ assignment. We then silence further error message if the variable
+ wasn't initialized */
+ if (not_initialized_as_it_should_p (op2) && !COMPOUND_ASSIGN_P (node))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl_op2, DECL_NAME (op2));
+ INITIALIZED_P (op2) = 1;
+ }
+
+ if (error_found)
+ return error_mark_node;
+
+ TREE_OPERAND (node, 0) = op1;
+ TREE_OPERAND (node, 1) = op2;
+ TREE_TYPE (node) = prom_type;
+ return fold (node);
+}
+
+/* Build an incomplete unary operator expression. Unary `+' node is
+ build as a CONV_EXPR, even though its tree code is overridden by a
+ JAVA_UNARY_PLUS_EXPR that isn't a tree code, to differentiate it during
+ the walk. */
+
+static tree
+build_unaryop (op_token, op_location, op1)
+ int op_token, op_location;
+ tree op1;
+{
+ enum tree_code op;
+ tree unaryop;
+ switch (op_token)
+ {
+ case PLUS_TK: op = CONVERT_EXPR; break;
+ case MINUS_TK: op = NEGATE_EXPR; break;
+ case NEG_TK: op = TRUTH_NOT_EXPR; break;
+ case NOT_TK: op = BIT_NOT_EXPR; break;
+ default: fatal ("Unknown token `%d' for unary operator - build_unaryop",
+ op_token);
+ }
+
+ unaryop = build1 (op, NULL_TREE, op1);
+ if (op_token == PLUS_TK)
+ TREE_SET_CODE (unaryop, JAVA_UNARY_PLUS_EXPR);
+
+ TREE_SIDE_EFFECTS (unaryop) = 1;
+ /* Store the location of the operator, for better error report. The
+ string of the operator will be rebuild based on the OP value. */
+ EXPR_WFL_LINECOL (unaryop) = op_location;
+ return unaryop;
+}
+
+/* Special case for the ++/-- operators, since they require an extra
+ argument to build, which is set to NULL and patched
+ later. IS_POST_P is 1 if the operator, 0 otherwise. */
+
+static tree
+build_incdec (op_token, op_location, op1, is_post_p)
+ int op_token, op_location;
+ tree op1;
+ int is_post_p;
+{
+ static enum tree_code lookup [2][2] =
+ {
+ { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
+ { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
+ };
+ tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
+ NULL_TREE, op1, NULL_TREE);
+ TREE_SIDE_EFFECTS (node) = 1;
+ /* Store the location of the operator, for better error report. The
+ string of the operator will be rebuild based on the OP value. */
+ EXPR_WFL_LINECOL (node) = op_location;
+ return node;
+}
+
+/* Build an incomplete cast operator, based on the use of the
+ CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
+ set. java_complete_tree is trained to walk a CONVERT_EXPR even
+ though its type is already set. */
+
+static tree
+build_cast (location, type, exp)
+ int location;
+ tree type, exp;
+{
+ tree node = build1 (CONVERT_EXPR, type, exp);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+/* 15.14 Unary operators. We return error_mark_node in case of error,
+ but preserve the type of NODE if the type is fixed. */
+
+static tree
+patch_unaryop (node, wfl_op)
+ tree node;
+ tree wfl_op;
+{
+ tree op = TREE_OPERAND (node, 0);
+ tree op_type = TREE_TYPE (op);
+ tree prom_type, value;
+ int code = TREE_CODE (node);
+ int error_found = 0;
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ switch (code)
+ {
+ /* 15.13.2 Postfix Increment Operator ++ */
+ case POSTINCREMENT_EXPR:
+ /* 15.13.3 Postfix Increment Operator -- */
+ case POSTDECREMENT_EXPR:
+ /* 15.14.1 Prefix Increment Operator ++ */
+ case PREINCREMENT_EXPR:
+ /* 15.14.2 Prefix Decrement Operator -- */
+ case PREDECREMENT_EXPR:
+ if (!DECL_P (op))
+ {
+ parse_error_context (wfl_operator, "Invalid argument to `%s'",
+ operator_string (node));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else if (FIELD_FINAL (op))
+ {
+ parse_error_context
+ (wfl_op, "Can't assign a value to the final variable `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl_op)));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ /* From now on, we know that op if a variable and that it has a
+ valid wfl. We use wfl_op to locate errors related to the
+ ++/-- operand. */
+ else if (!JNUMERIC_TYPE_P (op_type))
+ {
+ parse_error_context
+ (wfl_op, "Invalid argument type `%s' to `%s'",
+ lang_printable_name (op_type), operator_string (node));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else
+ {
+ /* Before the addition, binary numeric promotion if performed on
+ both operands */
+ value = integer_one_node;
+ prom_type = binary_numeric_promotion (op_type, TREE_TYPE (value),
+ &op, &value);
+ /* And write the promoted increment back */
+ TREE_OPERAND (node, 1) = value;
+ }
+ break;
+
+ /* 15.14.3 Unary Plus Operator + */
+ case JAVA_UNARY_PLUS_EXPR:
+ /* 15.14.4 Unary Minus Operator - */
+ case NEGATE_EXPR:
+ if (!JNUMERIC_TYPE_P (op_type))
+ {
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ /* Unary numeric promotion is performed on operand */
+ else
+ {
+ prom_type = promote_type (op_type);
+ op = convert (prom_type, op);
+ if (code == JAVA_UNARY_PLUS_EXPR)
+ node = op;
+ }
+ break;
+
+ /* 15.14.5 Bitwise Complement Operator ~ */
+ case BIT_NOT_EXPR:
+ if (!JINTEGRAL_TYPE_P (op_type))
+ {
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else
+ {
+ prom_type = promote_type (op_type);
+ op = convert (prom_type, op);
+ }
+ break;
+
+ /* 15.14.6 Logical Complement Operator ! */
+ case TRUTH_NOT_EXPR:
+ if (TREE_CODE (op_type) != BOOLEAN_TYPE)
+ {
+ ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ }
+ else
+ prom_type = boolean_type_node;
+ break;
+
+ /* 15.15 Cast Expression */
+ case CONVERT_EXPR:
+ value = patch_cast (node, wfl_op, wfl_operator);
+ if (value == error_mark_node)
+ {
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else
+ node = value;
+ break;
+ }
+
+ /* Check variable initialization */
+ if (not_initialized_as_it_should_p (op))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl_op, DECL_NAME (op));
+ INITIALIZED_P (op) = 1;
+ }
+
+ if (error_found)
+ return error_mark_node;
+ /* In the case of JAVA_UNARY_PLUS_EXPR, we replaced NODE by a new one */
+ else if (code != JAVA_UNARY_PLUS_EXPR && code != CONVERT_EXPR)
+ {
+ TREE_OPERAND (node, 0) = op;
+ TREE_TYPE (node) = prom_type;
+ }
+ return fold (node);
+}
+
+/* Generic type resolution that sometimes takes place during node
+ patching. Returned the resolved type or generate an error
+ message. Return the resolved type or NULL_TREE. */
+
+static tree
+resolve_type_during_patch (type)
+ tree type;
+{
+ if (unresolved_type_p (type, NULL))
+ {
+ tree type_decl = resolve_no_layout (EXPR_WFL_NODE (type), NULL_TREE);
+ if (!type_decl)
+ {
+ parse_error_context (type,
+ "Class `%s' not found in type declaration",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
+ return NULL_TREE;
+ }
+ else
+ return TREE_TYPE (type_decl);
+ }
+ return type;
+}
+/* 5.5 Casting Conversion. error_mark_node is returned if an error is
+ found. Otherwise NODE or something meant to replace it is returned. */
+
+static tree
+patch_cast (node, wfl_op, wfl_operator)
+ tree node;
+ tree wfl_op;
+ tree wfl_operator;
+{
+ tree op = TREE_OPERAND (node, 0);
+ tree op_type = TREE_TYPE (op);
+ tree cast_type = TREE_TYPE (node);
+ char *t1;
+
+ /* First resolve OP_TYPE if unresolved */
+ if (!(cast_type = resolve_type_during_patch (cast_type)))
+ return error_mark_node;
+
+ /* Check on cast that are proven correct at compile time */
+ if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
+ {
+ static tree convert_narrow ();
+ /* Same type */
+ if (cast_type == op_type)
+ return node;
+
+ /* Try widening/narowwing convertion. Potentially, things need
+ to be worked out in gcc so we implement the extreme cases
+ correctly. fold_convert() needs to be fixed. */
+ return convert (cast_type, op);
+ }
+
+ /* The remaining legal casts involve conversion between reference
+ types. Check for their compile time correctness. */
+ if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
+ && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
+ {
+ TREE_TYPE (node) = promote_type (cast_type);
+ /* Now, the case can be determined correct at compile time if
+ OP_TYPE can be converted into CAST_TYPE by assignment
+ conversion (5.2) */
+
+ if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
+ return node;
+
+ /* The cast requires a run-time check */
+ return build (CALL_EXPR, promote_type (cast_type),
+ build_address_of (soft_checkcast_node),
+ tree_cons (NULL_TREE, build_class_ref (cast_type),
+ build_tree_list (NULL_TREE, op)),
+ NULL_TREE);
+ }
+
+ /* Any other casts are proven incorrect at compile time */
+ t1 = strdup ((char *)lang_printable_name (op_type));
+ parse_error_context (wfl_operator, "Invalid cast from `%s' to `%s'",
+ t1, lang_printable_name (cast_type));
+ free (t1);
+ return error_mark_node;
+}
+
+/* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
+ a list of indices. */
+static tree
+build_array_ref (location, array, index)
+ int location;
+ tree array, index;
+{
+ tree node = build (ARRAY_REF, NULL_TREE, array, index);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+/* 15.12 Array Access Expression */
+
+static tree
+patch_array_ref (node, wfl_array, wfl_index)
+ tree node, wfl_array, wfl_index;
+{
+ tree array = TREE_OPERAND (node, 0);
+ tree array_type = TREE_TYPE (array);
+ tree index = TREE_OPERAND (node, 1);
+ tree index_type = TREE_TYPE (index);
+ tree promoted_index_type;
+ int error_found = 0;
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ if (not_initialized_as_it_should_p (array))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl_array, DECL_NAME (array));
+ INITIALIZED_P (array) = 1;
+ }
+ if (! flag_emit_class_files)
+ array = save_expr (array);
+
+ if (TREE_CODE (array_type) == POINTER_TYPE)
+ array_type = TREE_TYPE (array_type);
+
+ /* The array reference must be an array */
+ if (!TYPE_ARRAY_P (array_type))
+ {
+ parse_error_context
+ (wfl_operator, "`[]' can only be applied to arrays. It can't be "
+ "applied to `%s'", lang_printable_name (array_type));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+
+ /* The array index underdoes unary numeric promotion. The promoted
+ type must be int */
+ promoted_index_type = promote_type (index_type);
+ if (promoted_index_type != int_type_node)
+ {
+ int could_cast = can_cast_to_p (index_type, int_type_node);
+ parse_error_context
+ (wfl_operator,
+ (could_cast ? "Incompatible type for `[]'. Explicit cast needed to "
+ "convert `%s' to `int'" : "Incompatible type for `[]'. "
+ "Can't convert `%s' to `int'"),
+ lang_printable_name (index_type));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+
+ /* Now if the index is a var/parm decl, check on its initialization */
+ if (not_initialized_as_it_should_p (index))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl_index, DECL_NAME (index));
+ INITIALIZED_P (index) = 1;
+ }
+
+ if (error_found)
+ return error_mark_node;
+ index = convert (promoted_index_type, index);
+
+ if (TREE_CODE (array_type) == RECORD_TYPE)
+ array_type = promote_type (TYPE_ARRAY_ELEMENT (array_type));
+ if (flag_emit_class_files)
+ {
+ TREE_OPERAND (node, 0)= array;
+ TREE_OPERAND (node, 1)= index;
+ }
+ else
+ node = build_java_arrayaccess (array, array_type, index);
+ TREE_TYPE (node) = array_type;
+ return node;
+}
+
+/* 15.9 Array Creation Expressions */
+
+static tree
+build_newarray_node (type, dims, extra_dims)
+ tree type;
+ tree dims;
+ int extra_dims;
+{
+ tree node =
+ build (CALL_EXPR, NULL_TREE, type, nreverse (dims),
+ build_int_2 (extra_dims, 0));
+ TREE_SET_CODE (node, JAVA_NEW_ARRAY_EXPR);
+ return node;
+}
+
+static tree
+patch_newarray (node)
+ tree node;
+{
+ tree type = TREE_OPERAND (node, 0);
+ tree dims = TREE_OPERAND (node, 1);
+ tree cdim, array_type;
+ int error_found = 0;
+ int ndims = 0;
+ int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
+ int total_dims;
+
+ /* Dimension types are verified. It's better for the types to be
+ verified in order. */
+ for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
+ {
+ int dim_error = 0;
+ tree dim = TREE_VALUE (cdim);
+
+ /* Dim might have been saved during its evaluation */
+ dim = (TREE_CODE (dim) == SAVE_EXPR ? dim = TREE_OPERAND (dim, 0) : dim);
+
+ /* The type of each specified dimension must be an integral type. */
+ if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
+ dim_error = 1;
+
+ /* Each expression undergoes an unary numeric promotion (5.6.1) and the
+ promoted type must be int. */
+ else
+ {
+ dim = convert (promote_type (TREE_TYPE (dim)), dim);
+ if (TREE_TYPE (dim) != int_type_node)
+ dim_error = 1;
+ }
+
+ /* Report errors on types here */
+ if (dim_error)
+ {
+ parse_error_context
+ (TREE_PURPOSE (cdim),
+ "Incompatible type for dimension in array creation expression. "
+ "%s convert `%s' to `int'",
+ (can_cast_to_p (TREE_TYPE (dim), int_type_node) ?
+ "Explicit cast needed to" : "Can't"),
+ lang_printable_name (TREE_TYPE (dim)));
+ error_found = 1;
+ }
+
+ /* Check for uninitialized variables */
+ if (not_initialized_as_it_should_p (dim))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (TREE_PURPOSE (cdim),
+ DECL_NAME (dim));
+ INITIALIZED_P (dim) = 1;
+ error_found = 1;
+ }
+
+ TREE_PURPOSE (cdim) = NULL_TREE;
+ }
+
+ /* Resolve array base type if unresolved */
+ if (!(type = resolve_type_during_patch (type)))
+ error_found = 1;
+
+ if (error_found)
+ {
+ /* We don't want further evaluation of this bogus array creation
+ operation */
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+
+ /* The node is transformed into a function call. Things are done
+ differently according to the number of dimensions. If the number
+ of dimension is equal to 1, then the nature of the base type
+ (primitive or not) matters. */
+ total_dims = xdims + ndims;
+ if (total_dims == 1)
+ {
+ if (JPRIMITIVE_TYPE_P (type))
+ {
+ int type_code;
+ if (type == boolean_type_node)
+ type_code = 4;
+ else if (type == char_type_node)
+ type_code = 5;
+ else if (type == float_type_node)
+ type_code = 6;
+ else if (type == double_type_node)
+ type_code = 7;
+ else if (type == byte_type_node)
+ type_code = 8;
+ else if (type == short_type_node)
+ type_code = 9;
+ else if (type == int_type_node)
+ type_code = 10;
+ else if (type == long_type_node)
+ type_code = 11;
+ else
+ fatal ("Can't compute type code - patch_newarray");
+ return build_newarray (type_code, TREE_VALUE (dims));
+ }
+ else
+ return build_anewarray (type, TREE_VALUE (dims));
+ }
+
+ /* Add extra dimensions as unknown dimensions */
+ while (xdims--)
+ dims =
+ chainon (dims, build_tree_list (NULL_TREE, integer_negative_one_node));
+ dims = chainon (dims, build_tree_list (NULL_TREE, integer_zero_node));
+
+ /* Can't reuse what's already written in expr.c because it uses the
+ JVM stack representation. Provide a build_multianewarray. FIXME */
+ array_type = type;
+ for (cdim = TREE_CHAIN (dims); cdim; cdim = TREE_CHAIN (cdim))
+ array_type = build_java_array_type (promote_type (array_type),
+ TREE_CODE (cdim) == INTEGER_CST ?
+ TREE_INT_CST_LOW (cdim) : -1);
+ return build (CALL_EXPR,
+ promote_type (array_type),
+ build_address_of (soft_multianewarray_node),
+ tree_cons (NULL_TREE, build_class_ref (array_type),
+ tree_cons (NULL_TREE,
+ build_int_2 (total_dims, 0), dims )),
+ NULL_TREE);
+}
+
+static tree
+build_this (location)
+ int location;
+{
+ tree node = build_wfl_node (this_identifier_node, input_filename, 0, 0);
+ TREE_SET_CODE (node, JAVA_THIS_EXPR);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+/* 14.15 The return statement. It builds a modify expression that
+ assigns the returned value to the RESULT_DECL that hold the value
+ to be returned. */
+
+static tree
+build_return (location, op)
+ int location;
+ tree op;
+{
+ tree node = build1 (RETURN_EXPR, NULL_TREE, op);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+static tree
+patch_return (node)
+ tree node;
+{
+ tree return_exp = TREE_OPERAND (node, 0);
+ tree meth = current_function_decl;
+ tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
+ tree modify;
+ int error_found = 0;
+
+ TREE_TYPE (node) = error_mark_node;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* It's invalid to have a return value within a function that is
+ declared with the keyword void or that is a constructor */
+ if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
+ error_found = 1;
+
+ /* It's invalid to have a no return value within a function that
+ isn't declared with the keyword `void' */
+ if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
+ error_found = 2;
+
+ if (error_found)
+ {
+ char *t = strdup ((char *)lang_printable_name (mtype));
+ parse_error_context (wfl_operator, "`return' with%s value from `%s %s'",
+ (error_found == 1 ? "" : "out"), t,
+ lang_printable_name (meth));
+ free (t);
+ return error_mark_node;
+ }
+
+ /* If we have a return_exp, build a modify expression and expand it */
+ if (return_exp)
+ {
+ modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), return_exp);
+ EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
+ modify = java_complete_tree (modify);
+ if (modify != error_mark_node)
+ {
+ TREE_SIDE_EFFECTS (modify) = 1;
+ TREE_OPERAND (node, 0) = modify;
+ }
+ else
+ return error_mark_node;
+ }
+ TREE_TYPE (node) = void_type_node;
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* 14.8 The if Statement */
+
+static tree
+build_if_else_statement (location, expression, if_body, else_body)
+ int location;
+ tree expression, if_body, else_body;
+{
+ tree node;
+ /* FIXME: make else body be a void node, where this function is
+ called */
+ if (!else_body)
+ else_body = build (COMPOUND_EXPR, void_type_node, NULL_TREE, NULL_TREE);
+ node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+static tree
+patch_if_else_statement (node)
+ tree node;
+{
+ tree expression = TREE_OPERAND (node, 0);
+
+ TREE_TYPE (node) = error_mark_node;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* The type of expression must be boolean */
+ if (TREE_TYPE (expression) != boolean_type_node)
+ {
+ parse_error_context
+ (wfl_operator,
+ "Incompatible type for `if'. Can't convert `%s' to `boolean'",
+ lang_printable_name (TREE_TYPE (expression)));
+ return error_mark_node;
+ }
+
+ TREE_TYPE (node) = void_type_node;
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* 14.6 Labeled Statements */
+
+/* Action taken when a lableled statement is parsed. a new
+ LABELED_BLOCK_EXPR is created. No statement is attached to the
+ label, yet. */
+
+static tree
+build_labeled_block (location, label, wfl)
+ int location;
+ tree label, wfl;
+{
+ tree label_name = merge_qualified_name (label_id, label);
+ tree label_decl, node;
+
+ /* Issue a warning if we try to reuse a label that was previously
+ declared */
+ if (IDENTIFIER_LOCAL_VALUE (label_name))
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = location;
+ parse_warning_context (wfl_operator, "Declaration of `%s' shadows "
+ "a previous declaration",
+ IDENTIFIER_POINTER (label));
+ EXPR_WFL_LINECOL (wfl_operator) =
+ EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
+ parse_warning_context (wfl_operator, "This is the location of the "
+ "previous declaration of label `%s'",
+ IDENTIFIER_POINTER (label));
+ java_warning_count--;
+ }
+
+ label_decl = create_label_decl (label_name);
+ node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
+ EXPR_WFL_LINECOL (node) = location;
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* Generate a label crafting a unique name for it. This is used to
+ implicitely label loops that aren't the body part of labeled
+ statement. */
+
+static tree
+generate_labeled_block ()
+{
+ static int l_number = 0;
+ char buf [20];
+ tree label_name;
+
+ sprintf (buf, "$a%d", l_number++);
+ return build_labeled_block (0, get_identifier (buf), NULL_TREE);
+}
+
+/* A labeled statement LBE is attached a statement. If the statement
+ happens to be a loop, a link from the loop back to the label is
+ installed. */
+
+static tree
+complete_labeled_statement (lbe, statement)
+ tree lbe; /* Labeled block expr */
+ tree statement;
+{
+ /* In anyways, tie the loop to its statement */
+ LABELED_BLOCK_BODY (lbe) = statement;
+
+ /* Ok, if statement is a for loop, we have to attach the labeled
+ statement to the block the for loop belongs to and return the
+ block instead */
+ if (TREE_CODE (statement) == LOOP_EXPR && IS_FOR_LOOP_P (statement))
+ {
+ java_method_add_stmt (current_function_decl, lbe);
+ return exit_block ();
+ }
+
+ return lbe;
+}
+
+/* 14.10, 14.11, 14.12 Loop Statements */
+
+/* Create an empty LOOP_EXPR and make it the last in the nested loop
+ list. */
+
+static tree
+build_new_loop (loop_body)
+ tree loop_body;
+{
+ tree loop = build (LOOP_EXPR, NULL_TREE, loop_body);
+ TREE_SIDE_EFFECTS (loop) = 1;
+ PUSH_LOOP (loop);
+ return loop;
+}
+
+/* Create a loop body according to the following structure:
+ COMPOUND_EXPR
+ COMPOUND_EXPR (loop main body)
+ EXIT_EXPR (this order is for while/for loops.
+ LABELED_BLOCK_EXPR the order is reversed for do loops)
+ LABEL_DECL (continue occurding here branche at the
+ BODY end of this labeled block)
+ INCREMENT (if any)
+
+ REVERSED, if non zero, tells that the loop condition expr comes
+ after the body, like in the do-while loop. */
+
+static tree
+build_loop_body (location, condition, reversed)
+ int location;
+ tree condition;
+ int reversed;
+{
+ tree first, second, label, body;
+
+ condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
+ EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
+ condition = build_debugable_stmt (location, condition);
+ TREE_SIDE_EFFECTS (condition) = 1;
+
+ body = generate_labeled_block ();
+ first = (reversed ? body : condition);
+ second = (reversed ? condition : body);
+ return
+ build (COMPOUND_EXPR, NULL_TREE,
+ build (COMPOUND_EXPR, NULL_TREE, first, second), size_zero_node);
+}
+
+/* Install CONDITION (if any) and loop BODY (using REVERSED to tell
+ their order) on the current loop. Unlink the current loop from the
+ loop list. */
+
+static tree
+complete_loop_body (location, condition, body, reversed)
+ int location;
+ tree condition, body;
+ int reversed;
+{
+ tree to_return = ctxp->current_loop;
+ tree loop_body = LOOP_EXPR_BODY (to_return);
+ if (condition)
+ {
+ tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
+ /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
+ The real EXIT_EXPR is one operand further. */
+ EXPR_WFL_LINECOL (cnode) = location;
+ /* This one is for accurate error reports */
+ EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
+ TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
+ }
+ LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
+ POP_LOOP ();
+ return to_return;
+}
+
+/* Tailored version of complete_loop_body for FOR loops, when FOR
+ loops feature the condition part */
+
+static tree
+complete_for_loop (location, condition, update, body)
+ int location;
+ tree condition, update, body;
+{
+ /* Put the condition and the loop body in place */
+ tree loop = complete_loop_body (location, condition, body, 0);
+ /* LOOP is the current loop which has been now popped of the loop
+ stack. Install the update block */
+ LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
+ return loop;
+}
+
+/* If the loop isn't surrounded by a labeled statement, create one and
+ insert LOOP as it's body. */
+
+static tree
+patch_loop_statement (loop)
+ tree loop;
+{
+ tree cbl, loop_label, to_return_as_loop;
+
+ if (LOOP_HAS_LABEL_P (loop))
+ {
+ loop_label = ctxp->current_labeled_block;
+ to_return_as_loop = loop;
+ }
+ else
+ {
+ loop_label = generate_labeled_block ();
+ LABELED_BLOCK_BODY (loop_label) = loop;
+ PUSH_LABELED_BLOCK (loop_label);
+ to_return_as_loop = loop_label;
+ }
+ TREE_TYPE (to_return_as_loop) = void_type_node;
+ return to_return_as_loop;
+}
+
+/* 14.13, 14.14: break and continue Statements */
+
+/* Build a break or a continue statement. a null NAME indicates an
+ unlabeled break/continue statement. */
+
+static tree
+build_bc_statement (location, is_break, name)
+ int location, is_break;
+ tree name;
+{
+ tree break_continue, label_block_expr = NULL_TREE;
+
+ if (name)
+ {
+ if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
+ (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
+ /* Null means that we don't have a target for this named
+ break/continue. In this case, we make the target to be the
+ label name, so that the error can be reported accuratly in
+ patch_bc_statement. */
+ label_block_expr = EXPR_WFL_NODE (name);
+ }
+ /* Unlabeled break/continue will be handled during the
+ break/continue patch operation */
+ break_continue
+ = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
+
+ IS_BREAK_STMT_P (break_continue) = is_break;
+ TREE_SIDE_EFFECTS (break_continue) = 1;
+ EXPR_WFL_LINECOL (break_continue) = location;
+ return break_continue;
+}
+
+/* Verification of a break/continue statement. */
+
+static tree
+patch_bc_statement (node)
+ tree node;
+{
+ tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
+ int is_unlabeled = 0;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* Not having a target means that the break/continue statement is
+ unlabeled. We try to find a descent label for it */
+ if (!bc_label)
+ {
+ is_unlabeled = 1;
+ /* There should be a loop to branch to */
+ if (ctxp->current_loop)
+ {
+ /* At that stage, we're in the loop body, which is
+ encapsulated around a LABELED_BLOCK_EXPR. So searching
+ the current loop label requires us to consider the
+ labeled block before the current one. */
+ if (!LOOP_HAS_LABEL_SKIP_P (ctxp->current_loop))
+ fatal ("unlabeled loop has not installed label -- "
+ "patch_bc_statement");
+ bc_label = TREE_CHAIN (ctxp->current_labeled_block);
+ }
+ /* Not having a loop to break/continue to is an error */
+ else
+ {
+ parse_error_context (wfl_operator, "`%s' must be in loop%s",
+ (IS_BREAK_STMT_P (node) ? "break" : "continue"),
+ (IS_BREAK_STMT_P (node) ? " or switch" : ""));
+ return error_mark_node;
+ }
+ }
+ /* Having an identifier here means that the target is unknown. */
+ else if (TREE_CODE (bc_label) == IDENTIFIER_NODE)
+ {
+ parse_error_context (wfl_operator, "No label definition found for `%s'",
+ IDENTIFIER_POINTER (bc_label));
+ return error_mark_node;
+ }
+
+ /* Find the statement we're targeting. */
+ target_stmt = LABELED_BLOCK_BODY (bc_label);
+
+ /* 14.13 The break Statement */
+ if (IS_BREAK_STMT_P (node))
+ {
+ /* Named break are always fine, as far as they have a target
+ (already verified). Anonymous break need to target
+ while/do/for/switch */
+ if (is_unlabeled &&
+ !(TREE_CODE (target_stmt) == LOOP_EXPR /* do/while/for */
+ || 0)) /* switch FIXME */
+ {
+ parse_error_context (wfl_operator,
+ "`break' must be in loop or switch");
+ return error_mark_node;
+ }
+ /* If previously unlabeled, install the new found label */
+ if (is_unlabeled)
+ EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
+ }
+ /* 14.14 The continue Statement */
+ /* The continue statement must always target a loop */
+ else
+ {
+ if (TREE_CODE (target_stmt) != LOOP_EXPR) /* do/while/for */
+ {
+ parse_error_context (wfl_operator, "`continue' must be in loop");
+ return error_mark_node;
+ }
+ /* Everything looks good. We can fix the `continue' jump to go
+ at the place in the loop were the continue is. The continue
+ is the current labeled block, by construction. */
+ EXIT_BLOCK_LABELED_BLOCK (node) = ctxp->current_labeled_block;
+ }
+
+ /* Our break/continue don't return values. */
+ TREE_TYPE (node) = void_type_node;
+ /* Encapsulate the break within a compound statement so that it's
+ expanded all the times by expand_expr (and not clobered
+ sometimes, like after a if statement) */
+ node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* Process the exit expression belonging to a loop. Its type must be
+ boolean. */
+
+static tree
+patch_exit_expr (node)
+ tree node;
+{
+ tree expression = TREE_OPERAND (node, 0);
+ TREE_TYPE (node) = error_mark_node;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* The type of expression must be boolean */
+ if (TREE_TYPE (expression) != boolean_type_node)
+ {
+ parse_error_context
+ (wfl_operator,
+ "Incompatible type for loop conditional. Can't convert `%s' to "
+ "`boolean'",
+ lang_printable_name (TREE_TYPE (expression)));
+ return error_mark_node;
+ }
+ /* Now we know things are allright, invert the condition, fold and
+ return */
+ TREE_OPERAND (node, 0) =
+ fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
+ TREE_TYPE (node) = void_type_node;
+ return node;
+}
--- /dev/null
+/* Language parser definitions for the GNU compiler for the Java(TM) language.
+ Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+ Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+#ifndef JV_LANG_H
+#define JV_LANG_H
+
+#include "lex.h"
+
+/* Extern global variable declarations */
+extern int java_error_count;
+extern struct obstack temporary_obstack;
+extern struct obstack permanent_obstack;
+extern int quiet_flag;
+
+#ifndef JC1_LITE
+/* Function extern to java/ */
+extern int int_fits_type_p PROTO ((tree, tree));
+extern tree stabilize_reference PROTO ((tree));
+#endif
+
+/* Macros for verbose debug info */
+#ifdef VERBOSE_SKELETON
+#define RULE( rule ) printf ( "jv_yacc:%d: rule %s\n", lineno, rule )
+#else
+#define RULE( rule )
+#endif
+
+#ifdef SOURCE_FRONTEND_DEBUG
+#undef SOURCE_FRONTEND_DEBUG
+#define SOURCE_FRONTEND_DEBUG(X) \
+ {if (!quiet_flag) {printf ("* "); printf X; putchar ('\n');} }
+#else
+#define SOURCE_FRONTEND_DEBUG(X)
+#endif
+
+/* Macro for error recovering */
+#ifdef YYDEBUG
+#define RECOVERED \
+ { if (!quiet_flag) {printf ("** Recovered\n");} }
+#define DRECOVERED(s) \
+ { if (!quiet_flag) {printf ("** Recovered (%s)\n", #s);}}
+#else
+#define RECOVERED
+#define DRECOVERED(s)
+#endif
+
+#define DRECOVER(s) {yyerrok; DRECOVERED(s)}
+#define RECOVER {yyerrok; RECOVERED}
+
+#define YYERROR_NOW ctxp->java_error_flag = 1
+#define YYNOT_TWICE if (ctxp->prevent_ese != lineno)
+
+/* Accepted modifiers */
+#define CLASS_MODIFIERS ACC_PUBLIC|ACC_ABSTRACT|ACC_FINAL
+#define FIELD_MODIFIERS ACC_PUBLIC|ACC_PROTECTED|ACC_PRIVATE|ACC_FINAL| \
+ ACC_STATIC|ACC_TRANSIENT|ACC_VOLATILE
+#define METHOD_MODIFIERS ACC_PUBLIC|ACC_PROTECTED|ACC_PRIVATE|ACC_ABSTRACT| \
+ ACC_STATIC|ACC_FINAL|ACC_SYNCHRONIZED|ACC_NATIVE
+#define INTERFACE_MODIFIERS ACC_PUBLIC|ACC_ABSTRACT
+#define INTERFACE_METHOD_MODIFIERS ACC_PUBLIC|ACC_ABSTRACT
+#define INTERFACE_FIELD_MODIFIERS ACC_PUBLIC|ACC_STATIC|ACC_FINAL
+
+/* Getting a modifier WFL */
+#define MODIFIER_WFL(M) (ctxp->modifier_ctx [(M) - PUBLIC_TK])
+
+/* Check on modifiers */
+#define THIS_MODIFIER_ONLY(f, m, v, count, l) \
+ if ((f) & (m)) \
+ { \
+ tree node = ctxp->modifier_ctx [v]; \
+ if ((l) \
+ && ((EXPR_WFL_COLNO (node) > EXPR_WFL_COLNO (l)) \
+ || (EXPR_WFL_LINENO (node) > EXPR_WFL_LINENO (l)))) \
+ l = node; \
+ else if (!(l)) \
+ l = node; \
+ count++; \
+ }
+
+#define ABSTRACT_CHECK(flag, v, cl, s) \
+ if ((flag) & (v)) \
+ parse_error_context (cl, s " method can't be abstract");
+
+/* Misc. */
+#define exit_java_complete_class() \
+ { \
+ pop_obstacks (); \
+ return; \
+ }
+
+#define CLASS_OR_INTERFACE(decl, s1, s2) \
+ (decl ? \
+ ((get_access_flags_from_decl (TYPE_NAME (TREE_TYPE (decl))) \
+ & ACC_INTERFACE) ? \
+ s2 : s1) : ((s1 [0]=='S'|| s1 [0]=='s') ? \
+ (s1 [0]=='S' ? "Supertype" : "supertype") : \
+ (s1 [0] > 'A' ? "Type" : "type")))
+
+/* Pedantic warning on obsolete modifiers. Note: when cl is NULL,
+ flags was set artificially, such as for a interface method */
+#define OBSOLETE_MODIFIER_WARNING(cl, flags, modifier, format, arg) \
+ { \
+ if ((cl) && ((flags) & (modifier))) \
+ parse_warning_context (cl, \
+ "Discouraged redundant use of `%s' modifier " \
+ "in declaration of " format, \
+ java_accstring_lookup (modifier), arg); \
+ }
+
+/* Quickly build a temporary pointer on hypothetical type NAME. */
+#define BUILD_PTR_FROM_NAME(ptr, name) \
+ { \
+ ptr = build (POINTER_TYPE, NULL_TREE); \
+ TYPE_NAME (ptr) = name; \
+ }
+
+#define INCOMPLETE_TYPE_P(NODE) \
+ ((TREE_CODE (NODE) == TREE_LIST) \
+ && (TREE_CODE (TREE_PURPOSE (NODE)) == POINTER_TYPE) \
+ && (TREE_TYPE (TREE_PURPOSE (NODE)) == NULL_TREE))
+
+/* Set the EMIT_LINE_NOTE flag of a EXPR_WLF to 1 if debug information
+ are requested. Works in the context of a parser rule. */
+#define JAVA_MAYBE_GENERATE_DEBUG_INFO(node) \
+ (debug_info_level != DINFO_LEVEL_NONE ? \
+ EXPR_WFL_EMIT_LINE_NOTE (node) = 1, node : node)
+
+/* Types classification, according to the JLS, section 4.2 */
+#define JFLOAT_TYPE_P(TYPE) (TREE_CODE ((TYPE)) == REAL_TYPE)
+#define JINTEGRAL_TYPE_P(TYPE) ((TREE_CODE ((TYPE)) == INTEGER_TYPE) \
+ || (TREE_CODE ((TYPE)) == CHAR_TYPE))
+#define JNUMERIC_TYPE_P(TYPE) (JFLOAT_TYPE_P ((TYPE)) \
+ || JINTEGRAL_TYPE_P ((TYPE)))
+#define JPRIMITIVE_TYPE_P(TYPE) (JNUMERIC_TYPE_P ((TYPE)) \
+ || (TREE_CODE ((TYPE)) == BOOLEAN_TYPE))
+
+/* Not defined in the LRM */
+#define JSTRING_TYPE_P(TYPE) ((TYPE) == string_type_node || \
+ (TREE_CODE (TYPE) == POINTER_TYPE && \
+ TREE_TYPE (op1_type) == string_type_node))
+
+#define JREFERENCE_TYPE_P(TYPE) (TREE_CODE (TYPE) == RECORD_TYPE || \
+ (TREE_CODE (TYPE) == POINTER_TYPE && \
+ TREE_CODE (TREE_TYPE (TYPE)) == RECORD_TYPE))
+
+/* Other predicate */
+#define DECL_P(NODE) (NODE && (TREE_CODE (NODE) == PARM_DECL \
+ || TREE_CODE (NODE) == VAR_DECL \
+ || TREE_CODE (NODE) == FIELD_DECL))
+
+#define TYPE_INTERFACE_P(TYPE) \
+ (CLASS_P (TYPE) && CLASS_INTERFACE (TYPE_NAME (TYPE)))
+
+#define TYPE_CLASS_P(TYPE) (CLASS_P (TYPE) \
+ && !CLASS_INTERFACE (TYPE_NAME (TYPE)) \
+ && !TYPE_ARRAY_P (TYPE))
+
+/* Standard error messages */
+#define ERROR_CANT_CONVERT_TO_BOOLEAN(OPERATOR, NODE, TYPE) \
+ parse_error_context \
+ ((OPERATOR), "Incompatible type for `%s'. Can't convert `%s' to " \
+ "boolean", operator_string ((NODE)), lang_printable_name ((TYPE)))
+
+#define ERROR_CANT_CONVERT_TO_NUMERIC(OPERATOR, NODE, TYPE) \
+ parse_error_context \
+ ((OPERATOR), "Incompatible type for `%s'. Can't convert `%s' to " \
+ "numeric type", operator_string ((NODE)), lang_printable_name ((TYPE)))
+
+#define ERROR_CAST_NEEDED_TO_INTEGRAL(OPERATOR, NODE, TYPE) \
+ parse_error_context \
+ ((OPERATOR), (JPRIMITIVE_TYPE_P (TYPE) ? \
+ "Incompatible type for `%s'. Explicit cast needed to convert " \
+ "`%s' to integral" : "Incompatible type for `%s'. Can't convert " \
+ "`%s' to integral"), operator_string ((NODE)), \
+ lang_printable_name ((TYPE)))
+
+#define ERROR_VARIABLE_NOT_INITIALIZED(WFL, V) \
+ parse_error_context \
+ ((WFL), "Variable `%s' may not have been initialized", \
+ IDENTIFIER_POINTER (V))
+
+/* Definition for loop handling. This Java's own definition of a loop
+ body. See parse.y for documentation. It's valid once you hold a
+ loop's body (LOOP_EXPR_BODY) */
+
+/* The loop main block is the one hold the condition and the loop body */
+#define LOOP_EXPR_BODY_MAIN_BLOCK(NODE) TREE_OPERAND (NODE, 0)
+/* And then there is the loop update block */
+#define LOOP_EXPR_BODY_UPDATE_BLOCK(NODE) TREE_OPERAND (NODE, 1)
+
+/* Inside the loop main block, there is the loop condition and the
+ loop body. They may be reversed if the loop being described is a
+ do-while loop. NOTE: if you use a WFL around the EXIT_EXPR so you
+ can issue debug info for it, the EXIT_EXPR will be one operand
+ further. */
+#define LOOP_EXPR_BODY_CONDITION_EXPR(NODE, R) \
+ TREE_OPERAND (LOOP_EXPR_BODY_MAIN_BLOCK (NODE), (R ? 1 : 0))
+
+/* Here is the labeled block the loop real body is encapsulated in */
+#define LOOP_EXPR_BODY_LABELED_BODY(NODE, R) \
+ TREE_OPERAND (LOOP_EXPR_BODY_MAIN_BLOCK (NODE), (R ? 0 : 1))
+/* And here is the loop's real body */
+#define LOOP_EXPR_BODY_BODY_EXPR(NODE, R) \
+ LABELED_BLOCK_BODY (LOOP_EXPR_BODY_LABELED_BODY(NODE, R))
+
+/* Does a loop have a label ? */
+#define LOOP_HAS_LABEL_P(LOOP) \
+ (ctxp->current_labeled_block \
+ && LABELED_BLOCK_BODY (ctxp->current_labeled_block) == (LOOP))
+
+/* Same operation than the one performed above, but considering the
+ previous labeled block */
+#define LOOP_HAS_LABEL_SKIP_P(LOOP) \
+ (ctxp->current_labeled_block \
+ && TREE_CHAIN (ctxp->current_labeled_block) \
+ && LABELED_BLOCK_BODY (TREE_CHAIN (ctxp->current_labeled_block)) == (LOOP))
+
+#define PUSH_LABELED_BLOCK(B) \
+ { \
+ TREE_CHAIN (B) = ctxp->current_labeled_block; \
+ ctxp->current_labeled_block = (B); \
+ }
+#define POP_LABELED_BLOCK() \
+ ctxp->current_labeled_block = TREE_CHAIN (ctxp->current_labeled_block)
+
+#define PUSH_LOOP(L) \
+ { \
+ TREE_CHAIN (L) = ctxp->current_loop; \
+ ctxp->current_loop = (L); \
+ }
+#define POP_LOOP() ctxp->current_loop = TREE_CHAIN (ctxp->current_loop)
+
+
+/* Invocation modes, as returned by invocation_mode (). */
+enum {
+ INVOKE_STATIC,
+ INVOKE_NONVIRTUAL,
+ INVOKE_SUPER,
+ INVOKE_INTERFACE,
+ INVOKE_VIRTUAL,
+};
+
+/* We need the resolution stuff only if we compile jc1 */
+#ifndef JC1_LITE
+
+/* Unresolved type identifiers handling. When we process the source
+ code, we blindly accept an unknown type identifier and try to
+ resolve it later. When an unknown type identifier is encountered
+ and used, we record in a struct jdep element what the incomplete
+ type is and what it should patch. Later, java_complete_class will
+ process all classes known to have unresolved type
+ dependencies. Within each of these classes, this routine will
+ process unresolved type dependencies (JDEP_TO_RESOLVE), patch what
+ needs to be patched in the dependent tree node (JDEP_GET_PATCH,
+ JDEP_APPLY_PATCH) and perform other actions dictated by the context
+ of the patch (JDEP_KIND). The ideas are: we patch only what needs
+ to be patched, and with java_complete_class called at the right
+ time, we will start processing incomplete function bodies tree
+ nodes with everything external to function's bodies already
+ completed, it makes things much simpler. */
+
+enum jdep_code {
+ JDEP_NO_PATCH, /* Must be first */
+ JDEP_SUPER, /* Patch the type of one type
+ supertype. Requires some check
+ before it's done */
+ JDEP_FIELD, /* Patch the type of a class field */
+
+ /* JDEP_{METHOD,METHOD_RETURN,METHOD_END} to be kept in order */
+ JDEP_METHOD, /* Mark the beginning of the patching
+ of a method declaration, including
+ it's arguments */
+ JDEP_METHOD_RETURN, /* Mark the beginning of the patching
+ of a method declaration. Arguments
+ aren't patched, only the returned
+ type is */
+ JDEP_METHOD_END, /* Mark the end of the patching of a
+ method declaration. It indicates
+ that it's time to compute and
+ install a new signature */
+
+ JDEP_INTERFACE, /* Patch the type of a Class/interface
+ extension */
+ JDEP_VARIABLE, /* Patch the type of a variable declaration */
+ JDEP_PARM, /* Patch the type of a parm declaration */
+ JDEP_TYPE, /* Patch a random tree node type,
+ without the need for any specific
+ actions */
+};
+
+typedef struct _jdep {
+#ifdef ONLY_INT_FIELDS
+ int kind : 8; /* Type of patch */
+#else
+ enum jdep_code kind : 8;
+#endif
+
+ int flag0 : 1; /* Some flags */
+ tree decl; /* Tied decl/or WFL */
+ tree solv; /* What to solve */
+ tree wfl; /* Where thing to resolve where found */
+ tree misc; /* Miscellaneous info (optional). */
+ tree *patch; /* Address of a location to patch */
+ struct _jdep *next; /* Linked list */
+} jdep;
+
+
+#define JDEP_DECL(J) ((J)->decl)
+#define JDEP_DECL_WFL(J) ((J)->decl)
+#define JDEP_KIND(J) ((J)->kind)
+#define JDEP_SOLV(J) ((J)->solv)
+#define JDEP_WFL(J) ((J)->wfl)
+#define JDEP_MISC(J) ((J)->misc)
+#define JDEP_CLASS(J) ((J)->class)
+#define JDEP_APPLY_PATCH(J,P) (*(J)->patch = (P))
+#define JDEP_GET_PATCH(J) ((J)->patch)
+#define JDEP_CHAIN(J) ((J)->next)
+#define JDEP_TO_RESOLVE(J) (TREE_PURPOSE ((J)->solv))
+#define JDEP_RESOLVED_DECL(J) ((J)->solv ? TREE_PURPOSE ((J)->solv):NULL_TREE)
+#define JDEP_RESOLVED(J, D) \
+ { \
+ TREE_PURPOSE ((J)->solv) = D; \
+ TREE_VALUE ((J)->solv) = (J)->solv; \
+ }
+#define JDEP_RESOLVED_P(J) (!(J)->solv || \
+ TREE_VALUE ((J)->solv) == (J)->solv)
+
+typedef struct _jdeplist {
+ jdep *first;
+ jdep *last;
+ struct _jdeplist *next;
+} jdeplist;
+static jdeplist *reverse_jdep_list ();
+
+#endif /* JC1_LITE */
+
+#define CLASSD_FIRST(CD) ((CD)->first)
+#define CLASSD_LAST(CD) ((CD)->last)
+#define CLASSD_CHAIN(CD) ((CD)->next)
+
+#define JDEP_INSERT(L,J) \
+ { \
+ if (!(L)->first) \
+ (L)->last = (L)->first = (J); \
+ else \
+ { \
+ JDEP_CHAIN ((L)->last) = (J); \
+ (L)->last = (J); \
+ } \
+ }
+
+/* Insert a DECL in the current block */
+#define BLOCK_CHAIN_DECL(NODE) \
+ { \
+ TREE_CHAIN ((NODE)) = \
+ BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)); \
+ BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) = (NODE); \
+ }
+
+#define BLOCK_EXPR_DECLS(NODE) BLOCK_VARS(NODE)
+#define BLOCK_EXPR_BODY(NODE) BLOCK_SUBBLOCKS(NODE)
+#define BLOCK_EXPR_ORIGIN(NODE) BLOCK_ABSTRACT_ORIGIN(NODE)
+
+/* Merge an other line to the source line number of a decl. Used to
+ remember function's end. */
+#define DECL_SOURCE_LINE_MERGE(DECL,NO) DECL_SOURCE_LINE(DECL) |= (NO << 16)
+
+/* Retrieve those two info separately. */
+#define DECL_SOURCE_LINE_FIRST(DECL) (DECL_SOURCE_LINE(DECL) & 0x0000ffff)
+#define DECL_SOURCE_LINE_LAST(DECL) (DECL_SOURCE_LINE(DECL) >> 16)
+
+/* Build a WFL for expression nodes */
+#define BUILD_EXPR_WFL(NODE, WFL) \
+ build_expr_wfl ((NODE), input_filename, EXPR_WFL_LINENO ((WFL)), \
+ EXPR_WFL_COLNO ((WFL)))
+
+#define EXPR_WFL_QUALIFICATION(WFL) TREE_OPERAND ((WFL), 1)
+#define QUAL_WFL(NODE) TREE_PURPOSE (NODE)
+#define QUAL_RESOLUTION(NODE) TREE_VALUE (NODE)
+#define QUAL_DECL_TYPE(NODE) \
+ (TREE_CODE (TREE_TYPE (NODE)) == POINTER_TYPE ? \
+ TREE_TYPE (TREE_TYPE (NODE)) : TREE_TYPE (NODE))
+
+/* Handy macros for the walk operation */
+#define COMPLETE_CHECK_OP(NODE, N) \
+{ \
+ TREE_OPERAND ((NODE), (N)) = \
+ java_complete_tree (TREE_OPERAND ((NODE), (N))); \
+ if (TREE_OPERAND ((NODE), (N)) == error_mark_node) \
+ return error_mark_node; \
+}
+#define COMPLETE_CHECK_OP_0(NODE) COMPLETE_CHECK_OP(NODE, 0)
+#define COMPLETE_CHECK_OP_1(NODE) COMPLETE_CHECK_OP(NODE, 1)
+
+/* Parser context data structure. */
+struct parser_ctxt {
+
+ char *filename; /* Current filename */
+ FILE *finput; /* Current file input stream */
+ struct parser_ctxt *next;
+
+ struct java_line *p_line, *c_line; /* Previous and current line */
+ java_lc elc; /* Error's line column info */
+ unicode_t unget_utf8_value; /* An unget utf8 value */
+ int ccb_indent; /* Keep track of {} indent, lexer */
+ int first_ccb_indent1; /* First { at ident level 1 */
+ int last_ccb_indent1; /* Last } at ident level 1 */
+ int parser_ccb_indent; /* Keep track of {} indent, parser */
+ int osb_number; /* Keep track of ['s */
+ int minus_seen; /* Integral literal overflow */
+ int lineno; /* Current lineno */
+ int java_error_flag; /* Report error when true */
+
+ /* This section is defined only if we compile jc1 */
+#ifndef JC1_LITE
+ tree modifier_ctx [11]; /* WFL of modifiers */
+ tree current_class; /* Current class */
+ tree current_function_decl; /* Current function decl, save/restore */
+
+ JCF *current_jcf; /* CU jcf */
+
+ int prevent_ese; /* Prevent expression statement error */
+ int class_err; /* Flag to report certain errors */
+
+ int formal_parameter_number; /* Number of parameters found */
+ int interface_number; /* # itfs declared to extend an itf def */
+
+ tree package; /* Defined package ID */
+
+ tree incomplete_class; /* List of non-complete classes */
+ tree current_parsed_class; /* Class currently parsed */
+ tree class_list; /* List of classes in a CU */
+ jdeplist *classd_list; /* Classe dependencies in a CU */
+
+ tree non_static_initialized; /* List of non static initialized fields */
+ tree static_initialized; /* List of static non final initialized */
+
+ tree import_list; /* List of import */
+ tree import_demand_list; /* List of import on demand */
+
+ tree current_loop; /* List of the currently nested loops */
+ tree current_labeled_block; /* List of currently nested
+ labeled blocks. */
+
+ int pending_block; /* Pending block to close */
+#endif /* JC1_LITE */
+};
+
+/* Functions declarations */
+#ifndef JC1_LITE
+static char *java_accstring_lookup PROTO ((int));
+static void parse_error PROTO ((char *));
+static void redefinition_error PROTO ((char *,tree, tree, tree));
+static void check_modifiers PROTO ((char *, int, int));
+static tree create_class PROTO ((int, tree, tree, tree));
+static tree create_interface PROTO ((int, tree, tree));
+static tree find_field PROTO ((tree, tree));
+static tree lookup_field_wrapper PROTO ((tree, tree));
+static int duplicate_declaration_error PROTO ((tree, tree, tree, tree));
+static void register_fields PROTO ((int, tree, tree));
+static tree parser_qualified_classname PROTO ((tree));
+static int parser_check_super PROTO ((tree, tree, tree));
+static int parser_check_super_interface PROTO ((tree, tree, tree));
+static void check_modifiers_consistency PROTO ((int));
+static tree lookup_cl PROTO ((tree));
+static tree lookup_java_method2 PROTO ((tree, tree, int));
+static tree method_header PROTO ((int, tree, tree, tree));
+static tree method_declarator PROTO ((tree, tree));
+static void parse_error_context VPROTO ((tree cl, char *msg, ...));
+static void parse_warning_context VPROTO ((tree cl, char *msg, ...));
+static void complete_class_report_errors PROTO ((jdep *));
+static int process_imports PROTO ((void));
+static void read_import_dir PROTO ((tree));
+static int find_in_imports_on_demand PROTO ((tree));
+static int find_in_imports PROTO ((tree));
+static int check_pkg_class_access PROTO ((tree, tree));
+static tree resolve_class PROTO ((tree, tree, tree));
+static tree do_resolve_class PROTO ((tree, tree, tree));
+static void declare_local_variables PROTO ((int, tree, tree));
+static void source_start_java_method PROTO ((tree));
+static void source_end_java_method PROTO ((void));
+static void expand_start_java_method PROTO ((tree));
+static tree find_name_in_single_imports PROTO ((tree));
+static void check_abstract_method_header PROTO ((tree));
+static tree lookup_java_interface_method2 PROTO ((tree, tree));
+static tree resolve_expression_name PROTO ((tree));
+static tree maybe_create_class_interface_decl PROTO ((tree, tree, tree));
+static int check_class_interface_creation PROTO ((int, int, tree, tree, tree, tree));
+static tree patch_method_invocation_stmt PROTO ((tree, tree, tree, int *));
+static int breakdown_qualified PROTO ((tree *, tree *, tree));
+static tree resolve_and_layout PROTO ((tree, tree));
+static tree resolve_no_layout PROTO ((tree, tree));
+static int identical_subpath_p PROTO ((tree, tree));
+static int invocation_mode PROTO ((tree, int));
+static tree refine_accessible_methods_list PROTO ((int, tree));
+static tree patch_invoke PROTO ((tree, tree, tree, tree));
+static tree lookup_method_invoke PROTO ((int, tree, tree, tree, tree));
+static tree register_incomplete_type PROTO ((int, tree, tree, tree));
+static tree obtain_incomplete_type PROTO ((tree));
+static tree java_complete_tree PROTO ((tree));
+static void java_complete_expand_method PROTO ((tree));
+static int unresolved_type_p PROTO ((tree, tree *));
+static void create_jdep_list PROTO ((struct parser_ctxt *));
+static tree build_expr_block PROTO ((tree, tree));
+static tree enter_block PROTO ((void));
+static tree exit_block PROTO ((void));
+static tree lookup_name_in_blocks PROTO ((tree));
+static void maybe_absorb_scoping_blocks PROTO ((void));
+static tree build_method_invocation PROTO ((tree, tree));
+static tree build_assignment PROTO ((int, int, tree, tree));
+static tree build_binop PROTO ((enum tree_code, int, tree, tree));
+static tree patch_assignment PROTO ((tree, tree, tree ));
+static tree patch_binop PROTO ((tree, tree, tree));
+static tree build_unaryop PROTO ((int, int, tree));
+static tree build_incdec PROTO ((int, int, tree, int));
+static tree patch_unaryop PROTO ((tree, tree));
+static tree build_cast PROTO ((int, tree, tree));
+static tree patch_cast PROTO ((tree, tree, tree));
+static int valid_ref_assignconv_cast_p PROTO ((tree, tree, int));
+static int can_cast_to_p PROTO ((tree, tree));
+static tree build_unresolved_array_type PROTO ((tree));
+static tree build_array_ref PROTO ((int, tree, tree));
+static tree patch_array_ref PROTO ((tree, tree, tree));
+static tree make_qualified_name PROTO ((tree, tree, int));
+static tree merge_qualified_name PROTO ((tree, tree));
+static tree make_qualified_primary PROTO ((tree, tree, int));
+static int resolve_qualified_expression_name PROTO ((tree, tree *, tree *, tree *));
+static void qualify_ambiguous_name PROTO ((tree));
+static void maybe_generate_clinit PROTO ((void));
+static tree resolve_field_access PROTO ((tree, tree *, tree *));
+static tree build_newarray_node PROTO ((tree, tree, int));
+static tree patch_newarray PROTO ((tree));
+static tree resolve_type_during_patch PROTO ((tree));
+static int not_initialized_as_it_should_p PROTO ((tree));
+static tree build_this PROTO ((int));
+static tree build_return PROTO ((int, tree));
+static tree patch_return PROTO ((tree));
+static tree maybe_access_field PROTO ((tree, tree, tree));
+static int complete_function_arguments PROTO ((tree));
+static int check_for_static_method_reference PROTO ((tree, tree, tree, tree, tree));
+static int not_accessible_p PROTO ((tree, tree, int));
+static int class_in_current_package PROTO ((tree));
+static tree build_if_else_statement PROTO ((int, tree, tree, tree));
+static tree patch_if_else_statement PROTO ((tree));
+static tree add_stmt_to_compound PROTO ((tree, tree, tree));
+static tree patch_exit_expr PROTO ((tree));
+static tree build_labeled_block PROTO ((int, tree, tree));
+static tree generate_labeled_block PROTO (());
+static tree complete_labeled_statement PROTO ((tree, tree));
+static tree build_bc_statement PROTO ((int, int, tree));
+static tree patch_bc_statement PROTO ((tree));
+static tree patch_loop_statement PROTO ((tree));
+static tree build_new_loop PROTO ((tree));
+static tree build_loop_body PROTO ((int, tree, int));
+static tree complete_loop_body PROTO ((int, tree, tree, int));
+static tree build_debugable_stmt PROTO ((int, tree));
+static tree complete_for_loop PROTO ((int, tree, tree, tree));
+
+void safe_layout_class PROTO ((tree));
+void java_complete_class PROTO ((void));
+void java_check_circular_reference PROTO ((void));
+void java_check_final PROTO ((void));
+void java_check_methods PROTO ((void));
+void java_layout_classes PROTO ((void));
+tree java_method_add_stmt PROTO ((tree, tree));
+char *java_get_line_col PROTO ((char *, int, int));
+#endif /* JC1_LITE */
+
+/* Always in use, no matter what you compile */
+
+void java_push_parser_context PROTO ((void));
+void java_init_lex PROTO ((void));
+int yyparse PROTO ((void));
+int yylex ();
+void yyerror PROTO ((char *));
+
+#endif
--- /dev/null
+/* Source code parsing and tree node generation for the GNU compiler
+ for the Java(TM) language.
+ Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+ Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* This file parses java source code and issues a tree node image
+suitable for code generation (byte code and targeted CPU assembly
+language).
+
+The grammar conforms to the Java grammar described in "The Java(TM)
+Language Specification. J. Gosling, B. Joy, G. Steele. Addison Wesley
+1996, ISBN 0-201-63451-1"
+
+The following modifications were brought to the original grammar:
+
+method_body: added the rule '| block SC_TK'
+constructor_declaration: added two rules to accept SC_TK.
+static_initializer: added the rule 'static block SC_TK'.
+
+Note: All the extra rules described above should go away when the
+ empty_statement rule will work.
+
+statement_nsi: 'nsi' should be read no_short_if.
+
+Some rules have been modified to support JDK1.1 inner classes
+definitions and other extensions. */
+
+%{
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+#ifdef __STDC__
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+#include "config.h"
+#include "tree.h"
+#include "rtl.h"
+#include "obstack.h"
+#include "flags.h"
+#include "java-tree.h"
+#include "jcf.h"
+#include "lex.h"
+#include "parse.h"
+#include "zipfile.h"
+
+/* Number of error found so far. */
+int java_error_count;
+/* Number of warning found so far. */
+int java_warning_count;
+
+/* The current parser context */
+static struct parser_ctxt *ctxp;
+
+/* binop_lookup maps token to tree_code. It is used where binary
+ operations are involved and required by the parser. RDIV_EXPR
+ covers both integral/floating point division. The code is changed
+ once the type of both operator is worked out. */
+
+static enum tree_code binop_lookup[19] =
+ {
+ PLUS_EXPR, MINUS_EXPR, MULT_EXPR, RDIV_EXPR, TRUNC_MOD_EXPR,
+ LSHIFT_EXPR, RSHIFT_EXPR, URSHIFT_EXPR,
+ BIT_AND_EXPR, BIT_XOR_EXPR, BIT_IOR_EXPR,
+ TRUTH_ANDIF_EXPR, TRUTH_ORIF_EXPR,
+ EQ_EXPR, NE_EXPR, GT_EXPR, GE_EXPR, LT_EXPR, LE_EXPR,
+ };
+#define BINOP_LOOKUP(VALUE) \
+ binop_lookup [((VALUE) - PLUS_TK)% \
+ (sizeof (binop_lookup) / sizeof (binop_lookup[0]))]
+
+/* Fake WFL used to report error message. It is initialized once if
+ needed and reused with it's location information is overriden. */
+static tree wfl_operator = NULL_TREE;
+
+/* The "$L" identifier we use to create labels. */
+static tree label_id;
+%}
+
+%union {
+ tree node;
+ int sub_token;
+ struct {
+ int token;
+ int location;
+ } operator;
+ int value;
+}
+
+%pure_parser
+
+/* Things defined here have to match the order of what's in the
+ binop_lookup table. */
+
+%token PLUS_TK MINUS_TK MULT_TK DIV_TK REM_TK
+%token LS_TK SRS_TK ZRS_TK
+%token AND_TK XOR_TK OR_TK
+%token BOOL_AND_TK BOOL_OR_TK
+%token EQ_TK NEQ_TK GT_TK GTE_TK LT_TK LTE_TK
+
+/* This maps to the same binop_lookup entry than the token above */
+
+%token PLUS_ASSIGN_TK MINUS_ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
+%token REM_ASSIGN_TK
+%token LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
+%token AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
+
+
+/* Modifier TOKEN have to be kept in this order. Don't scramble it */
+
+%token PUBLIC_TK PRIVATE_TK PROTECTED_TK
+%token STATIC_TK FINAL_TK SYNCHRONIZED_TK
+%token VOLATILE_TK TRANSIENT_TK NATIVE_TK
+%token PAD_TK ABSTRACT_TK MODIFIER_TK
+
+/* Keep those two in order, too */
+%token DECR_TK INCR_TK
+
+/* From now one, things can be in any order */
+
+%token DEFAULT_TK IF_TK THROW_TK
+%token BOOLEAN_TK DO_TK IMPLEMENTS_TK
+%token THROWS_TK BREAK_TK IMPORT_TK
+%token ELSE_TK INSTANCEOF_TK RETURN_TK
+%token VOID_TK CATCH_TK INTERFACE_TK
+%token CASE_TK EXTENDS_TK FINALLY_TK
+%token SUPER_TK WHILE_TK CLASS_TK
+%token SWITCH_TK CONST_TK TRY_TK
+%token FOR_TK NEW_TK CONTINUE_TK
+%token GOTO_TK PACKAGE_TK THIS_TK
+
+%token BYTE_TK SHORT_TK INT_TK LONG_TK
+%token CHAR_TK INTEGRAL_TK
+
+%token FLOAT_TK DOUBLE_TK FP_TK
+
+%token ID_TK
+
+%token REL_QM_TK REL_CL_TK NOT_TK NEG_TK
+
+%token ASSIGN_ANY_TK ASSIGN_TK
+%token OP_TK CP_TK OCB_TK CCB_TK OSB_TK CSB_TK SC_TK C_TK DOT_TK
+
+%token STRING_LIT_TK CHAR_LIT_TK INT_LIT_TK FP_LIT_TK
+%token TRUE_TK FALSE_TK BOOL_LIT_TK NULL_TK
+
+%type <value> modifiers MODIFIER_TK
+
+%type <node> super ID_TK identifier
+%type <node> name simple_name qualified_name
+%type <node> class_declaration type_declaration compilation_unit
+ field_declaration method_declaration extends_interfaces
+ interfaces interface_type_list
+ interface_declaration class_member_declaration
+ import_declarations package_declaration
+ type_declarations interface_body
+ interface_member_declaration constant_declaration
+ interface_member_declarations interface_type
+ abstract_method_declaration interface_type_list
+%type <node> class_body_declaration class_member_declaration
+ static_initializer constructor_declaration block
+%type <node> class_body_declarations
+%type <node> class_or_interface_type class_type class_type_list
+ constructor_declarator explicit_constructor_invocation
+%type <node> dim_expr dim_exprs this_or_super
+
+%type <node> variable_declarator_id variable_declarator
+ variable_declarators variable_initializer
+ variable_initializers
+
+%type <node> class_body
+%type <node> block_statement local_variable_declaration_statement
+ block_statements local_variable_declaration
+%type <node> statement statement_without_trailing_substatement
+ labeled_statement if_then_statement label_decl
+ if_then_else_statement while_statement for_statement
+ statement_nsi labeled_statement_nsi do_statement
+ if_then_else_statement_nsi while_statement_nsi
+ for_statement_nsi statement_expression_list for_init
+ for_update statement_expression expression_statement
+ primary_no_new_array expression primary
+ array_creation_expression array_type
+ class_instance_creation_expression field_access
+ method_invocation array_access something_dot_new
+ argument_list postfix_expression while_expression
+ post_increment_expression post_decrement_expression
+ unary_expression_not_plus_minus unary_expression
+ pre_increment_expression pre_decrement_expression
+ unary_expression_not_plus_minus cast_expression
+ multiplicative_expression additive_expression
+ shift_expression relational_expression
+ equality_expression and_expression
+ exclusive_or_expression inclusive_or_expression
+ conditional_and_expression conditional_or_expression
+ conditional_expression assignment_expression
+ left_hand_side assignment for_header for_begin
+ constant_expression do_statement_begin empty_statement
+%type <node> return_statement break_statement continue_statement
+
+%type <operator> ASSIGN_TK MULT_ASSIGN_TK DIV_ASSIGN_TK
+%type <operator> REM_ASSIGN_TK PLUS_ASSIGN_TK MINUS_ASSIGN_TK
+%type <operator> LS_ASSIGN_TK SRS_ASSIGN_TK ZRS_ASSIGN_TK
+%type <operator> AND_ASSIGN_TK XOR_ASSIGN_TK OR_ASSIGN_TK
+%type <operator> ASSIGN_ANY_TK assignment_operator
+%token <operator> EQ_TK GTE_TK ZRS_TK SRS_TK GT_TK LTE_TK LS_TK
+%token <operator> BOOL_AND_TK AND_TK BOOL_OR_TK OR_TK INCR_TK PLUS_TK
+%token <operator> DECR_TK MINUS_TK MULT_TK DIV_TK XOR_TK REM_TK NEQ_TK
+%token <operator> NEG_TK REL_QM_TK REL_CL_TK NOT_TK LT_TK
+%token <operator> OP_TK OSB_TK DOT_TK
+%type <operator> THIS_TK SUPER_TK RETURN_TK BREAK_TK CONTINUE_TK
+
+%type <node> method_body
+
+%type <node> literal INT_LIT_TK FP_LIT_TK BOOL_LIT_TK CHAR_LIT_TK
+ STRING_LIT_TK NULL_TK VOID_TK
+
+%type <node> IF_TK WHILE_TK FOR_TK
+
+%type <node> formal_parameter_list formal_parameter
+ method_declarator method_header
+
+%type <node> primitive_type reference_type type
+ BOOLEAN_TK INTEGRAL_TK FP_TK
+
+%%
+/* 19.2 Production from 2.3: The Syntactic Grammar */
+goal:
+ compilation_unit
+ {}
+;
+
+/* 19.3 Productions from 3: Lexical structure */
+literal:
+ INT_LIT_TK
+| FP_LIT_TK
+| BOOL_LIT_TK
+| CHAR_LIT_TK
+| STRING_LIT_TK
+| NULL_TK
+;
+
+/* 19.4 Productions from 4: Types, Values and Variables */
+type:
+ primitive_type
+| reference_type
+;
+
+primitive_type:
+ INTEGRAL_TK
+| FP_TK
+| BOOLEAN_TK
+;
+
+reference_type:
+ class_or_interface_type
+| array_type
+;
+
+class_or_interface_type:
+ name
+;
+
+class_type:
+ class_or_interface_type /* Default rule */
+;
+
+interface_type:
+ class_or_interface_type
+;
+
+array_type:
+ primitive_type OSB_TK CSB_TK
+ {
+ $$ = build_java_array_type ($1, -1);
+ CLASS_LOADED_P ($$) = 1;
+ }
+| name OSB_TK CSB_TK
+ { $$ = build_unresolved_array_type ($1); }
+| array_type OSB_TK CSB_TK
+ { $$ = build_unresolved_array_type ($1); }
+| primitive_type OSB_TK error
+ {RULE ("']' expected"); RECOVER;}
+| array_type OSB_TK error
+ {RULE ("']' expected"); RECOVER;}
+;
+
+/* 19.5 Productions from 6: Names */
+name:
+ simple_name /* Default rule */
+| qualified_name /* Default rule */
+;
+
+simple_name:
+ identifier /* Default rule */
+;
+
+qualified_name:
+ name DOT_TK identifier
+ { $$ = make_qualified_name ($1, $3, $2.location); }
+;
+
+identifier:
+ ID_TK
+;
+
+/* 19.6: Production from 7: Packages */
+compilation_unit:
+ {$$ = NULL;}
+| package_declaration
+| import_declarations
+| type_declarations
+| package_declaration import_declarations
+| package_declaration type_declarations
+| import_declarations type_declarations
+| package_declaration import_declarations type_declarations
+;
+
+import_declarations:
+ import_declaration
+ {
+ $$ = NULL;
+ }
+| import_declarations import_declaration
+ {
+ $$ = NULL;
+ }
+;
+
+type_declarations:
+ type_declaration
+| type_declarations type_declaration
+;
+
+package_declaration:
+ PACKAGE_TK name SC_TK
+ { ctxp->package = EXPR_WFL_NODE ($2); }
+| PACKAGE_TK error
+ {yyerror ("Missing name"); RECOVER;}
+| PACKAGE_TK name error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+import_declaration:
+ single_type_import_declaration
+| type_import_on_demand_declaration
+;
+
+single_type_import_declaration:
+ IMPORT_TK name SC_TK
+ {
+ tree name = EXPR_WFL_NODE ($2), node, last_name;
+ int i = IDENTIFIER_LENGTH (name)-1;
+ char *last = &IDENTIFIER_POINTER (name)[i];
+ while (last != IDENTIFIER_POINTER (name))
+ {
+ if (last [0] == '.')
+ break;
+ last--;
+ }
+ last_name = get_identifier (++last);
+ if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name))
+ {
+ tree err = find_name_in_single_imports (last_name);
+ if (err && err != name)
+ parse_error_context
+ ($2, "Ambiguous class: `%s' and `%s'",
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (err));
+ }
+ else
+ {
+ IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (last_name) = 1;
+ node = build_tree_list ($2, last_name);
+ TREE_CHAIN (node) = ctxp->import_list;
+ ctxp->import_list = node;
+ }
+ }
+| IMPORT_TK error
+ {yyerror ("Missing name"); RECOVER;}
+| IMPORT_TK name error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+type_import_on_demand_declaration:
+ IMPORT_TK name DOT_TK MULT_TK SC_TK
+ {
+ tree name = EXPR_WFL_NODE ($2);
+ tree node = build_tree_list ($2, NULL_TREE);
+ if (!IS_AN_IMPORT_ON_DEMAND_P (name))
+ {
+ read_import_dir ($2);
+ IS_AN_IMPORT_ON_DEMAND_P (name) = 1;
+ }
+ TREE_CHAIN (node) = ctxp->import_demand_list;
+ ctxp->import_demand_list = node;
+ }
+| IMPORT_TK name DOT_TK error
+ {yyerror ("'*' expected"); RECOVER;}
+| IMPORT_TK name DOT_TK MULT_TK error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+type_declaration:
+ class_declaration
+ {
+ maybe_generate_clinit ();
+ $$ = $1;
+ }
+| interface_declaration
+| SC_TK
+ { $$ = NULL; }
+| error
+ {
+ YYERROR_NOW;
+ yyerror ("Class or interface declaration expected");
+ }
+;
+
+/* 19.7 Shortened from the original:
+ modifiers: modifier | modifiers modifier
+ modifier: any of public... */
+modifiers:
+ MODIFIER_TK
+ {
+ $$ = (1 << $1);
+ }
+| modifiers MODIFIER_TK
+ {
+ int acc = (1 << $2);
+ if ($$ & acc)
+ parse_error_context
+ (ctxp->modifier_ctx [$2], "Modifier `%s' declared twice",
+ java_accstring_lookup (acc));
+ else
+ {
+ $$ |= acc;
+ }
+ }
+;
+
+/* 19.8.1 Production from $8.1: Class Declaration */
+class_declaration:
+ modifiers CLASS_TK identifier super interfaces
+ { create_class ($1, $3, $4, $5); }
+ class_body
+ {
+ $$ = $7;
+ }
+| CLASS_TK identifier super interfaces
+ { create_class (0, $2, $3, $4); }
+ class_body
+ {
+ $$ = $6;
+ }
+| modifiers CLASS_TK error
+ {yyerror ("Missing class name"); RECOVER;}
+| CLASS_TK error
+ {yyerror ("Missing class name"); RECOVER;}
+| CLASS_TK identifier error
+ {if (!ctxp->class_err) yyerror ("'{' expected"); DRECOVER(class1);}
+| modifiers CLASS_TK identifier error
+ {if (!ctxp->class_err) yyerror ("'{' expected"); RECOVER;}
+;
+
+super:
+ { $$ = NULL; }
+| EXTENDS_TK class_type
+ { $$ = $2; }
+| EXTENDS_TK class_type error
+ {yyerror ("'{' expected"); ctxp->class_err=1;}
+| EXTENDS_TK error
+ {yyerror ("Missing super class name"); ctxp->class_err=1;}
+;
+
+interfaces:
+ { $$ = NULL_TREE; }
+| IMPLEMENTS_TK interface_type_list
+ { $$ = $2; }
+| IMPLEMENTS_TK error
+ {
+ ctxp->class_err=1;
+ yyerror ("Missing interface name");
+ }
+;
+
+interface_type_list:
+ interface_type
+ {
+ ctxp->interface_number = 1;
+ $$ = build_tree_list ($1, NULL_TREE);
+ }
+| interface_type_list C_TK interface_type
+ {
+ ctxp->interface_number++;
+ $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
+ }
+| interface_type_list C_TK error
+ {yyerror ("Missing interface name"); RECOVER;}
+;
+
+class_body:
+ OCB_TK CCB_TK
+ { $$ = ctxp->current_parsed_class; }
+| OCB_TK class_body_declarations CCB_TK
+ { $$ = ctxp->current_parsed_class; }
+;
+
+class_body_declarations:
+ class_body_declaration
+| class_body_declarations class_body_declaration
+;
+
+class_body_declaration:
+ class_member_declaration
+| static_initializer
+| constructor_declaration
+| block /* Added, JDK1.1, instance initializer */
+;
+
+class_member_declaration:
+ field_declaration
+| method_declaration
+| class_declaration /* Added, JDK1.1 inner classes */
+| interface_declaration /* Added, JDK1.1 inner classes */
+;
+
+/* 19.8.2 Productions from 8.3: Field Declarations */
+field_declaration:
+ type variable_declarators SC_TK
+ { register_fields (0, $1, $2); }
+| modifiers type variable_declarators SC_TK
+ {
+ int acc_count = 0;
+
+ check_modifiers
+ ("Illegal modifier `%s' for field declaration",
+ $1, FIELD_MODIFIERS);
+ check_modifiers_consistency ($1);
+ register_fields ($1, $2, $3);
+ }
+;
+
+variable_declarators:
+ /* Should we use build_decl_list () instead ? FIXME */
+ variable_declarator /* Default rule */
+| variable_declarators C_TK variable_declarator
+ { $$ = chainon ($1, $3); }
+| variable_declarators C_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+variable_declarator:
+ variable_declarator_id
+ { $$ = build_tree_list ($1, NULL_TREE); }
+| variable_declarator_id ASSIGN_TK variable_initializer
+ {
+ if (java_error_count)
+ $3 = NULL_TREE;
+ $$ = build_tree_list
+ ($1, build_assignment ($2.token, $2.location, $1, $3));
+ }
+| variable_declarator_id ASSIGN_TK error
+ {
+ yyerror ("Missing variable initializer");
+ $$ = build_tree_list ($1, NULL_TREE);
+ RECOVER;
+ }
+| variable_declarator_id ASSIGN_TK variable_initializer error
+ {
+ yyerror ("';' expected");
+ $$ = build_tree_list ($1, NULL_TREE);
+ RECOVER;
+ }
+;
+
+variable_declarator_id:
+ identifier
+| variable_declarator_id OSB_TK CSB_TK
+ {
+ $$ = NULL; /* FIXME */
+ }
+| identifier error
+ {yyerror ("Invalid declaration"); DRECOVER(vdi);}
+| variable_declarator_id OSB_TK error
+ {yyerror ("']' expected"); DRECOVER(vdi);}
+| variable_declarator_id CSB_TK error
+ {yyerror ("Unbalanced ']'"); DRECOVER(vdi);}
+;
+
+variable_initializer:
+ expression
+| array_initializer
+ { $$ = NULL; }
+;
+
+/* 19.8.3 Productions from 8.4: Method Declarations */
+method_declaration:
+ method_header
+ {
+ current_function_decl = $1;
+ source_start_java_method (current_function_decl);
+ }
+ method_body
+ {
+ BLOCK_EXPR_BODY
+ (DECL_FUNCTION_BODY (current_function_decl)) = $3;
+ maybe_absorb_scoping_blocks ();
+ exit_block (); /* Exit function's body. */
+
+ /* Merge last line of the function with first line,
+ directly in the function decl. It will be used to
+ emit correct debug info. */
+ DECL_SOURCE_LINE_MERGE (current_function_decl,
+ ctxp->last_ccb_indent1);
+ }
+| method_header error
+ {YYNOT_TWICE yyerror ("'{' expected"); RECOVER;}
+;
+
+method_header:
+ type method_declarator throws
+ { $$ = method_header (0, $1, $2, NULL); }
+| VOID_TK method_declarator throws
+ { $$ = method_header (0, void_type_node, $2, NULL); }
+| modifiers type method_declarator throws
+ { $$ = method_header ($1, $2, $3, NULL); }
+| modifiers VOID_TK method_declarator throws
+ { $$ = method_header ($1, void_type_node, $3, NULL); }
+| type error
+ {RECOVER;}
+| modifiers type error
+ {RECOVER;}
+| VOID_TK error
+ {yyerror ("Identifier expected"); RECOVER;}
+| modifiers VOID_TK error
+ {yyerror ("Identifier expected"); RECOVER;}
+| modifiers error
+ {
+ yyerror ("Invalid method declaration, return type required");
+ RECOVER;
+ }
+;
+
+method_declarator:
+ identifier OP_TK CP_TK
+ { $$ = method_declarator ($1, NULL_TREE); }
+| identifier OP_TK formal_parameter_list CP_TK
+ { $$ = method_declarator ($1, $3); }
+| method_declarator OSB_TK CSB_TK
+ {
+ /* Issue a warning here: obsolete declaration. FIXME */
+ $$ = NULL; /* FIXME */
+ }
+| identifier OP_TK error
+ {yyerror ("')' expected"); DRECOVER(method_declarator);}
+| method_declarator OSB_TK error
+ {yyerror ("']' expected"); RECOVER;}
+;
+
+formal_parameter_list:
+ formal_parameter
+ {
+ ctxp->formal_parameter_number = 1;
+ }
+| formal_parameter_list C_TK formal_parameter
+ {
+ ctxp->formal_parameter_number += 1;
+ $$ = chainon ($1, $3);
+ }
+| formal_parameter_list C_TK error
+ {yyerror ("Missing formal parameter term"); RECOVER;}
+;
+
+formal_parameter:
+ type variable_declarator_id
+ {
+ $$ = build_tree_list ($2, $1);
+ }
+| modifiers type variable_declarator_id /* Added, JDK1.1 final locals */
+ {
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
+ $$ = NULL; /* FIXME */
+ }
+| type error
+ {yyerror ("Missing identifier"); RECOVER;}
+| modifiers type error
+ {
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
+ yyerror ("Missing identifier"); RECOVER;
+ }
+;
+
+throws:
+| THROWS_TK class_type_list
+| THROWS_TK error
+ {yyerror ("Missing class type term"); RECOVER;}
+;
+
+class_type_list:
+ class_type
+| class_type_list C_TK class_type
+| class_type_list C_TK error
+ {yyerror ("Missing class type term"); RECOVER;}
+;
+
+method_body:
+ block
+| block SC_TK
+| SC_TK
+ { $$ = NULL_TREE; } /* Probably not the right thing to do. */
+;
+
+/* 19.8.4 Productions from 8.5: Static Initializers */
+static_initializer:
+ static block
+ {
+ RULE ("STATIC_INITIALIZER");
+ }
+| static block SC_TK /* Shouldn't be here. FIXME */
+ {
+ RULE ("STATIC_INITIALIZER");
+ }
+;
+
+static: /* Test lval.sub_token here */
+ MODIFIER_TK
+ {
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
+ }
+;
+
+/* 19.8.5 Productions from 8.6: Constructor Declarations */
+/* NOTE FOR FURTHER WORK ON CONSTRUCTORS:
+ - If a forbidded modifier is found, the the error is either the use of
+ a forbidded modifier for a constructor OR bogus attempt to declare a
+ method without having specified the return type. FIXME */
+constructor_declaration:
+ constructor_declarator throws constructor_body
+ {
+ RULE ("CONSTRUCTOR_DECLARATION");
+ }
+| modifiers constructor_declarator throws constructor_body
+ {
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
+ RULE ("CONSTRUCTOR_DECLARATION (modifier)");
+ }
+/* extra SC_TK, FIXME */
+| constructor_declarator throws constructor_body SC_TK
+ {
+ RULE ("CONSTRUCTOR_DECLARATION");
+ }
+/* extra SC_TK, FIXME */
+| modifiers constructor_declarator throws constructor_body SC_TK
+ {
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
+ RULE ("CONSTRUCTOR_DECLARATION (modifier)");
+ }
+/* I'm not happy with the SC_TK addition. It isn't in the grammer and should
+ probably be matched by and empty statement. But it doesn't work. FIXME */
+;
+
+constructor_declarator:
+ simple_name OP_TK CP_TK
+| simple_name OP_TK formal_parameter_list CP_TK
+;
+
+constructor_body:
+ OCB_TK CCB_TK
+| OCB_TK explicit_constructor_invocation CCB_TK
+| OCB_TK block_statements CCB_TK
+| OCB_TK explicit_constructor_invocation block_statements CCB_TK
+;
+
+/* Error recovery for that rule moved down expression_statement: rule. */
+explicit_constructor_invocation:
+ this_or_super OP_TK CP_TK SC_TK
+| this_or_super OP_TK argument_list CP_TK SC_TK
+ /* Added, JDK1.1 inner classes. Modified because the rule
+ 'primary' couldn't work. */
+| name DOT_TK SUPER_TK OP_TK argument_list CP_TK SC_TK
+| name DOT_TK SUPER_TK OP_TK CP_TK SC_TK
+ {RULE ("explicit_constructor_invocation (X.super)");}
+;
+
+this_or_super: /* Added, simplifies error diagnostics */
+ THIS_TK
+ {
+ tree wfl = build_wfl_node (this_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = $1.location;
+ $$ = wfl;
+ }
+| SUPER_TK
+ {
+ tree wfl = build_wfl_node (super_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = $1.location;
+ $$ = wfl;
+ }
+;
+
+/* 19.9 Productions from 9: Interfaces */
+/* 19.9.1 Productions from 9.1: Interfaces Declarations */
+interface_declaration:
+ INTERFACE_TK identifier
+ { create_interface (0, $2, NULL_TREE); }
+ interface_body
+ {
+ $$ = $4;
+ }
+| modifiers INTERFACE_TK identifier
+ { create_interface ($1, $3, NULL_TREE); }
+ interface_body
+ {
+ $$ = $5;
+ }
+| INTERFACE_TK identifier extends_interfaces
+ { create_interface (0, $2, $3); }
+ interface_body
+ {
+ $$ = $5;
+ }
+| modifiers INTERFACE_TK identifier extends_interfaces
+ { create_interface ($1, $3, $4); }
+ interface_body
+ {
+ $$ = $6;
+ }
+| INTERFACE_TK identifier error
+ {yyerror ("(here)'{' expected"); RECOVER;}
+| modifiers INTERFACE_TK identifier error
+ {yyerror ("(there)'{' expected"); RECOVER;}
+;
+
+extends_interfaces:
+ EXTENDS_TK interface_type
+ {
+ ctxp->interface_number = 1;
+ $$ = build_tree_list ($2, NULL_TREE);
+ }
+| extends_interfaces C_TK interface_type
+ {
+ ctxp->interface_number++;
+ $$ = chainon ($1, build_tree_list ($3, NULL_TREE));
+ }
+| EXTENDS_TK error
+ {yyerror ("Invalid interface type"); RECOVER;}
+| extends_interfaces C_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+interface_body:
+ OCB_TK CCB_TK
+ { $$ = NULL_TREE; }
+| OCB_TK interface_member_declarations CCB_TK
+ { $$ = NULL_TREE; }
+;
+
+interface_member_declarations:
+ interface_member_declaration
+| interface_member_declarations interface_member_declaration
+;
+
+interface_member_declaration:
+ constant_declaration
+| abstract_method_declaration
+| class_declaration /* Added, JDK1.1 inner classes */
+| interface_declaration /* Added, JDK1.1 inner classes */
+;
+
+constant_declaration:
+ field_declaration
+;
+
+abstract_method_declaration:
+ method_header SC_TK
+ {
+ check_abstract_method_header ($1);
+ current_function_decl = NULL_TREE; /* FIXME ? */
+ }
+| method_header error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+/* 19.10 Productions from 10: Arrays */
+array_initializer:
+ OCB_TK CCB_TK
+ {
+ RULE ("ARRAY_INITIALIZER (empty)");
+ }
+| OCB_TK variable_initializers CCB_TK
+ {
+ RULE ("ARRAY_INITIALIZER (variable)");
+ }
+| OCB_TK C_TK CCB_TK
+ {
+ RULE ("ARRAY_INITIALIZER (,)");
+ }
+| OCB_TK variable_initializers C_TK CCB_TK
+ {
+ RULE ("ARRAY_INITIALIZER (variable, ,)");
+ }
+;
+
+variable_initializers:
+ variable_initializer
+| variable_initializers C_TK variable_initializer
+| variable_initializers C_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+/* 19.11 Production from 14: Blocks and Statements */
+block:
+ OCB_TK CCB_TK
+ { $$ = size_zero_node; }
+| OCB_TK
+ { enter_block (); }
+ block_statements
+ CCB_TK
+ {
+ maybe_absorb_scoping_blocks ();
+ $$ = exit_block ();
+ }
+;
+
+block_statements:
+ block_statement
+| block_statements block_statement
+;
+
+block_statement:
+ local_variable_declaration_statement
+| statement
+ { $$ = java_method_add_stmt (current_function_decl, $1); }
+| class_declaration /* Added, JDK1.1 inner classes */
+;
+
+local_variable_declaration_statement:
+ local_variable_declaration SC_TK /* Can't catch missing ';' here */
+;
+
+local_variable_declaration:
+ type variable_declarators
+ { declare_local_variables (0, $1, $2); }
+| modifiers type variable_declarators /* Added, JDK1.1 final locals */
+ { declare_local_variables ($1, $2, $3); }
+;
+
+statement:
+ statement_without_trailing_substatement
+| labeled_statement
+ { RULE ("STATEMENT (labeled)"); }
+| if_then_statement
+ { RULE ("STATEMENT (if-then)"); }
+| if_then_else_statement
+ { RULE ("STATEMENT (if-then-else)"); }
+| while_statement
+ { RULE ("STATEMENT (while)"); }
+| for_statement
+ {
+ /* If the for loop is unlabeled, we must return the
+ block it was defined it. It our last chance to
+ get a hold on it. */
+ if (!LOOP_HAS_LABEL_P ($$))
+ $$ = exit_block ();
+ }
+;
+
+statement_nsi:
+ statement_without_trailing_substatement
+| labeled_statement_nsi
+ { RULE ("NSI STATEMENT (labeled)"); }
+| if_then_else_statement_nsi
+ { RULE ("NSI STATEMENT (if-then-else)"); }
+| while_statement_nsi
+ { RULE ("NSI STATEMENT (while)"); }
+| for_statement_nsi
+ { RULE ("NSI STATEMENT (for)"); }
+;
+
+statement_without_trailing_substatement:
+ block
+ { RULE ("STATEMENT (block)"); }
+| empty_statement
+ { RULE ("STATEMENT (empty)"); }
+| expression_statement
+ { RULE ("STATEMENT (expression)"); }
+| switch_statement
+ { RULE ("STATEMENT (switch)"); }
+| do_statement
+ { RULE ("STATEMENT (do)"); }
+| break_statement
+ { RULE ("STATEMENT (break)"); }
+| continue_statement
+ { RULE ("STATEMENT (continue)"); }
+| return_statement
+| synchronized_statement
+ { RULE ("STATEMENT (synchronized)"); }
+| throw_statement
+ { RULE ("STATEMENT (throw)"); }
+| try_statement
+ { RULE ("STATEMENT (try)"); }
+;
+
+empty_statement:
+ SC_TK
+ { $$ = size_zero_node; }
+;
+
+label_decl:
+ identifier REL_CL_TK
+ {
+ $$ = build_labeled_block (EXPR_WFL_LINECOL ($1),
+ EXPR_WFL_NODE ($1), $1);
+ pushlevel (2);
+ push_labeled_block ($$);
+ PUSH_LABELED_BLOCK ($$);
+ }
+;
+
+labeled_statement:
+ label_decl statement
+ {
+ $$ = complete_labeled_statement ($1, $2);
+ pop_labeled_block ();
+ POP_LABELED_BLOCK ();
+ }
+| identifier error
+ {yyerror ("':' expected"); RECOVER;}
+;
+
+labeled_statement_nsi:
+ label_decl statement_nsi
+ {
+ $$ = complete_labeled_statement ($1, $2);
+ pop_labeled_block ();
+ POP_LABELED_BLOCK ();
+ }
+;
+
+/* We concentrate here a bunch of error handling rules that we couldn't write
+ earlier, because expression_statement catches a missing ';'. */
+expression_statement:
+ statement_expression SC_TK
+ {
+ /* We have a statement. Generate a WFL around it so
+ we can debug it */
+ $$ = build_expr_wfl ($1, input_filename, lineno, 0);
+ /* We know we have a statement, so set the debug
+ info to be eventually generate here. */
+ $$ = JAVA_MAYBE_GENERATE_DEBUG_INFO ($$);
+ }
+| error SC_TK
+ {
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid expression statement");
+ DRECOVER (expr_stmt);
+ }
+| error OCB_TK
+ {
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid expression statement");
+ DRECOVER (expr_stmt);
+ }
+| error CCB_TK
+ {
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid expression statement");
+ DRECOVER (expr_stmt);
+ }
+| this_or_super OP_TK error
+ {yyerror ("')' expected"); RECOVER;}
+| this_or_super OP_TK CP_TK error
+ {yyerror ("';' expected"); RECOVER;}
+| this_or_super OP_TK argument_list error
+ {yyerror ("')' expected"); RECOVER;}
+| this_or_super OP_TK argument_list CP_TK error
+ {yyerror ("';' expected"); RECOVER;}
+| name DOT_TK SUPER_TK error
+ {yyerror ("'(' expected"); RECOVER;}
+| name DOT_TK SUPER_TK OP_TK error
+ {yyerror ("')' expected"); RECOVER;}
+| name DOT_TK SUPER_TK OP_TK argument_list error
+ {yyerror ("')' expected"); RECOVER;}
+| name DOT_TK SUPER_TK OP_TK argument_list CP_TK error
+ {yyerror ("';' expected"); RECOVER;}
+| name DOT_TK SUPER_TK OP_TK CP_TK error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+statement_expression:
+ assignment
+| pre_increment_expression
+ {
+ RULE ("++INCREMENT");
+ }
+| pre_decrement_expression
+ {
+ RULE ("--DECREMENT");
+ }
+| post_increment_expression
+ {
+ RULE ("INCREMENT++");
+ }
+| post_decrement_expression
+ {
+ RULE ("DECREMENT--");
+ }
+| method_invocation
+| class_instance_creation_expression
+ {
+ RULE ("INSTANCE CREATION");
+ }
+;
+
+if_then_statement:
+ IF_TK OP_TK expression CP_TK statement
+ { $$ = build_if_else_statement ($2.location, $3, $5, NULL_TREE); }
+| IF_TK error
+ {yyerror ("'(' expected"); RECOVER;}
+| IF_TK OP_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| IF_TK OP_TK expression error
+ {yyerror ("')' expected"); RECOVER;}
+;
+
+if_then_else_statement:
+ IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement
+ { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
+;
+
+if_then_else_statement_nsi:
+ IF_TK OP_TK expression CP_TK statement_nsi ELSE_TK statement_nsi
+ { $$ = build_if_else_statement ($2.location, $3, $5, $7); }
+;
+
+switch_statement:
+ SWITCH_TK OP_TK expression CP_TK switch_block
+| SWITCH_TK error
+ {yyerror ("'(' expected"); RECOVER;}
+| SWITCH_TK OP_TK error
+ {yyerror ("Missing term or ')'"); DRECOVER(switch_statement);}
+| SWITCH_TK OP_TK expression CP_TK error
+ {yyerror ("'{' expected"); RECOVER;}
+;
+
+switch_block:
+ OCB_TK CCB_TK
+| OCB_TK switch_labels CCB_TK
+| OCB_TK switch_block_statement_groups CCB_TK
+| OCB_TK switch_block_statement_groups switch_labels CCB_TK
+;
+
+switch_block_statement_groups:
+ switch_block_statement_group
+| switch_block_statement_groups switch_block_statement_group
+;
+
+switch_block_statement_group:
+ switch_labels block_statements
+;
+
+
+switch_labels:
+ switch_label
+| switch_labels switch_label
+;
+
+switch_label:
+ CASE_TK constant_expression REL_CL_TK
+| DEFAULT_TK REL_CL_TK
+| CASE_TK error
+ {yyerror ("Missing or invalid constant expression"); RECOVER;}
+| CASE_TK constant_expression error
+ {yyerror ("':' expected"); RECOVER;}
+| DEFAULT_TK error
+ {yyerror ("':' expected"); RECOVER;}
+;
+
+while_expression:
+ WHILE_TK OP_TK expression CP_TK
+ {
+ tree body = build_loop_body ($2.location, $3, 0);
+ $$ = build_new_loop (body);
+ }
+;
+
+while_statement:
+ while_expression statement
+ { $$ = complete_loop_body (0, NULL_TREE, $2, 0); }
+| WHILE_TK error
+ {YYERROR_NOW; yyerror ("'(' expected"); RECOVER;}
+| WHILE_TK OP_TK error
+ {yyerror ("Missing term and ')' expected"); RECOVER;}
+| WHILE_TK OP_TK expression error
+ {yyerror ("')' expected"); RECOVER;}
+;
+
+while_statement_nsi:
+ while_expression statement_nsi
+ { $$ = complete_loop_body (0, NULL_TREE, $2, 0); }
+;
+
+do_statement_begin:
+ DO_TK
+ {
+ tree body = build_loop_body (0, NULL_TREE, 1);
+ $$ = build_new_loop (body);
+ }
+ /* Need error handing here. FIXME */
+;
+
+do_statement:
+ do_statement_begin statement WHILE_TK OP_TK expression CP_TK SC_TK
+ { $$ = complete_loop_body ($4.location, $5, $2, 1); }
+;
+
+for_statement:
+ for_begin SC_TK expression SC_TK for_update CP_TK statement
+ { $$ = complete_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
+| for_begin SC_TK SC_TK for_update CP_TK statement
+ {
+ $$ = complete_for_loop (0, NULL_TREE, $4, $6);
+ /* We have not condition, so we get rid of the EXIT_EXPR */
+ LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
+ size_zero_node;
+ }
+| for_begin SC_TK error
+ {yyerror ("Invalid control expression"); RECOVER;}
+| for_begin SC_TK expression SC_TK error
+ {yyerror ("Invalid update expression"); RECOVER;}
+| for_begin SC_TK SC_TK error
+ {yyerror ("Invalid update expression"); RECOVER;}
+;
+
+for_statement_nsi:
+ for_begin SC_TK expression SC_TK for_update CP_TK statement_nsi
+ { $$ = complete_for_loop (EXPR_WFL_LINECOL ($3), $3, $5, $7);}
+| for_begin SC_TK SC_TK for_update CP_TK statement_nsi
+ {
+ $$ = complete_for_loop (0, NULL_TREE, $4, $6);
+ /* We have not condition, so we get rid of the EXIT_EXPR */
+ LOOP_EXPR_BODY_CONDITION_EXPR (LOOP_EXPR_BODY ($$), 0) =
+ size_zero_node;
+ }
+;
+
+for_header:
+ FOR_TK OP_TK
+ {
+ /* This scope defined for local variable that may be
+ defined within the scope of the for loop */
+ enter_block ();
+ }
+| FOR_TK error
+ {yyerror ("'(' expected"); DRECOVER(for_1);}
+| FOR_TK OP_TK error
+ {yyerror ("Invalid init statement"); RECOVER;}
+;
+
+for_begin:
+ for_header for_init
+ {
+ /* We now declare the loop body. The loop is
+ declared as a for loop. */
+ tree body = build_loop_body (0, NULL_TREE, 0);
+ $$ = build_new_loop (body);
+ IS_FOR_LOOP_P ($$) = 1;
+ /* The loop is added to the current block the for
+ statement is defined within */
+ java_method_add_stmt (current_function_decl, $$);
+ }
+;
+for_init: /* Can be empty */
+ { $$ = size_zero_node; }
+| statement_expression_list
+ {
+ /* Init statement recorded within the previously
+ defined block scope */
+ $$ = java_method_add_stmt (current_function_decl, $1);
+ }
+| local_variable_declaration
+ {
+ /* Local variable are recorded within the previously
+ defined block scope */
+ $$ = NULL_TREE;
+ }
+| statement_expression_list error
+ {yyerror ("';' expected"); DRECOVER(for_init_1);}
+;
+
+for_update: /* Can be empty */
+ {$$ = size_zero_node;}
+| statement_expression_list
+ { $$ = build_debugable_stmt (BUILD_LOCATION (), $1); }
+;
+
+statement_expression_list:
+ statement_expression
+ { $$ = add_stmt_to_compound (NULL_TREE, NULL_TREE, $1); }
+| statement_expression_list C_TK statement_expression
+ { $$ = add_stmt_to_compound ($1, NULL_TREE, $3); }
+| statement_expression_list C_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+break_statement:
+ BREAK_TK SC_TK
+ { $$ = build_bc_statement ($1.location, 1, NULL_TREE); }
+| BREAK_TK identifier SC_TK
+ { $$ = build_bc_statement ($1.location, 1, $2); }
+| BREAK_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| BREAK_TK identifier error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+continue_statement:
+ CONTINUE_TK SC_TK
+ { $$ = build_bc_statement ($1.location, 0, NULL_TREE); }
+| CONTINUE_TK identifier SC_TK
+ { $$ = build_bc_statement ($1.location, 0, $2); }
+| CONTINUE_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| CONTINUE_TK identifier error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+return_statement:
+ RETURN_TK SC_TK
+ { $$ = build_return ($1.location, NULL_TREE); }
+| RETURN_TK expression SC_TK
+ { $$ = build_return ($1.location, $2); }
+| RETURN_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| RETURN_TK expression error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+throw_statement:
+ THROW_TK expression SC_TK
+| THROW_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| THROW_TK expression error
+ {yyerror ("';' expected"); RECOVER;}
+;
+
+synchronized_statement:
+ synchronized OP_TK expression CP_TK block
+| synchronized OP_TK expression CP_TK error
+ {yyerror ("'{' expected"); RECOVER;}
+| synchronized error
+ {yyerror ("'(' expected"); RECOVER;}
+| synchronized OP_TK error CP_TK
+ {yyerror ("Missing term"); RECOVER;}
+| synchronized OP_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+synchronized: /* Test lval.sub_token here */
+ MODIFIER_TK
+ {
+ SOURCE_FRONTEND_DEBUG (("Modifiers: %d", $1));
+ }
+;
+
+try_statement:
+ TRY_TK block catches
+| TRY_TK block finally
+| TRY_TK block catches finally
+| TRY_TK error
+ {yyerror ("'{' expected"); DRECOVER (try_statement);}
+;
+
+catches:
+ catch_clause
+| catches catch_clause
+;
+
+catch_clause:
+ CATCH_TK OP_TK formal_parameter CP_TK block
+| CATCH_TK error
+ {yyerror ("'(' expected"); RECOVER;}
+| CATCH_TK OP_TK error CP_TK /* That's for () */
+ {yyerror ("Missing term"); DRECOVER (1);}
+| CATCH_TK OP_TK error
+ {yyerror ("Missing term"); DRECOVER (2);}
+;
+
+finally:
+ FINALLY_TK block
+| FINALLY_TK error
+ {yyerror ("'{' expected"); RECOVER; }
+;
+
+/* 19.12 Production from 15: Expressions */
+primary:
+ primary_no_new_array
+| array_creation_expression
+;
+
+primary_no_new_array:
+ literal
+| THIS_TK
+ { $$ = build_this ($1.location); }
+| OP_TK expression CP_TK
+ {$$ = $2;}
+| class_instance_creation_expression
+| field_access
+| method_invocation
+| array_access
+ /* type DOT_TK CLASS_TK doens't work. So we split the rule
+ 'type' into its components. Missing is something for array,
+ which will complete the reference_type part. FIXME */
+| name DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
+| primitive_type DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
+| VOID_TK DOT_TK CLASS_TK /* Added, JDK1.1 class literals */
+ /* Added, JDK1.1 inner classes. Documentation is wrong
+ refering to a 'ClassName' (class_name) rule that doesn't
+ exist. Used name instead. */
+| name DOT_TK THIS_TK
+| OP_TK expression error
+ {yyerror ("')' expected"); RECOVER;}
+| name DOT_TK error
+ {yyerror ("'class' or 'this' expected" ); RECOVER;}
+| primitive_type DOT_TK error
+ {yyerror ("'class' expected" ); RECOVER;}
+| VOID_TK DOT_TK error
+ {yyerror ("'class' expected" ); RECOVER;}
+;
+
+class_instance_creation_expression:
+ NEW_TK class_type OP_TK argument_list CP_TK
+ {
+ $$ = build_method_invocation ($2, $4);
+ TREE_SET_CODE ($$, JAVA_NEW_CLASS_EXPR);
+ }
+| NEW_TK class_type OP_TK CP_TK
+ {
+ $$ = build_method_invocation ($2, NULL_TREE);
+ TREE_SET_CODE ($$, JAVA_NEW_CLASS_EXPR);
+ }
+ /* Added, JDK1.1 inner classes but modified to use
+ 'class_type' instead of 'TypeName' (type_name) mentionned
+ in the documentation but doesn't exist. */
+| NEW_TK class_type OP_TK argument_list CP_TK class_body
+{$$ = $2;}
+| NEW_TK class_type OP_TK CP_TK class_body
+{$$ = $2;}
+ /* Added, JDK1.1 inner classes, modified to use name or
+ primary instead of primary solely which couldn't work in
+ all situations. */
+| something_dot_new identifier OP_TK CP_TK
+| something_dot_new identifier OP_TK CP_TK class_body
+| something_dot_new identifier OP_TK argument_list CP_TK
+| something_dot_new identifier OP_TK argument_list CP_TK class_body
+| NEW_TK error SC_TK
+ {yyerror ("'(' expected"); DRECOVER(new_1);}
+| NEW_TK class_type error
+ {yyerror ("'(' expected"); RECOVER;}
+| NEW_TK class_type OP_TK error
+ {yyerror ("')' or term expected"); RECOVER;}
+| NEW_TK class_type OP_TK argument_list error
+ {yyerror ("')' expected"); RECOVER;}
+| something_dot_new error
+ {YYERROR_NOW; yyerror ("Identifier expected"); RECOVER;}
+| something_dot_new identifier error
+ {yyerror ("'(' expected"); RECOVER;}
+;
+
+something_dot_new: /* Added, not part of the specs. */
+ name DOT_TK NEW_TK
+| primary DOT_TK NEW_TK
+;
+
+argument_list:
+ expression
+ {
+ $$ = tree_cons (NULL_TREE, $1, NULL_TREE);
+ ctxp->formal_parameter_number = 1;
+ }
+| argument_list C_TK expression
+ {
+ ctxp->formal_parameter_number += 1;
+ $$ = tree_cons (NULL_TREE, $3, $1);
+ }
+| argument_list C_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+array_creation_expression:
+ NEW_TK primitive_type dim_exprs
+ { $$ = build_newarray_node ($2, $3, 0); }
+| NEW_TK class_or_interface_type dim_exprs
+ { $$ = build_newarray_node ($2, $3, 0); }
+| NEW_TK primitive_type dim_exprs dims
+ { $$ = build_newarray_node ($2, $3, ctxp->osb_number); }
+| NEW_TK class_or_interface_type dim_exprs dims
+ { $$ = build_newarray_node ($2, $3, ctxp->osb_number); }
+ /* Added, JDK1.1 anonymous array. Initial documentation rule
+ modified */
+| NEW_TK class_or_interface_type dims array_initializer
+{$$ = $2;}
+| NEW_TK primitive_type dims array_initializer
+{$$ = $2;}
+| NEW_TK error CSB_TK
+ {yyerror ("'[' expected"); DRECOVER ("]");}
+| NEW_TK error OSB_TK
+ {yyerror ("']' expected"); RECOVER;}
+;
+
+dim_exprs:
+ dim_expr
+ { $$ = build_tree_list (NULL_TREE, $1); }
+| dim_exprs dim_expr
+ { $$ = tree_cons (NULL_TREE, $2, $$); }
+;
+
+dim_expr:
+ OSB_TK expression CSB_TK
+ {
+ EXPR_WFL_LINECOL ($2) = $1.location;
+ $$ = $2;
+ }
+| OSB_TK expression error
+ {yyerror ("']' expected"); RECOVER;}
+| OSB_TK error
+ {
+ yyerror ("Missing term");
+ yyerror ("']' expected");
+ RECOVER;
+ }
+;
+
+dims:
+ OSB_TK CSB_TK
+ { ctxp->osb_number = 1; }
+| dims OSB_TK CSB_TK
+ { ctxp->osb_number++; }
+| dims OSB_TK error
+ { yyerror ("']' expected"); RECOVER;}
+;
+
+field_access:
+ primary DOT_TK identifier
+ { $$ = make_qualified_primary ($1, $3, $2.location); }
+| SUPER_TK DOT_TK identifier
+ {
+ tree super_wfl =
+ build_wfl_node (super_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (super_wfl) = $1.location;
+ $$ = make_qualified_name (super_wfl, $3, $2.location);
+ }
+| SUPER_TK error
+ {yyerror ("Field expected"); DRECOVER (super_field_acces);}
+;
+
+method_invocation:
+ name OP_TK CP_TK
+ { $$ = build_method_invocation ($1, NULL_TREE); }
+| name OP_TK argument_list CP_TK
+ { $$ = build_method_invocation ($1, $3); }
+| primary DOT_TK identifier OP_TK CP_TK
+ {
+ tree invok = build_method_invocation ($3, NULL_TREE);
+ $$ = make_qualified_primary ($1, invok, $2.location);
+ }
+| primary DOT_TK identifier OP_TK argument_list CP_TK
+ {
+ tree invok = build_method_invocation ($3, $5);
+ $$ = make_qualified_primary ($1, invok, $2.location);
+ }
+| SUPER_TK DOT_TK identifier OP_TK CP_TK
+ {
+ tree invok;
+ tree wfl = build_wfl_node (super_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = $1.location;
+ invok = build_method_invocation ($3, NULL_TREE);
+ $$ = make_qualified_primary (wfl, invok, $2.location);
+ }
+| SUPER_TK DOT_TK identifier OP_TK argument_list CP_TK
+ {
+ tree invok;
+ tree wfl = build_wfl_node (super_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = $1.location;
+ invok = build_method_invocation ($3, $5);
+ $$ = make_qualified_primary (wfl, invok, $2.location);
+ }
+ /* Screws up thing. I let it here until I'm convinced it can
+ be removed. FIXME
+| primary DOT_TK error
+ {yyerror ("'(' expected"); DRECOVER(bad);} */
+| SUPER_TK DOT_TK error CP_TK
+ { yyerror ("'(' expected"); DRECOVER (method_invocation); }
+| SUPER_TK DOT_TK error DOT_TK
+ { yyerror ("'(' expected"); DRECOVER (method_invocation); }
+;
+
+array_access:
+ name OSB_TK expression CSB_TK
+ { $$ = build_array_ref ($2.location, $1, $3); }
+| primary_no_new_array OSB_TK expression CSB_TK
+ { $$ = build_array_ref ($2.location, $1, $3); }
+| name OSB_TK error
+ {
+ yyerror ("Missing term and ']' expected");
+ DRECOVER(array_access);
+ }
+| name OSB_TK expression error
+ {
+ yyerror ("']' expected");
+ DRECOVER(array_access);
+ }
+| primary_no_new_array OSB_TK error
+ {
+ yyerror ("Missing term and ']' expected");
+ DRECOVER(array_access);
+ }
+| primary_no_new_array OSB_TK expression error
+ {
+ yyerror ("']' expected");
+ DRECOVER(array_access);
+ }
+;
+
+postfix_expression:
+ primary
+| name
+| post_increment_expression
+| post_decrement_expression
+;
+
+post_increment_expression:
+ postfix_expression INCR_TK
+ { $$ = build_incdec ($2.token, $2.location, $1, 1); }
+;
+
+post_decrement_expression:
+ postfix_expression DECR_TK
+ { $$ = build_incdec ($2.token, $2.location, $1, 1); }
+;
+
+unary_expression:
+ pre_increment_expression
+| pre_decrement_expression
+| PLUS_TK unary_expression
+ {$$ = build_unaryop ($1.token, $1.location, $2); }
+| MINUS_TK unary_expression
+ {$$ = build_unaryop ($1.token, $1.location, $2); }
+| unary_expression_not_plus_minus
+| PLUS_TK error
+ {yyerror ("Missing term"); RECOVER}
+| MINUS_TK error
+ {yyerror ("Missing term"); RECOVER}
+;
+
+pre_increment_expression:
+ INCR_TK unary_expression
+ {$$ = build_incdec ($1.token, $1.location, $2, 0); }
+| INCR_TK error
+ {yyerror ("Missing term"); RECOVER}
+;
+
+pre_decrement_expression:
+ DECR_TK unary_expression
+ {$$ = build_incdec ($1.token, $1.location, $2, 0); }
+| DECR_TK error
+ {yyerror ("Missing term"); RECOVER}
+;
+
+unary_expression_not_plus_minus:
+ postfix_expression
+| NOT_TK unary_expression
+ {$$ = build_unaryop ($1.token, $1.location, $2); }
+| NEG_TK unary_expression
+ {$$ = build_unaryop ($1.token, $1.location, $2); }
+| cast_expression
+| NOT_TK error
+ {yyerror ("Missing term"); RECOVER}
+| NEG_TK error
+ {yyerror ("Missing term"); RECOVER}
+;
+
+cast_expression: /* Error handling here is potentially weak */
+ OP_TK primitive_type dims CP_TK unary_expression
+ {
+ tree type = $2;
+ while (ctxp->osb_number--)
+ type = build_java_array_type (type, -1);
+ $$ = build_cast ($1.location, type, $5);
+ }
+| OP_TK primitive_type CP_TK unary_expression
+ { $$ = build_cast ($1.location, $2, $4); }
+| OP_TK expression CP_TK unary_expression_not_plus_minus
+ { $$ = build_cast ($1.location, $2, $4); }
+| OP_TK name dims CP_TK unary_expression_not_plus_minus
+ {
+ char *ptr;
+ while (ctxp->osb_number--)
+ obstack_1grow (&temporary_obstack, '[');
+ obstack_grow0 (&temporary_obstack,
+ IDENTIFIER_POINTER (EXPR_WFL_NODE ($2)),
+ IDENTIFIER_LENGTH (EXPR_WFL_NODE ($2)));
+ ptr = obstack_finish (&temporary_obstack);
+ EXPR_WFL_NODE ($2) = get_identifier (ptr);
+ $$ = build_cast ($1.location, $2, $5);
+ }
+| OP_TK primitive_type OSB_TK error
+ {yyerror ("']' expected, invalid type expression");}
+| OP_TK error
+ {
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Invalid type expression"); RECOVER;
+ RECOVER;
+ }
+| OP_TK primitive_type dims CP_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| OP_TK primitive_type CP_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| OP_TK name dims CP_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+multiplicative_expression:
+ unary_expression
+| multiplicative_expression MULT_TK unary_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token),
+ $2.location, $1, $3);
+ }
+| multiplicative_expression DIV_TK unary_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| multiplicative_expression REM_TK unary_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| multiplicative_expression MULT_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| multiplicative_expression DIV_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| multiplicative_expression REM_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+additive_expression:
+ multiplicative_expression
+| additive_expression PLUS_TK multiplicative_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| additive_expression MINUS_TK multiplicative_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| additive_expression PLUS_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| additive_expression MINUS_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+shift_expression:
+ additive_expression
+| shift_expression LS_TK additive_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| shift_expression SRS_TK additive_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| shift_expression ZRS_TK additive_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| shift_expression LS_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| shift_expression SRS_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| shift_expression ZRS_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+relational_expression:
+ shift_expression
+| relational_expression LT_TK shift_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| relational_expression GT_TK shift_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| relational_expression LTE_TK shift_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| relational_expression GTE_TK shift_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| relational_expression INSTANCEOF_TK reference_type
+| relational_expression LT_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| relational_expression GT_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| relational_expression LTE_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| relational_expression GTE_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| relational_expression INSTANCEOF_TK error
+ {yyerror ("Invalid reference type"); RECOVER;}
+;
+
+equality_expression:
+ relational_expression
+| equality_expression EQ_TK relational_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| equality_expression NEQ_TK relational_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| equality_expression EQ_TK error
+ {yyerror ("Missing term"); RECOVER;}
+| equality_expression NEQ_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+and_expression:
+ equality_expression
+| and_expression AND_TK equality_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| and_expression AND_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+exclusive_or_expression:
+ and_expression
+| exclusive_or_expression XOR_TK and_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| exclusive_or_expression XOR_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+inclusive_or_expression:
+ exclusive_or_expression
+| inclusive_or_expression OR_TK exclusive_or_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| inclusive_or_expression OR_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+conditional_and_expression:
+ inclusive_or_expression
+| conditional_and_expression BOOL_AND_TK inclusive_or_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| conditional_and_expression BOOL_AND_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+conditional_or_expression:
+ conditional_and_expression
+| conditional_or_expression BOOL_OR_TK conditional_and_expression
+ {
+ $$ = build_binop (BINOP_LOOKUP ($2.token), $2.location,
+ $1, $3);
+ }
+| conditional_or_expression BOOL_OR_TK error
+ {yyerror ("Missing term"); RECOVER;}
+;
+
+conditional_expression: /* Error handling here is weak */
+ conditional_or_expression
+| conditional_or_expression REL_QM_TK expression REL_CL_TK conditional_expression
+| conditional_or_expression REL_QM_TK REL_CL_TK error
+ {
+ YYERROR_NOW;
+ yyerror ("Missing term");
+ DRECOVER (1);
+ }
+| conditional_or_expression REL_QM_TK error
+ {yyerror ("Missing term"); DRECOVER (2);}
+| conditional_or_expression REL_QM_TK expression REL_CL_TK error
+ {yyerror ("Missing term"); DRECOVER (3);}
+;
+
+assignment_expression:
+ conditional_expression
+| assignment
+;
+
+assignment:
+ left_hand_side assignment_operator assignment_expression
+ { $$ = build_assignment ($2.token, $2.location, $1, $3); }
+| left_hand_side assignment_operator error
+ {
+ if (ctxp->prevent_ese != lineno)
+ yyerror ("Missing term");
+ DRECOVER (assign);
+ }
+;
+
+left_hand_side:
+ name
+| field_access
+| array_access
+;
+
+assignment_operator:
+ ASSIGN_ANY_TK
+| ASSIGN_TK
+;
+
+expression:
+ assignment_expression
+;
+
+constant_expression:
+ expression
+;
+
+%%
+\f
+
+#include "lex.c"
+
+/* Flag for the error report routine to issue the error the first time
+ it's called (overriding the default behavior which is to drop the
+ first invocation and honor the second one, taking advantage of a
+ richer context. */
+static int force_error = 0;
+
+/* Create a new parser context and make it the current one. */
+
+void
+java_push_parser_context ()
+{
+ struct parser_ctxt *new =
+ (struct parser_ctxt *)malloc(sizeof (struct parser_ctxt));
+
+ bzero (new, sizeof (struct parser_ctxt));
+ new->next = ctxp;
+ ctxp = new;
+ if (ctxp->next)
+ ctxp->incomplete_class = ctxp->next->incomplete_class;
+}
+
+void
+java_parser_context_save_global ()
+{
+ ctxp->finput = finput;
+ ctxp->lineno = lineno;
+ ctxp->current_class = current_class;
+ ctxp->filename = input_filename;
+ ctxp->current_function_decl = current_function_decl;
+}
+
+void
+java_parser_context_restore_global ()
+{
+ finput = ctxp->finput;
+ lineno = ctxp->lineno;
+ current_class = ctxp->current_class;
+ input_filename = ctxp->filename;
+ current_function_decl = ctxp->current_function_decl;
+}
+
+void
+java_pop_parser_context ()
+{
+ tree current;
+ struct parser_ctxt *toFree = ctxp;
+ struct parser_ctxt *next = ctxp->next;
+
+ if (next)
+ {
+ next->incomplete_class = ctxp->incomplete_class;
+ lineno = ctxp->lineno;
+ finput = ctxp->finput;
+ current_class = ctxp->current_class;
+ }
+
+ /* Set the single import class file flag to 0 for the current list
+ of imported things */
+ for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
+ IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 0;
+
+ /* And restore those of the previous context */
+ if (ctxp = next)
+ for (current = ctxp->import_list; current; current = TREE_CHAIN (current))
+ IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (TREE_PURPOSE (current)) = 1;
+
+ free (toFree);
+}
+
+static int do_warning = 0;
+
+void
+yyerror (msg)
+ char *msg;
+{
+ static java_lc elc;
+ static int prev_lineno;
+ static char *prev_msg;
+
+ int i, save_lineno;
+ char *remainder, *code_from_source;
+ extern struct obstack temporary_obstack;
+
+ if (!force_error && prev_lineno == lineno)
+ return;
+
+ /* Save current error location but report latter, when the context is
+ richer. */
+ if (ctxp->java_error_flag == 0)
+ {
+ ctxp->java_error_flag = 1;
+ elc = ctxp->elc;
+ /* Do something to use the previous line if we're reaching the
+ end of the file... */
+#ifdef VERBOSE_SKELETON
+ printf ("* Error detected (%s)\n", (msg ? msg : "(null)"));
+#endif
+ return;
+ }
+
+ /* Ignore duplicate message on the same line. BTW, this is dubious. FIXME */
+ if (!force_error && msg == prev_msg && prev_lineno == elc.line)
+ return;
+
+ ctxp->java_error_flag = 0;
+ if (do_warning)
+ java_warning_count++;
+ else
+ java_error_count++;
+
+ if (elc.col == 0 && msg[1] == ';')
+ {
+ elc.col = ctxp->p_line->char_col-1;
+ elc.line = ctxp->p_line->lineno;
+ }
+
+ save_lineno = lineno;
+ prev_lineno = lineno = elc.line;
+ prev_msg = msg;
+
+ code_from_source = java_get_line_col (ctxp->filename, elc.line, elc.col);
+ obstack_grow0 (&temporary_obstack,
+ code_from_source, strlen (code_from_source));
+ remainder = obstack_finish (&temporary_obstack);
+ if (do_warning)
+ warning ("%s.\n%s", msg, remainder);
+ else
+ error ("%s.\n%s", msg, remainder);
+
+ /* This allow us to cheaply avoid an extra 'Invalid expression
+ statement' error report when errors have been already reported on
+ the same line. This occurs when we report an error but don't have
+ a synchronization point other than ';', which
+ expression_statement is the only one to take care of. */
+ ctxp->prevent_ese = lineno = save_lineno;
+}
+
+static void
+parse_error (msg)
+ char *msg;
+{
+ java_error (NULL);
+ java_error (msg);
+}
+
+/* Issue an error message at a current source line CL */
+
+static void
+parse_error_context VPROTO ((tree cl, char *msg, ...))
+{
+#ifndef __STDC__
+ tree cl;
+ char *msg;
+#endif
+ char buffer [4096];
+ va_list ap;
+
+ VA_START (ap, msg);
+#ifndef __STDC__
+ cl = va_arg (ap, tree);
+ msg = va_arg (ap, char *);
+#endif
+ vsprintf (buffer, msg, ap);
+
+ force_error = 1;
+ ctxp->elc.line = EXPR_WFL_LINENO (cl);
+ ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 : EXPR_WFL_COLNO (cl));
+
+ parse_error (buffer);
+ force_error = 0;
+}
+
+/* Issue a warning at a current source line CL */
+
+static void
+parse_warning_context VPROTO ((tree cl, char *msg, ...))
+{
+#ifndef __STDC__
+ tree cl;
+ char *msg;
+#endif
+ char buffer [4096];
+ va_list ap;
+
+ VA_START (ap, msg);
+#ifndef __STDC__
+ cl = va_arg (ap, tree);
+ msg = va_arg (ap, char *);
+#endif
+ vsprintf (buffer, msg, ap);
+
+ force_error = do_warning = 1;
+ ctxp->elc.line = EXPR_WFL_LINENO (cl);
+ ctxp->elc.col = (EXPR_WFL_COLNO (cl) == 0xfff ? -1 : EXPR_WFL_COLNO (cl));
+
+ parse_error (buffer);
+ do_warning = force_error = 0;
+}
+
+void
+java_report_errors ()
+{
+ if (java_error_count)
+ fprintf (stderr, "%d error%s",
+ java_error_count, (java_error_count == 1 ? "" : "s"));
+ if (java_warning_count)
+ fprintf (stderr, "%s%d warning%s", (java_error_count ? ", " : ""),
+ java_warning_count, (java_warning_count == 1 ? "" : "s"));
+ if (java_error_count || java_warning_count)
+ putc ('\n', stderr);
+}
+
+static char *
+java_accstring_lookup (flags)
+ int flags;
+{
+ static char buffer [80];
+#define COPY_RETURN(S) {strcpy (buffer, S); return buffer;}
+
+ /* Access modifier looked-up first for easier report on forbidden
+ access. */
+ if (flags & ACC_PUBLIC) COPY_RETURN ("public");
+ if (flags & ACC_PRIVATE) COPY_RETURN ("private");
+ if (flags & ACC_PROTECTED) COPY_RETURN ("protected");
+ if (flags & ACC_STATIC) COPY_RETURN ("static");
+ if (flags & ACC_FINAL) COPY_RETURN ("final");
+ if (flags & ACC_SYNCHRONIZED) COPY_RETURN ("synchronized");
+ if (flags & ACC_VOLATILE) COPY_RETURN ("volatile");
+ if (flags & ACC_TRANSIENT) COPY_RETURN ("transient");
+ if (flags & ACC_NATIVE) COPY_RETURN ("native");
+ if (flags & ACC_INTERFACE) COPY_RETURN ("interface");
+ if (flags & ACC_ABSTRACT) COPY_RETURN ("abstract");
+
+ buffer [0] = '\0';
+ return buffer;
+#undef COPY_RETURN
+}
+
+static void
+redefinition_error (context, id, decl, cl)
+ char *context;
+ tree id, decl, cl;
+{
+ parse_error_context (cl, "%s `%s' already defined in %s:%d",
+ context, IDENTIFIER_POINTER (id),
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
+ /* Here we should point out where its redefined. It's a unicode. FIXME */
+}
+
+/* Build something that the type identifier resolver will identify as
+ being an array to an unresolved type. TYPE_WFL is a WFL on a
+ identifier. */
+
+static tree
+build_unresolved_array_type (type_or_wfl)
+ tree type_or_wfl;
+{
+ char *ptr;
+
+ /* TYPE_OR_WFL might be an array on a primitive type. In this case,
+ just create a array type */
+ if (TREE_CODE (type_or_wfl) == RECORD_TYPE)
+ {
+ tree type = build_java_array_type (type_or_wfl, -1);
+ CLASS_LOADED_P (type) = CLASS_LOADED_P (type_or_wfl);
+ return type;
+ }
+
+ obstack_1grow (&temporary_obstack, '[');
+ obstack_grow0 (&temporary_obstack,
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (type_or_wfl)),
+ IDENTIFIER_LENGTH (EXPR_WFL_NODE (type_or_wfl)));
+ ptr = obstack_finish (&temporary_obstack);
+ return build_expr_wfl (get_identifier (ptr),
+ EXPR_WFL_FILENAME (type_or_wfl),
+ EXPR_WFL_LINENO (type_or_wfl),
+ EXPR_WFL_COLNO (type_or_wfl));
+}
+
+/* Check modifiers. If one doesn't fit, retrieve it in its declaration line
+ and point it out. */
+
+static void
+check_modifiers (message, value, mask)
+ char *message;
+ int value;
+ int mask;
+{
+ /* Should point out the one that don't fit. ASCII/unicode,
+ going backward. FIXME */
+ if (value & ~mask)
+ {
+ int i, remainder = value & ~mask;
+ for (i = 0; i <= 10; i++)
+ if ((1 << i) & remainder)
+ parse_error_context (ctxp->modifier_ctx [i], message,
+ java_accstring_lookup (1 << i));
+ }
+}
+
+static void
+parser_add_interface (class_decl, interface_decl, wfl)
+ tree class_decl, interface_decl, wfl;
+{
+ if (maybe_add_interface (TREE_TYPE (class_decl), TREE_TYPE (interface_decl)))
+ parse_error_context (wfl, "Interface `%s' repeated",
+ IDENTIFIER_POINTER (DECL_NAME (interface_decl)));
+}
+
+/* Bulk of common class/interface checks. Return 1 if an error was
+ encountered. TAG is 0 for a class, 1 for an interface. */
+
+static int
+check_class_interface_creation (is_interface, flags, raw_name, qualified_name, decl, cl)
+ int is_interface, flags;
+ tree raw_name, qualified_name, decl, cl;
+{
+ tree node;
+
+ if (!quiet_flag)
+ fprintf (stderr, " %s %s", (is_interface ? "interface" : "class"),
+ IDENTIFIER_POINTER (qualified_name));
+
+ /* Scope of an interface/class type name:
+ - Can't be imported by a single type import
+ - Can't already exists in the package */
+ if (IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (raw_name)
+ && (node = find_name_in_single_imports (raw_name)))
+ {
+ parse_error_context
+ (cl, "%s name `%s' clashes with imported type `%s'",
+ (is_interface ? "Interface" : "Class"),
+ IDENTIFIER_POINTER (raw_name), IDENTIFIER_POINTER (node));
+ return 1;
+ }
+ if (decl && CLASS_COMPLETE_P (decl))
+ {
+ redefinition_error ((is_interface ? "Interface" : "Class"),
+ qualified_name, decl, cl);
+ return 1;
+ }
+
+ /* If public, file name should match class/interface name */
+ if (flags & ACC_PUBLIC)
+ {
+ char *f;
+
+ /* Contains OS dependent assumption on path separator. FIXME */
+ for (f = &input_filename [strlen (input_filename)];
+ f != input_filename && f[0] != '/'; f--);
+ if (f[0] == '/')
+ f++;
+ if (strncmp (IDENTIFIER_POINTER (raw_name),
+ f , IDENTIFIER_LENGTH (raw_name)) ||
+ f [IDENTIFIER_LENGTH (raw_name)] != '.')
+ parse_error_context (cl, "Public %s `%s' must be defined in a file "
+ "called `%s.java'",
+ (is_interface ? "interface" : "class"),
+ IDENTIFIER_POINTER (qualified_name),
+ IDENTIFIER_POINTER (raw_name));
+ }
+
+ check_modifiers ((is_interface ?
+ "Illegal modifier `%s' for interface declaration" :
+ "Illegal modifier `%s' for class declaration"), flags,
+ (is_interface ? INTERFACE_MODIFIERS : CLASS_MODIFIERS));
+ return 0;
+}
+
+/* If DECL is NULL, create and push a new DECL, record the current
+ line CL and do other maintenance things. */
+
+static tree
+maybe_create_class_interface_decl (decl, qualified_name, cl)
+ tree decl, qualified_name, cl;
+{
+ if (decl)
+ DECL_ARTIFICIAL (decl) = 1; /* FIXME */
+ else
+ decl = push_class (make_class (), qualified_name);
+
+ /* Take care of the file and line business */
+ DECL_SOURCE_FILE (decl) = EXPR_WFL_FILENAME (cl);
+ DECL_SOURCE_LINE (decl) = EXPR_WFL_LINENO (cl);
+ CLASS_FROM_SOURCE_P (TREE_TYPE (decl)) = 1;
+
+ ctxp->current_parsed_class = decl;
+
+ /* Link the declaration to the already seen ones */
+ TREE_CHAIN (decl) = ctxp->class_list;
+ ctxp->class_list = decl;
+ /* Install a new dependency list element */
+ create_jdep_list (ctxp);
+
+ SOURCE_FRONTEND_DEBUG (("Defining class/interface %s",
+ IDENTIFIER_POINTER (qualified_name)));
+ return decl;
+}
+
+static void
+add_superinterfaces (decl, interface_list)
+ tree decl, interface_list;
+{
+ tree node;
+ /* Superinterface(s): if present and defined, parser_check_super_interface ()
+ takes care of ensuring that:
+ - This is an accessible interface type,
+ - Circularity detection.
+ parser_add_interface is then called. If present but not defined,
+ the check operation is delayed until the super interface gets
+ defined. */
+ for (node = interface_list; node; node = TREE_CHAIN (node))
+ {
+ tree current = TREE_PURPOSE (node), interface_decl;
+ if ((interface_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (current))))
+ {
+ if (!parser_check_super_interface (interface_decl, decl, current))
+ parser_add_interface (decl, interface_decl, current);
+ }
+ else
+ register_incomplete_type (JDEP_INTERFACE,
+ current, decl, NULL_TREE);
+ }
+}
+
+/* Create an interface in pass1 and return its decl. Return the
+ interface's decl in pass 2. */
+
+static tree
+create_interface (flags, id, super)
+ int flags;
+ tree id, super;
+{
+ int chk;
+ tree raw_name = EXPR_WFL_NODE (id);
+ tree q_name = parser_qualified_classname (id);
+ tree decl = IDENTIFIER_CLASS_VALUE (q_name);
+
+ EXPR_WFL_NODE (id) = q_name; /* Keep source location, even if refined. */
+
+ /* Basic checks: scope, redefinition, modifiers */
+ if (check_class_interface_creation (1, flags, raw_name, q_name, decl, id))
+ return NULL_TREE;
+
+ /* Interface modifiers check
+ - public/abstract allowed (already done at that point)
+ - abstract is obsolete (comes first, it's a warning, or should be)
+ - Can't use twice the same (checked in the modifier rule) */
+ if (flags & ACC_ABSTRACT)
+ parse_warning_context
+ (MODIFIER_WFL (ABSTRACT_TK),
+ "Obsolete use of `abstract' modifier. Interface `%s' is implicitely "
+ "abstract", IDENTIFIER_POINTER (raw_name));
+ if (flags & ACC_PUBLIC && flags & ACC_ABSTRACT)
+ parse_error_context
+ (MODIFIER_WFL (ABSTRACT_TK),
+ "Can't specify both `public' and `abstract' modifiers in the "
+ "definition of interface `%s'", IDENTIFIER_POINTER (raw_name));
+
+ /* Create a new decl if DECL is NULL, otherwise fix it */
+ decl = maybe_create_class_interface_decl (decl, q_name, id);
+
+ /* Set super info and mark the class a complete */
+ set_super_info (ACC_ABSTRACT | ACC_INTERFACE | flags, TREE_TYPE (decl),
+ object_type_node, ctxp->interface_number);
+ ctxp->interface_number = 0;
+ CLASS_COMPLETE_P (decl) = 1;
+ add_superinterfaces (decl, super);
+
+ return decl;
+}
+
+/* Create an class in pass1 and return its decl. Return class
+ interface's decl in pass 2. */
+
+static tree
+create_class (flags, id, super, interfaces)
+ int flags;
+ tree id, super, interfaces;
+{
+ int chk;
+ tree raw_name = EXPR_WFL_NODE (id);
+ tree class_id, decl;
+ tree super_decl = NULL, super_decl_type;
+
+ class_id = parser_qualified_classname (id);
+ decl = IDENTIFIER_CLASS_VALUE (class_id);
+ EXPR_WFL_NODE (id) = class_id;
+
+ /* Basic check: scope, redefinition, modifiers */
+ if (check_class_interface_creation (0, flags, raw_name, class_id, decl, id))
+ return NULL_TREE;
+
+ /* Class modifier check:
+ - Allowed modifier (already done at that point)
+ - abstract AND final forbidden
+ - Public classes defined in the correct file */
+ if ((flags & ACC_ABSTRACT) && (flags & ACC_FINAL))
+ parse_error_context (id, "Class `%s' can't be declared both abstract "
+ "and final", IDENTIFIER_POINTER (raw_name));
+
+ /* Create a new decl if DECL is NULL, otherwise fix it */
+ decl = maybe_create_class_interface_decl (decl, class_id, id);
+
+ /* If SUPER exists, use it, otherwise use Object */
+ if (super)
+ {
+ /* Can't extend java.lang.Object */
+ if (TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_id)) == object_type_node)
+ {
+ parse_error_context (id, "Can't extend `java.lang.Object'");
+ return NULL_TREE;
+ }
+
+ /* The class is known and exists if there is a decl. Otherwise,
+ postpone the operation and do it later. */
+ super_decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (super));
+ if (super_decl)
+ {
+ parser_check_super (super_decl, decl, id);
+ super_decl_type = TREE_TYPE (super_decl);
+ }
+ else
+ super_decl_type =
+ register_incomplete_type (JDEP_SUPER, super, decl, NULL_TREE);
+ }
+ else if (TREE_TYPE (decl) != object_type_node)
+ super_decl_type = object_type_node;
+ /* We're defining java.lang.Object */
+ else
+ super_decl_type = NULL_TREE;
+
+ /* Set super info and mark the class a complete */
+ set_super_info (flags, TREE_TYPE (decl), super_decl_type,
+ ctxp->interface_number);
+ ctxp->interface_number = 0;
+ CLASS_COMPLETE_P (decl) = 1;
+ add_superinterfaces (decl, interfaces);
+
+ return decl;
+}
+
+/* Can't use lookup_field () since we don't want to load the class and
+ can't set the CLASS_LOADED_P flag */
+
+static tree
+find_field (class, name)
+ tree class;
+ tree name;
+{
+ tree decl;
+ for (decl = TYPE_FIELDS (class); decl; decl = TREE_CHAIN (decl))
+ {
+ if (DECL_NAME (decl) == name)
+ return decl;
+ }
+ return NULL_TREE;
+}
+
+/* Wrap around lookup_field that doesn't potentially upset the value
+ of CLASS */
+
+static tree
+lookup_field_wrapper (class, name)
+ tree class, name;
+{
+ tree type = class;
+ return lookup_field (&type, name);
+}
+
+/* Find duplicate field within the same class declarations and report
+ the error */
+
+static int
+duplicate_declaration_error (class, new_field_name, new_type, cl)
+ tree class, new_field_name, new_type, cl;
+{
+ /* This might be modified to work with method decl as well */
+ tree decl = find_field (TREE_TYPE (ctxp->current_parsed_class),
+ new_field_name);
+ if (decl)
+ {
+ char *t1 = strdup ((char *)lang_printable_name (new_type, 1));
+ char *t2 =
+ strdup ((TREE_CODE (TREE_TYPE (decl)) == TREE_LIST ?
+ IDENTIFIER_POINTER (TYPE_NAME
+ (TREE_PURPOSE (TREE_TYPE (decl)))) :
+ (char *)lang_printable_name (TREE_TYPE (decl), 1)));
+ parse_error_context
+ (cl , "Duplicate variable declaration: `%s %s' was `%s %s' (%s:%d)",
+ t1, IDENTIFIER_POINTER (new_field_name),
+ t2, IDENTIFIER_POINTER (DECL_NAME (decl)),
+ DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
+ free (t1);
+ free (t2);
+ return 0;
+ }
+ return 1;
+}
+
+/* Field registration routine. If TYPE doesn't exist, field
+ declarations are linked to the undefined TYPE dependency list, to
+ be later resolved in java_complete_class () */
+
+static void
+register_fields (flags, type, variable_list)
+ int flags;
+ tree type, variable_list;
+{
+ tree current, type_decl, returned_type;
+ tree class_type = TREE_TYPE (ctxp->current_parsed_class);
+ int saved_lineno = lineno;
+ int must_chain = 0;
+ tree wfl = NULL_TREE;
+
+ /* If we're adding fields to interfaces, those fields are public,
+ static, final */
+ if (CLASS_INTERFACE (TYPE_NAME (class_type)))
+ {
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK),
+ flags, ACC_PUBLIC,
+ "%s", "interface field(s)");
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (STATIC_TK),
+ flags, ACC_STATIC,
+ "%s", "interface field(s)");
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (FINAL_TK),
+ flags, ACC_FINAL, "%s", "interface field(s)");
+ check_modifiers ("Illegal interface member modifier `%s'", flags,
+ INTERFACE_FIELD_MODIFIERS);
+ flags |= (ACC_PUBLIC | ACC_STATIC | ACC_FINAL);
+ }
+
+ if (unresolved_type_p (type, &returned_type))
+ {
+ if (returned_type)
+ type = returned_type;
+ else
+ {
+ wfl = type;
+ type = obtain_incomplete_type (type);
+ must_chain = 1;
+ }
+ }
+
+ for (current = variable_list; current; current = TREE_CHAIN (current))
+ {
+ tree cl = TREE_PURPOSE (current);
+ tree init = TREE_VALUE (current);
+ tree current_name = EXPR_WFL_NODE (cl);
+
+ if (duplicate_declaration_error (class_type, current_name, type, cl))
+ {
+ tree field_decl;
+ lineno = EXPR_WFL_LINENO (cl);
+ field_decl = add_field (class_type, current_name, type, flags);
+
+ /* Check if we must chain. */
+ if (must_chain)
+ register_incomplete_type (JDEP_FIELD, wfl, field_decl, type);
+
+ /* Default value of a static field is 0 and it is considered
+ initialized. */
+ if (flags & ACC_STATIC)
+ INITIALIZED_P (field_decl) = 1;
+
+ /* If we have an initialization value tied to the field */
+ if (init)
+ {
+ /* The field is declared static */
+ if (flags & ACC_STATIC)
+ {
+ /* FIXME */
+ if (flags & ACC_FINAL)
+ ;
+ /* Otherwise, the field should be initialized in
+ <clinit>. This field is remembered so we can
+ generate <clinit> later. */
+ else
+ {
+ INITIALIZED_P (field_decl) = 1;
+ TREE_CHAIN (init) = ctxp->static_initialized;
+ ctxp->static_initialized = init;
+ }
+ }
+ /* A non-static field declared with an immediate
+ initialization is to be initialized in <init>, if
+ any. This field is remembered to be processed at the
+ time of the generation of <init>. */
+ else
+ {
+ TREE_CHAIN (init) = ctxp->non_static_initialized;
+ ctxp->non_static_initialized = init;
+ }
+ }
+ }
+ }
+ lineno = saved_lineno;
+}
+
+/* Check whether it is necessary to generate a <clinit> for the class
+ we just parsed. */
+
+static void
+maybe_generate_clinit ()
+{
+ int saved_lineno;
+ tree meth, mdecl, c;
+ tree cclass, class_wfl;
+
+ if (!ctxp->static_initialized || java_error_count)
+ return;
+
+ cclass = TREE_TYPE (ctxp->current_parsed_class);
+ class_wfl = build_expr_wfl (DECL_NAME (TYPE_NAME (cclass)),
+ input_filename, 0, 0);
+
+ saved_lineno = lineno;
+ lineno = 0;
+ meth = make_node (FUNCTION_TYPE);
+ TREE_TYPE (meth) = void_type_node;
+ TYPE_ARG_TYPES (meth) = NULL_TREE;
+ mdecl = add_method (cclass, ACC_STATIC, clinit_identifier_node,
+ build_java_signature (meth));
+ lineno = saved_lineno;
+
+ DECL_SOURCE_LINE (mdecl) = 1;
+ DECL_SOURCE_LINE_MERGE (mdecl, 1);
+ source_start_java_method (mdecl);
+ enter_block ();
+
+ /* Keep initialization in order to enforce 8.5 */
+ ctxp->static_initialized = nreverse (ctxp->static_initialized);
+
+ /* We process the list of assignment we produced as the result of
+ the declaration of initialized static field and add them as
+ statement to the <clinit> method. */
+ for (c = ctxp->static_initialized; c; c = TREE_CHAIN (c))
+ {
+ /* We build the assignment expression that will initialize the
+ field to its value. There are strict rules on static
+ initializers (8.5). FIXME */
+ java_method_add_stmt (mdecl, c);
+ }
+
+ BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = exit_block ();
+ exit_block ();
+ ctxp->static_initialized = NULL_TREE;
+}
+
+/* Shared accros method_declarator and method_header to remember the
+ patch stage that was reached during the declaration of the method.
+ A method DECL is built differently is there is no patch
+ (JDEP_NO_PATCH) or a patch (JDEP_METHOD or JDEP_METHOD_RETURN)
+ pending on the currently defined method. */
+
+static int patch_stage;
+
+/* Check the method declaration and add the method to its current
+ class. If the argument list is known to contain incomplete types,
+ the method is partially added and the registration will be resume
+ once the method arguments resolved */
+
+static tree
+method_header (flags, type, mdecl, throws)
+ int flags;
+ tree type, mdecl, throws;
+{
+ tree meth = TREE_VALUE (mdecl);
+ tree id = TREE_PURPOSE (mdecl);
+ tree this_class = TREE_TYPE (ctxp->current_parsed_class);
+ tree handle_class = CLASS_TO_HANDLE_TYPE (this_class);
+ tree meth_name, returned_type;
+ int saved_lineno;
+
+ check_modifiers_consistency (flags);
+
+ /* There are some forbidden modifiers for an abstract method and its
+ class must be abstract as well. */
+ if (flags & ACC_ABSTRACT)
+ {
+ ABSTRACT_CHECK (flags, ACC_PRIVATE, id, "Private");
+ ABSTRACT_CHECK (flags, ACC_STATIC, id, "Static");
+ ABSTRACT_CHECK (flags, ACC_FINAL, id, "Final");
+ ABSTRACT_CHECK (flags, ACC_NATIVE, id, "Native");
+ ABSTRACT_CHECK (flags, ACC_SYNCHRONIZED,id, "Synchronized");
+ if (!CLASS_ABSTRACT (TYPE_NAME (this_class)))
+ parse_error_context
+ (id, "Class `%s' must be declared abstract to define abstract "
+ "method `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (ctxp->current_parsed_class)),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
+ }
+
+
+ /* Method declared within the scope of an interface are implicitly
+ abstract and public. Conflicts with other erroneously provided
+ modifiers are check right after. */
+
+ if (CLASS_INTERFACE (TYPE_NAME (this_class)))
+ {
+ /* If FLAGS isn't set because of a modifier, turn the
+ corresponding modifier WFL to NULL so we issue a warning on
+ the obsolete use of the modifier */
+ if (!(flags & ACC_PUBLIC))
+ MODIFIER_WFL (PUBLIC_TK) = NULL;
+ if (!(flags & ACC_ABSTRACT))
+ MODIFIER_WFL (ABSTRACT_TK) = NULL;
+ flags |= ACC_PUBLIC;
+ flags |= ACC_ABSTRACT;
+ }
+
+ /* Modifiers context reset moved up, so abstract method declaration
+ modifiers can be later checked. */
+
+ meth_name = EXPR_WFL_NODE (id);
+
+ if (unresolved_type_p (type, &returned_type))
+ {
+ if (returned_type)
+ TREE_TYPE (meth) = returned_type;
+ else
+ {
+ patch_stage = JDEP_METHOD_RETURN;
+ TREE_TYPE (meth) =
+ register_incomplete_type (patch_stage, type, id, NULL_TREE);
+ }
+ }
+ else
+ TREE_TYPE (meth) = type;
+
+ saved_lineno = lineno;
+ /* When defining an abstract or interface method, the curly
+ bracket at level 1 doesn't exist because there is no function
+ body */
+ lineno = (ctxp->first_ccb_indent1 ? ctxp->first_ccb_indent1 :
+ EXPR_WFL_LINENO (id));
+
+ if (patch_stage) /* includes ret type and/or all args */
+ {
+ jdep *jdep;
+ meth = add_method_1 (this_class, flags, meth_name, meth);
+ /* Patch for the return type */
+ if (patch_stage == JDEP_METHOD_RETURN)
+ {
+ jdep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_GET_PATCH (jdep) = &TREE_TYPE (TREE_TYPE (meth));
+ }
+ /* This is the stop JDEP. METH allows the function's signature
+ to be computed. */
+ register_incomplete_type (JDEP_METHOD_END, NULL_TREE, meth, NULL_TREE);
+ }
+ else
+ {
+ tree signature = build_java_signature (meth);
+ tree arg, orig_arg;
+ /* Save original argument list, including argument's names */
+ orig_arg = TYPE_ARG_TYPES (meth);
+ /* Add the method to its class */
+ meth = add_method (this_class, flags, meth_name, signature);
+ /* Fix the method argument list so we have the argument name
+ information */
+ arg = TYPE_ARG_TYPES (TREE_TYPE (meth));
+ if (TREE_CODE (TREE_TYPE (meth)) == METHOD_TYPE)
+ {
+ TREE_PURPOSE (arg) = this_identifier_node;
+ arg = TREE_CHAIN (arg);
+ }
+ while (orig_arg)
+ {
+ TREE_PURPOSE (arg) = TREE_PURPOSE (orig_arg);
+ orig_arg = TREE_CHAIN (orig_arg);
+ arg = TREE_CHAIN (arg);
+ }
+ }
+ DECL_MAX_LOCALS (meth) = ctxp->formal_parameter_number+1;
+ lineno = saved_lineno;
+ /* We set the DECL_NAME to ID so we can track the location where
+ the function was declared. This allow us to report
+ redefinition error accurately. When method are verified,
+ DECL_NAME is reinstalled properly (using the content of the
+ WFL node ID) (see check_method_redefinition). We don't do that
+ when Object is being defined. */
+ if (TREE_TYPE (ctxp->current_parsed_class) != object_type_node)
+ DECL_NAME (meth) = id;
+ return meth;
+}
+
+/* Check modifiers that can be declared but exclusively */
+
+static void
+check_modifiers_consistency (flags)
+ int flags;
+{
+ int acc_count = 0;
+ tree cl = NULL_TREE;
+
+ THIS_MODIFIER_ONLY (flags, ACC_PUBLIC, 0, acc_count, cl);
+ THIS_MODIFIER_ONLY (flags, ACC_PRIVATE, 1, acc_count, cl);
+ THIS_MODIFIER_ONLY (flags, ACC_PROTECTED, 2, acc_count, cl);
+ if (acc_count > 1)
+ parse_error_context
+ (cl, "Inconsistent member declaration. At most one of `public', "
+ "`private', or `protected' may be specified");
+}
+
+/* Check the methode header METH for abstract specifics features */
+
+static void
+check_abstract_method_header (meth)
+ tree meth;
+{
+ int flags = get_access_flags_from_decl (meth);
+ /* DECL_NAME might still be a WFL node */
+ tree name = (TREE_CODE (DECL_NAME (meth)) == EXPR_WITH_FILE_LOCATION ?
+ EXPR_WFL_NODE (DECL_NAME (meth)) : DECL_NAME (meth));
+
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (ABSTRACT_TK), flags,
+ ACC_ABSTRACT, "abstract method `%s'",
+ IDENTIFIER_POINTER (name));
+ OBSOLETE_MODIFIER_WARNING (MODIFIER_WFL (PUBLIC_TK), flags,
+ ACC_PUBLIC, "abstract method `%s'",
+ IDENTIFIER_POINTER (name));
+
+ check_modifiers ("Illegal modifier `%s' for interface method",
+ flags, INTERFACE_METHOD_MODIFIERS);
+}
+
+/* Create a FUNCTION_TYPE node and start augmenting it with the
+ declared function arguments. Arguments type that can't be resolved
+ are left as they are, but the returned node is marked as containing
+ incomplete types. */
+
+static tree
+method_declarator (id, list)
+ tree id, list;
+{
+ tree arg_types = NULL_TREE, current, node;
+ tree meth = make_node (FUNCTION_TYPE);
+ jdep *jdep;
+ int incomplete = 0;
+
+ patch_stage = JDEP_NO_PATCH;
+
+ for (current = list; current; current = TREE_CHAIN (current))
+ {
+ tree wfl_name = TREE_PURPOSE (current);
+ tree type = TREE_VALUE (current);
+ tree name = EXPR_WFL_NODE (wfl_name);
+ tree patchable_type = NULL_TREE, already;
+ tree arg_node, returned_type;
+
+ /* Check redefinition */
+ for (already = arg_types; already; already = TREE_CHAIN (already))
+ if (TREE_PURPOSE (already) == name)
+ {
+ parse_error_context
+ (wfl_name, "Variable `%s' is used more than once in the "
+ "argument list of method `%s'", IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (id)));
+ break;
+ }
+
+ /* If we've an incomplete argument type, we know there is a location
+ to patch when the type get resolved, later. */
+ jdep = NULL;
+ if (unresolved_type_p (type, &returned_type))
+ {
+ if (returned_type)
+ type = returned_type;
+ else
+ {
+ patch_stage = JDEP_METHOD;
+ type = register_incomplete_type (patch_stage, type,
+ wfl_name, NULL_TREE);
+ jdep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_MISC (jdep) = id;
+ }
+ }
+ /* The argument node: a name and a (possibly) incomplete type */
+ arg_node = build_tree_list (name, type);
+ if (jdep)
+ JDEP_GET_PATCH (jdep) = &TREE_VALUE (arg_node);
+ TREE_CHAIN (arg_node) = arg_types;
+ arg_types = arg_node;
+ }
+ TYPE_ARG_TYPES (meth) = nreverse (arg_types);
+ node = build_tree_list (id, meth);
+ return node;
+}
+
+static int
+unresolved_type_p (wfl, returned)
+ tree wfl;
+ tree *returned;
+
+{
+ if (TREE_CODE (wfl) == EXPR_WITH_FILE_LOCATION)
+ {
+ tree decl = IDENTIFIER_CLASS_VALUE (EXPR_WFL_NODE (wfl));
+ if (returned)
+ *returned = (decl ? TREE_TYPE (decl) : NULL_TREE);
+ return 1;
+ }
+ if (returned)
+ *returned = wfl;
+ return 0;
+}
+
+/* From NAME, build a qualified identifier node using the
+ qualification from the current package definition. */
+
+static tree
+parser_qualified_classname (name)
+ tree name;
+{
+ if (ctxp->package)
+ return merge_qualified_name (ctxp->package, EXPR_WFL_NODE (name));
+ else
+ return EXPR_WFL_NODE (name);
+}
+
+/* Called once the type a interface extends is resolved. Returns 0 if
+ everything is OK. */
+
+static int
+parser_check_super_interface (super_decl, this_decl, this_wfl)
+ tree super_decl, this_decl, this_wfl;
+{
+ tree super_type = TREE_TYPE (super_decl);
+
+ /* Has to be an interface */
+ if (!CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (super_decl))))
+ {
+ parse_error_context
+ (this_wfl, "Can't use %s `%s' to implement/extend %s `%s'",
+ (TYPE_ARRAY_P (super_type) ? "array" : "class"),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl)),
+ (CLASS_INTERFACE (TYPE_NAME (TREE_TYPE (this_decl))) ?
+ "interface" : "class"),
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)));
+ return 1;
+ }
+
+ /* Check scope: same package OK, other package: OK if public */
+ if (check_pkg_class_access (DECL_NAME (super_decl), lookup_cl (this_decl)))
+ return 1;
+
+ SOURCE_FRONTEND_DEBUG (("Completing interface %s with %s",
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl))));
+ return 0;
+}
+
+/* Makes sure that SUPER_DECL is suitable to extend THIS_DECL. Returns
+ 0 if everthing is OK. */
+
+static int
+parser_check_super (super_decl, this_decl, wfl)
+ tree super_decl, this_decl, wfl;
+{
+ tree this_type = TREE_TYPE (this_decl);
+ tree super_type = TREE_TYPE (super_decl);
+
+ /* SUPER should be a CLASS (neither an array nor an interface) */
+ if (TYPE_ARRAY_P (super_type) || CLASS_INTERFACE (TYPE_NAME (super_type)))
+ {
+ parse_error_context
+ (wfl, "Class `%s' can't subclass %s `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)),
+ (CLASS_INTERFACE (TYPE_NAME (super_type)) ? "interface" : "array"),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl)));
+ return 1;
+ }
+
+ if (CLASS_FINAL (TYPE_NAME (super_type)))
+ {
+ parse_error_context (wfl, "Can't subclass final classes: %s",
+ IDENTIFIER_POINTER (DECL_NAME (super_decl)));
+ return 1;
+ }
+
+ /* Check scope: same package OK, other package: OK if public */
+ if (check_pkg_class_access (DECL_NAME (super_decl), wfl))
+ return 1;
+
+ SOURCE_FRONTEND_DEBUG (("Completing class %s with %s",
+ IDENTIFIER_POINTER (DECL_NAME (this_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (super_decl))));
+ return 0;
+}
+
+/* Create a new dependency list and link it (in a LIFO manner) to the
+ CTXP list of type dependency list. */
+
+static void
+create_jdep_list (ctxp)
+ struct parser_ctxt *ctxp;
+{
+ jdeplist *new = malloc (sizeof (jdeplist));
+
+ if (!new)
+ fatal ("Can't alloc jdeplist - create_jdep_list");
+
+ new->first = new->last = NULL;
+ new->next = ctxp->classd_list;
+ ctxp->classd_list = new;
+}
+
+static jdeplist *
+reverse_jdep_list (ctxp)
+ struct parser_ctxt *ctxp;
+{
+ register jdeplist *prev = NULL, *current, *next;
+ for (current = ctxp->classd_list; current; current = next)
+ {
+ next = current->next;
+ current->next = prev;
+ prev = current;
+ }
+ return prev;
+}
+
+/* Create a fake pointer based on the ID stored in the WFL */
+
+static tree
+obtain_incomplete_type (wfl)
+ tree wfl;
+{
+ tree ptr;
+ tree name = EXPR_WFL_NODE (wfl);
+
+ for (ptr = ctxp->incomplete_class; ptr; ptr = TREE_CHAIN (ptr))
+ if (TYPE_NAME (TREE_PURPOSE (ptr)) == name)
+ break;
+
+ if (!ptr)
+ {
+ tree core;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ BUILD_PTR_FROM_NAME (core, name);
+ ptr = build_tree_list (core, NULL_TREE);
+ pop_obstacks ();
+ TREE_CHAIN (ptr) = ctxp->incomplete_class;
+ ctxp->incomplete_class = ptr;
+ }
+
+ return ptr;
+}
+
+/* Register a incomplete type whose name is WFL. Reuse PTR if PTR is
+ non NULL instead of computing a new fake type based on WFL. The new
+ dependency is inserted in the current type dependency list, in FIFO
+ manner. */
+
+static tree
+register_incomplete_type (kind, wfl, decl, ptr)
+ int kind;
+ tree wfl, decl, ptr;
+{
+ jdep *new = malloc (sizeof (jdep));
+
+ if (!new)
+ fatal ("Can't allocate new jdep - register_incomplete_type");
+ if (!ptr && kind != JDEP_METHOD_END) /* JDEP_METHOD_END is a mere marker */
+ ptr = obtain_incomplete_type (wfl);
+
+ JDEP_KIND (new) = kind;
+ JDEP_DECL (new) = decl;
+ JDEP_SOLV (new) = ptr;
+ JDEP_WFL (new) = wfl;
+ JDEP_CHAIN (new) = NULL;
+ JDEP_MISC (new) = NULL_TREE;
+ JDEP_GET_PATCH (new) = (tree *)NULL;
+
+ JDEP_INSERT (ctxp->classd_list, new);
+
+ return ptr;
+}
+
+void
+java_check_circular_reference ()
+{
+ tree current;
+ for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+ {
+ tree type = TREE_TYPE (current);
+ if (CLASS_INTERFACE (TYPE_NAME (type)))
+ {
+ /* Check all interfaces this class extends */
+ tree basetype_vec = TYPE_BINFO_BASETYPES (type);
+ int n, i;
+
+ if (!basetype_vec)
+ return;
+ n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; i < n; i++)
+ {
+ tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
+ if (vec_elt && BINFO_TYPE (vec_elt) != object_type_node
+ && interface_of_p (type, BINFO_TYPE (vec_elt)))
+ parse_error_context (lookup_cl (current),
+ "Cyclic interface inheritance");
+ }
+ }
+ else
+ if (inherits_from_p (CLASSTYPE_SUPER (type), type))
+ parse_error_context (lookup_cl (current),
+ "Cyclic class inheritance");
+ }
+}
+
+void
+safe_layout_class (class)
+ tree class;
+{
+ tree save_current_class = current_class;
+ char *save_input_filename = input_filename;
+ int save_lineno = lineno;
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ layout_class (class);
+ pop_obstacks ();
+
+ current_class = save_current_class;
+ input_filename = save_input_filename;
+ lineno = save_lineno;
+ CLASS_LOADED_P (class) = 1;
+}
+
+static tree
+jdep_resolve_class (dep)
+ jdep *dep;
+{
+ tree decl;
+
+ if (!JDEP_RESOLVED_P (dep))
+ {
+ decl =
+ resolve_class (JDEP_TO_RESOLVE (dep), JDEP_DECL (dep), JDEP_WFL (dep));
+ JDEP_RESOLVED (dep, decl);
+ }
+ else
+ decl = JDEP_RESOLVED_DECL (dep);
+
+ if (!decl)
+ {
+ complete_class_report_errors (dep);
+ return NULL_TREE;
+ }
+ return decl;
+}
+
+/* Complete unsatisfied class declaration and their dependencies */
+
+void
+java_complete_class ()
+{
+ tree current;
+ tree cclass;
+ jdeplist *cclassd;
+ int error_found;
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+
+ /* Process imports and reverse the import on demand list */
+ process_imports ();
+ if (ctxp->import_demand_list)
+ ctxp->import_demand_list = nreverse (ctxp->import_demand_list);
+
+ /* Rever things so we have the right order */
+ ctxp->class_list = nreverse (ctxp->class_list);
+ ctxp->classd_list = reverse_jdep_list (ctxp);
+
+ for (cclassd = ctxp->classd_list, cclass = ctxp->class_list;
+ cclass && cclassd;
+ cclass = TREE_CHAIN (cclass), cclassd = CLASSD_CHAIN (cclassd))
+ {
+ jdep *dep;
+ for (dep = CLASSD_FIRST (cclassd); dep; dep = JDEP_CHAIN (dep))
+ {
+ tree decl;
+
+ if (!(decl = jdep_resolve_class (dep)))
+ continue;
+
+ /* Now it's time to patch */
+ switch (JDEP_KIND (dep))
+ {
+ case JDEP_SUPER:
+ /* Simply patch super */
+ if (parser_check_super (decl, JDEP_DECL (dep), JDEP_WFL (dep)))
+ continue;
+ BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO
+ (TREE_TYPE (JDEP_DECL (dep)))), 0)) = TREE_TYPE (decl);
+ break;
+
+ case JDEP_FIELD:
+ {
+ /* We do part of the job done in add_field */
+ tree field_decl = JDEP_DECL (dep);
+ tree field_type = TREE_TYPE (decl);
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+#if ! JAVA_PROMOTE_TO_INT
+ if (TREE_CODE (field_type) == RECORD_TYPE)
+#endif
+ field_type = promote_type (field_type);
+ pop_obstacks ();
+ TREE_TYPE (field_decl) = field_type;
+ SOURCE_FRONTEND_DEBUG
+ (("Completed field/var decl `%s' with `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (field_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (decl))));
+ break;
+ }
+ case JDEP_METHOD: /* We start patching a method */
+ case JDEP_METHOD_RETURN:
+ error_found = 0;
+ while (1)
+ {
+ if (decl)
+ {
+ tree type = promote_type (TREE_TYPE(decl));
+ JDEP_APPLY_PATCH (dep, type);
+ SOURCE_FRONTEND_DEBUG
+ (((JDEP_KIND (dep) == JDEP_METHOD_RETURN ?
+ "Completing fct `%s' with ret type `%s'":
+ "Completing arg `%s' with type `%s'"),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE
+ (JDEP_DECL_WFL (dep))),
+ IDENTIFIER_POINTER (DECL_NAME (decl))));
+ }
+ else
+ error_found = 1;
+ dep = JDEP_CHAIN (dep);
+ if (JDEP_KIND (dep) == JDEP_METHOD_END)
+ break;
+ else
+ decl = jdep_resolve_class (dep);
+ }
+ if (!error_found)
+ {
+ tree mdecl = JDEP_DECL (dep), signature;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ /* Recompute and reset the signature */
+ signature = build_java_signature (TREE_TYPE (mdecl));
+ set_java_signature (TREE_TYPE (mdecl), signature);
+ pop_obstacks ();
+ }
+ else
+ continue;
+ break;
+
+ case JDEP_INTERFACE:
+ if (parser_check_super_interface (decl, JDEP_DECL (dep),
+ JDEP_WFL (dep)))
+ continue;
+ parser_add_interface (JDEP_DECL (dep), decl, JDEP_WFL (dep));
+ break;
+
+ case JDEP_VARIABLE:
+ JDEP_APPLY_PATCH (dep, promote_type (TREE_TYPE (decl)));
+ SOURCE_FRONTEND_DEBUG
+ (("Completing variable `%s' with type `%s'",
+ (TREE_CODE (JDEP_DECL_WFL (dep)) == EXPR_WITH_FILE_LOCATION ?
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))) :
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL_WFL (dep)))),
+ IDENTIFIER_POINTER (DECL_NAME (decl))));
+ break;
+
+ case JDEP_TYPE:
+ JDEP_APPLY_PATCH (dep, TREE_TYPE (decl));
+ SOURCE_FRONTEND_DEBUG
+ (("Completing a random type dependency on a '%s' node",
+ tree_code_name [TREE_CODE (JDEP_DECL (dep))]));
+ break;
+
+ case JDEP_PARM:
+ JDEP_APPLY_PATCH (dep, promote_type (TREE_TYPE (decl)));
+ SOURCE_FRONTEND_DEBUG
+ (("Completing parameter `%s' with type `%s'",
+ IDENTIFIER_POINTER (JDEP_MISC (dep)),
+ IDENTIFIER_POINTER (DECL_NAME (decl))));
+ break;
+
+ default:
+ fatal ("incomplete switch - java_complete_class");
+ }
+ }
+ }
+ pop_obstacks ();
+ return;
+}
+
+/* Resolve class CLASS_TYPE. Handle the case of trying to resolve an
+ array. */
+
+static tree
+resolve_class (class_type, decl, cl)
+ tree class_type, decl, cl;
+{
+ char *name = IDENTIFIER_POINTER (TYPE_NAME (class_type));
+ char *base = name;
+ tree resolved_type, resolved_type_decl;
+
+ /* 1- Check to see if we have an array. If true, find what we really
+ want to resolve */
+ while (name[0] == '[')
+ name++;
+ if (base != name)
+ TYPE_NAME (class_type) = get_identifier (name);
+
+ /* 2- Resolve the bare type */
+ if (!(resolved_type_decl = do_resolve_class (class_type, decl, cl)))
+ return NULL_TREE;
+ resolved_type = TREE_TYPE (resolved_type_decl);
+
+ /* 3- If we have and array, reconstruct the array down to its nesting */
+ if (base != name)
+ {
+ while (base != name)
+ {
+ if (TREE_CODE (resolved_type) == RECORD_TYPE)
+ resolved_type = promote_type (resolved_type);
+ resolved_type = build_java_array_type (resolved_type, -1);
+ name--;
+ }
+ /* Build a fake decl for this, since this is what is expected to
+ be returned. */
+ resolved_type_decl =
+ build_decl (TYPE_DECL, TYPE_NAME (resolved_type), resolved_type);
+ /* Figure how those two things are important for error report. FIXME */
+ DECL_SOURCE_LINE (resolved_type_decl) = 0;
+ DECL_SOURCE_FILE (resolved_type_decl) = input_filename;
+ }
+ return resolved_type_decl;
+}
+
+/* Effectively perform the resolution of class CLASS_TYPE. DECL or CL
+ are used to report error messages. */
+
+static tree
+do_resolve_class (class_type, decl, cl)
+ tree class_type;
+ tree decl;
+ tree cl;
+{
+ tree new_class_decl;
+ tree original_name = NULL_TREE;
+
+ /* Do not try to replace TYPE_NAME (class_type) by a variable, since
+ its is changed by find_in_imports{_on_demand} */
+
+ /* 1- Check for the type in single imports */
+ if (find_in_imports (class_type))
+ return NULL_TREE;
+
+ /* 2- And check for the type in the current compilation unit. If it fails,
+ try with a name qualified with the package name if appropriate. */
+
+ if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
+ {
+ if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
+ !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
+ load_class (TYPE_NAME (class_type), 0);
+ return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+ }
+
+ original_name = TYPE_NAME (class_type);
+ if (!QUALIFIED_P (TYPE_NAME (class_type)) && ctxp->package)
+ TYPE_NAME (class_type) = merge_qualified_name (ctxp->package,
+ TYPE_NAME (class_type));
+ if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
+ {
+ if (!CLASS_LOADED_P (TREE_TYPE (new_class_decl)) &&
+ !CLASS_FROM_SOURCE_P (TREE_TYPE (new_class_decl)))
+ load_class (TYPE_NAME (class_type), 0);
+ return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+ }
+ TYPE_NAME (class_type) = original_name;
+
+ /* 3- Check an other compilation unit that bears the name of type */
+ load_class (TYPE_NAME (class_type), 0);
+ if (check_pkg_class_access (TYPE_NAME (class_type),
+ (cl ? cl : lookup_cl (decl))))
+ return NULL_TREE;
+
+ if ((new_class_decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type))))
+ return new_class_decl;
+
+ /* 4- Check the import on demands. Don't allow bar.baz to be
+ imported from foo.* */
+ if (!QUALIFIED_P (TYPE_NAME (class_type)))
+ if (find_in_imports_on_demand (class_type))
+ return NULL_TREE;
+
+ /* 5- Last call for a resolution */
+ return IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+}
+
+/* Resolve NAME and lay it out (if not done and if not the current
+ parsed class). Return a decl node. */
+
+static tree
+resolve_and_layout (name, cl)
+ tree name;
+ tree cl;
+{
+ tree decl = resolve_no_layout (name, cl);
+ if (decl && TREE_TYPE (decl) != current_class
+ && !CLASS_LOADED_P (TREE_TYPE (decl)))
+ safe_layout_class (TREE_TYPE (decl));
+ return decl;
+}
+
+/* Resolve a class, returns its decl but doesn't perform any
+ layout. The current parsing context is saved and restored */
+
+static tree
+resolve_no_layout (name, cl)
+ tree name, cl;
+{
+ tree ptr, decl;
+ BUILD_PTR_FROM_NAME (ptr, name);
+ java_parser_context_save_global ();
+ decl = resolve_class (ptr, NULL_TREE, cl);
+ java_parser_context_restore_global ();
+
+ return decl;
+}
+
+/* Called to report errors. Skip leader '[' in a complex array type
+ description that failed to be resolved. */
+
+static char *
+purify_type_name (name)
+ char *name;
+{
+ while (*name && *name == '[')
+ name++;
+ return name;
+}
+
+/* The type CURRENT refers to can't be found. We print error messages. */
+
+static void
+complete_class_report_errors (dep)
+ jdep *dep;
+{
+ switch (JDEP_KIND (dep))
+ {
+ case JDEP_SUPER:
+ parse_error_context
+ (JDEP_WFL (dep), "Superclass `%s' of class `%s' not found",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ case JDEP_FIELD:
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in declaration of field `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ case JDEP_METHOD: /* Covers arguments */
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
+ "argument `%s' of method `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_MISC (dep))));
+ break;
+ case JDEP_METHOD_RETURN: /* Covers return type */
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
+ "return type of method `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_DECL_WFL (dep))));
+ break;
+ case JDEP_INTERFACE:
+ parse_error_context
+ (JDEP_WFL (dep), "Superinterface `%s' of %s `%s' not found",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep))),
+ (CLASS_OR_INTERFACE (JDEP_DECL (dep), "class", "interface")),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ case JDEP_VARIABLE:
+ parse_error_context
+ (JDEP_WFL (dep), "Type `%s' not found in the declaration of the "
+ "local variable `%s'",
+ purify_type_name (IDENTIFIER_POINTER (EXPR_WFL_NODE (JDEP_WFL (dep)))),
+ IDENTIFIER_POINTER (DECL_NAME (JDEP_DECL (dep))));
+ break;
+ }
+}
+
+/* Check uninitialized final. */
+
+void
+java_check_final ()
+{
+}
+
+static int
+check_method_redefinition (class, method)
+ tree class, method;
+{
+ tree redef, name;
+ tree cl = DECL_NAME (method);
+ tree sig = TYPE_LANG_SPECIFIC (TREE_TYPE (method))->signature;
+ /* decl name of generated <clinit> doesn't need to be fixed and
+ checked */
+ if (DECL_NAME (method) != clinit_identifier_node)
+ {
+ /* NAME is just the plain name when Object is being defined */
+ if (class != object_type_node)
+ name = DECL_NAME (method) = EXPR_WFL_NODE (DECL_NAME (method));
+ else
+ name = DECL_NAME (method);
+ }
+ else
+ return 0;
+
+ for (redef = TYPE_METHODS (class); redef; redef = TREE_CHAIN (redef))
+ {
+ struct lang_type *t = TYPE_LANG_SPECIFIC (TREE_TYPE (redef));
+
+ if (! t || (redef == method))
+ break;
+ if (DECL_NAME (redef) == name && sig == t->signature)
+ {
+ parse_error_context (cl, "Duplicate method declaration");
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* Check all the methods of CLASS. Methods are first completed then
+ checked according to regular method existance rules.
+ If no constructor were encountered, then build its declaration. */
+
+static void
+java_check_regular_methods (class_decl)
+ tree class_decl;
+{
+ tree method;
+ tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (class_decl));
+ tree super_class = CLASSTYPE_SUPER (class);
+ int seen_constructor = 0;
+
+ TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
+
+ /* Should take interfaces into account. FIXME */
+ for (method = TYPE_METHODS (class); method; method = TREE_CHAIN (method))
+ {
+ tree found, sig;
+ tree method_wfl = DECL_NAME (method);
+ int aflags;
+
+ if (DECL_CONSTRUCTOR_P (method))
+ seen_constructor = 1;
+
+ /* Check for redefinitions */
+ if (check_method_redefinition (class, method))
+ continue;
+
+ sig = build_java_argument_signature (TREE_TYPE (method));
+
+ found = lookup_argument_method (super_class, DECL_NAME (method), sig);
+ if (! found)
+ continue;
+ /* Can't override a method with the same name and different return
+ types. */
+ if (TREE_TYPE (TREE_TYPE (found)) != TREE_TYPE (TREE_TYPE (method)))
+ parse_warning_context
+ (method_wfl,
+ "Method `%s' redefined with different return type in class `%s'",
+ lang_printable_name (found),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+
+ /* Can't override final. Can't override static. */
+ if (METHOD_FINAL (found) || METHOD_STATIC (found))
+ {
+ /* Static *can* override static */
+ if (METHOD_STATIC (found) && METHOD_STATIC (method))
+ continue;
+ parse_error_context
+ (method_wfl,
+ "%s methods can't be overriden. Method `%s' is %s in class `%s'",
+ (METHOD_FINAL (found) ? "Final" : "Static"),
+ lang_printable_name (found),
+ (METHOD_FINAL (found) ? "final" : "static"),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ continue;
+ }
+ /* Static method can't override instance method. */
+ if (METHOD_STATIC (method))
+ {
+ parse_error_context
+ (method_wfl,
+ "Instance methods can't be overriden by a static method. Method "
+ "`%s' is an instance method in class `%s'",
+ lang_printable_name (found),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ continue;
+ }
+ /* Overriding/hiding public must be public or
+ overriding/hiding protected must be protected or public */
+ if ((METHOD_PUBLIC (found) && !METHOD_PUBLIC (method)) ||
+ (METHOD_PROTECTED (found)
+ && !(METHOD_PUBLIC (method) || METHOD_PROTECTED (method))))
+ {
+ parse_error_context
+ (method_wfl,
+ "Methods can't be overridden to be more private. Method `%s' is "
+ "%s in class `%s'", lang_printable_name (found),
+ (METHOD_PUBLIC (found) ? "public" : "protected"),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ continue;
+ }
+
+ /* If the method has default access in an other package, then
+ issue a warning that the current method doesn't override the one
+ that was found elsewhere */
+ aflags = get_access_flags_from_decl (found);
+ if ((!aflags || (aflags > ACC_PROTECTED))
+ && !class_in_current_package (DECL_CONTEXT (found)))
+ parse_warning_context
+ (method_wfl, "Method `%s' in class `%s' does not "
+ "override the corresponding method in class `%s', which is "
+ "private to a different package",
+ lang_printable_name (found),
+ IDENTIFIER_POINTER (DECL_NAME (class_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+
+ /* Check on (default) package access. FIXME. */
+ /* Inheriting multiple methods with the same signature. FIXME */
+ }
+
+ TYPE_METHODS (class) = nreverse (TYPE_METHODS (class));
+
+ if (!seen_constructor)
+ {
+ /* No constructor seen, we craft one, at line 0 */
+ int saved_lineno = lineno;
+ tree meth, decl;
+ lineno = 0;
+ meth = make_node (FUNCTION_TYPE);
+ TREE_TYPE (meth) = void_type_node;
+ TYPE_ARG_TYPES (meth) = NULL_TREE;
+ decl = add_method (class, 0, init_identifier_node,
+ build_java_signature (meth));
+ DECL_CONSTRUCTOR_P (decl) = 1;
+ lineno = saved_lineno;
+ }
+}
+
+/* Check abstract method of interface INTERFACE */
+
+static void
+java_check_abstract_methods (interface)
+ tree interface;
+{
+ int i, n;
+ tree method, basetype_vec, found;
+
+ for (method = TYPE_METHODS (interface); method; method = TREE_CHAIN (method))
+ {
+ char *csig;
+ tree name = DECL_NAME (method);
+
+ /* 2- Check for double definition inside the defining interface */
+ if (check_method_redefinition (interface, method))
+ continue;
+
+ /* 3- Overriding is OK as far as we preserve the return type and
+ the thrown exceptions */
+ found = lookup_java_interface_method2 (interface, method);
+ if (found)
+ {
+ parse_error_context
+ (lookup_cl (method),
+ "Method `%s' previously defined in interface `%s' is "
+ "redefined with different return type in interface `%s'",
+ lang_printable_name (found),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))));
+ continue;
+ }
+ }
+
+ /* 4- Inherited methods can't differ by their returned types */
+ if (!(basetype_vec = TYPE_BINFO_BASETYPES (interface)))
+ return;
+ n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; i < n; i++)
+ {
+ tree sub_interface_method, sub_interface;
+ tree vec_elt = TREE_VEC_ELT (basetype_vec, i);
+ if (!vec_elt)
+ continue;
+ sub_interface = BINFO_TYPE (vec_elt);
+ for (sub_interface_method = TYPE_METHODS (sub_interface);
+ sub_interface_method;
+ sub_interface_method = TREE_CHAIN (sub_interface_method))
+ {
+ found = lookup_java_interface_method2 (interface,
+ sub_interface_method);
+ if (found && (found != sub_interface_method))
+ parse_error_context
+ (lookup_cl (sub_interface_method),
+ "Interface `%s' inherits method `%s' from interface `%s'. This "
+ "method is redefined with a different return "
+ "type in interface `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (interface))),
+ lang_printable_name (found),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (sub_interface_method)))),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (DECL_CONTEXT (found)))));
+ }
+ }
+}
+
+/* Check the method on all the defined classes. Should be done to the
+ classes declared in the compilation unit only. FIXME */
+
+void
+java_check_methods ()
+{
+
+ tree current;
+ for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+ if (CLASS_FROM_SOURCE_P (TREE_TYPE (current)))
+ {
+ tree class = CLASS_TO_HANDLE_TYPE (TREE_TYPE (current));
+
+ if (CLASS_INTERFACE (TYPE_NAME (class)))
+ java_check_abstract_methods (class);
+ else
+ java_check_regular_methods (current);
+ }
+}
+
+/* Lookup methods in interfaces using their name and partial
+ signature. Return a matching method only if their types differ. */
+
+static tree
+lookup_java_interface_method2 (class, method_decl)
+ tree class, method_decl;
+{
+ int i, n;
+ tree basetype_vec = TYPE_BINFO_BASETYPES (class), to_return;
+
+ if (!basetype_vec)
+ return NULL_TREE;
+
+ n = TREE_VEC_LENGTH (basetype_vec);
+ for (i = 0; i < n; i++)
+ {
+ tree vec_elt = TREE_VEC_ELT (basetype_vec, i), to_return;
+ if ((BINFO_TYPE (vec_elt) != object_type_node)
+ && (to_return =
+ lookup_java_method2 (BINFO_TYPE (vec_elt), method_decl, 1)))
+ return to_return;
+ }
+ for (i = 0; i < n; i++)
+ {
+ to_return = lookup_java_interface_method2
+ (BINFO_TYPE (TREE_VEC_ELT (basetype_vec, i)), method_decl);
+ if (to_return)
+ return to_return;
+ }
+
+ return NULL_TREE;
+}
+
+/* Lookup method using their name and partial signature. Return a
+ matching method only if their types differ. */
+
+static tree
+lookup_java_method2 (clas, method_decl, do_interface)
+ tree clas, method_decl;
+ int do_interface;
+{
+ tree method, method_signature, method_name, method_type;
+ method_signature = build_java_argument_signature (TREE_TYPE (method_decl));
+ method_name = DECL_NAME (method_decl);
+ method_type = TREE_TYPE (TREE_TYPE (method_decl));
+
+ while (clas != NULL_TREE)
+ {
+ for (method = TYPE_METHODS (clas);
+ method != NULL_TREE; method = TREE_CHAIN (method))
+ {
+ tree method_sig = build_java_argument_signature (TREE_TYPE (method));
+ if (DECL_NAME (method) == method_name
+ && method_sig == method_signature
+ && TREE_TYPE (TREE_TYPE (method)) != method_type)
+ {
+ return method;
+ }
+ }
+ clas = (do_interface ? NULL_TREE : CLASSTYPE_SUPER (clas));
+ }
+ return NULL_TREE;
+}
+
+/* Return the line that matches DECL line number. Used during error
+ report */
+
+static tree
+lookup_cl (decl)
+ tree decl;
+{
+ static tree cl = NULL_TREE;
+
+ if (!decl)
+ return NULL_TREE;
+
+ if (cl == NULL_TREE)
+ cl = build_expr_wfl (NULL_TREE, NULL, 0, 0);
+
+ EXPR_WFL_FILENAME_NODE (cl) = get_identifier (DECL_SOURCE_FILE (decl));
+ EXPR_WFL_SET_LINECOL (cl, DECL_SOURCE_LINE_FIRST (decl), -1);
+
+ return cl;
+}
+
+/* Look for a simple name in the single-type import list */
+
+static tree
+find_name_in_single_imports (name)
+ tree name;
+{
+ tree node;
+
+ for (node = ctxp->import_list; node; node = TREE_CHAIN (node))
+ if (TREE_VALUE (node) == name)
+ return (EXPR_WFL_NODE (TREE_PURPOSE (node)));
+
+ return NULL_TREE;
+}
+
+/* Process all single-type import. */
+
+static int
+process_imports ()
+{
+ tree import;
+ int error_found;
+
+ for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
+ {
+ tree to_be_found = EXPR_WFL_NODE (TREE_PURPOSE (import));
+
+ /* Don't load twice something already defined. */
+ if (IDENTIFIER_CLASS_VALUE (to_be_found))
+ continue;
+ QUALIFIED_P (to_be_found) = 1;
+ load_class (to_be_found, 0);
+ error_found =
+ check_pkg_class_access (to_be_found, TREE_PURPOSE (import));
+ if (!IDENTIFIER_CLASS_VALUE (to_be_found))
+ {
+ parse_error_context (TREE_PURPOSE (import),
+ "Class or interface `%s' not found in import",
+ IDENTIFIER_POINTER (to_be_found));
+ return 1;
+ }
+ if (error_found)
+ return 1;
+ }
+ return 0;
+}
+
+/* Possibly find a class imported by a single-type import statement. Return
+ 1 if an error occured, 0 otherwise. */
+
+static int
+find_in_imports (class_type)
+ tree class_type;
+{
+ tree import;
+
+ for (import = ctxp->import_list; import; import = TREE_CHAIN (import))
+ if (TREE_VALUE (import) == TYPE_NAME (class_type))
+ {
+ TYPE_NAME (class_type) = EXPR_WFL_NODE (TREE_PURPOSE (import));
+ QUALIFIED_P (TYPE_NAME (class_type)) = 1;
+ return check_pkg_class_access (TYPE_NAME (class_type),
+ TREE_PURPOSE (import));
+ }
+ return 0;
+}
+
+/* Process a import on demand statement (lazy) */
+
+static int
+read_import_entry (jcf, dirp, returned_name)
+ JCF *jcf;
+ DIR *dirp;
+ char **returned_name;
+{
+ if (dirp)
+ {
+ struct dirent *direntp = readdir (dirp);
+ if (!direntp)
+ {
+ *returned_name = NULL;
+ return 0;
+ }
+ else
+ {
+ *returned_name = direntp->d_name;
+ return (strlen (direntp->d_name));
+ }
+ }
+ else
+ {
+ int current_dir_len = strlen (jcf->classname);
+ char *current_entry;
+ int current_entry_len;
+
+ /* Here we read a zip directory as a file directory. The files
+ we're selecting must have the same root than the directory
+ we're examining. */
+
+ ZipDirectory *zipd = (ZipDirectory *)jcf->zipd;
+
+ while (zipd)
+ {
+ current_entry = ZIPDIR_FILENAME (zipd);
+ current_entry_len = zipd->filename_length;
+ while (current_entry_len && current_entry [current_entry_len] != '/')
+ current_entry_len--;
+ /* If the path of the current file doesn't match the directory we're
+ scanning, that the end of the search */
+ current_entry_len++;
+ if (strncmp (jcf->classname, current_entry, current_dir_len))
+ {
+ *returned_name = NULL;
+ return 0;
+ }
+ /* Ok, we have at least the same path. The position of the last '/'
+ of the current file we're examining should match the size of
+ name of the directory we're browsing, otherwise that an entry
+ belonging to a sub directory, we want to skip it. */
+ if (current_entry_len != current_dir_len)
+ zipd = ZIPDIR_NEXT (zipd);
+ else
+ {
+ jcf->zipd = ZIPDIR_NEXT (zipd); /* Prepare next read */
+ *returned_name = ¤t_entry [current_entry_len];
+ return (zipd->filename_length - current_entry_len);
+ }
+ }
+ }
+}
+
+/* Read a import directory, gathering potential match for further type
+ references. Indifferently reads a filesystem or a ZIP archive
+ directory. */
+
+static void
+read_import_dir (wfl)
+ tree wfl;
+{
+ char *name = IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl));
+ int name_len = IDENTIFIER_LENGTH (EXPR_WFL_NODE (wfl)), reclen;
+ DIR *dirp = NULL;
+ tree dirname = ident_subst (name, name_len, "", '.', '/', "");
+ JCF jcfr, *jcf, *saved_jcf = current_jcf;
+ char *founddirname, *d_name;
+ struct ZipFileCache zip_cache;
+
+ jcf = &jcfr;
+ if (!classpath)
+ fix_classpath ();
+ if (!(founddirname = find_class (name, name_len, jcf, 0)))
+ fatal ("Can't import `%s'", name);
+ if (jcf->outofsynch)
+ jcf_out_of_synch (jcf);
+ if (jcf->seen_in_zip)
+ jcf->zipd = ZIPDIR_NEXT ((ZipDirectory *)jcf->zipd);
+
+ else if (founddirname && (dirp = opendir (founddirname)))
+ {
+ readdir (dirp); readdir (dirp);
+ }
+
+ if (!founddirname && !dirp)
+ {
+ static int first = 1;
+ if (first)
+ {
+ char buffer [256];
+ sprintf (buffer, "Can't find default package `%s'. Check "
+ "the CLASSPATH environment variable and the access to the "
+ "archives.", name);
+ error (buffer);
+ java_error_count++;
+ first = 0;
+ }
+ else
+ parse_error_context (wfl, "Package `%s' not found in import", name);
+ current_jcf = saved_jcf;
+ return;
+ }
+
+ /* Here we should have a unified way of retrieving an entry, to be
+ indexed. */
+ while ((reclen = read_import_entry (jcf, dirp, &d_name)))
+ {
+ int java_or_class = 0;
+ int len;
+ if ((reclen > 5)
+ && !strcmp (&d_name [reclen-5], ".java"))
+ {
+ java_or_class = 1;
+ len = reclen - 5;
+ }
+
+ if (!java_or_class && (reclen > 6) &&
+ !strcmp (&d_name [reclen-6], ".class"))
+ {
+ java_or_class = 2;
+ len = reclen - 6;
+ }
+
+ if (java_or_class)
+ {
+ char *id_name;
+ tree node, old;
+
+ obstack_grow (&temporary_obstack, name, name_len);
+ obstack_1grow (&temporary_obstack, '/');
+ obstack_grow0 (&temporary_obstack, d_name, len);
+ id_name = obstack_finish (&temporary_obstack);
+
+ node = get_identifier (id_name);
+ IS_A_CLASSFILE_NAME (node) = 1; /* Or soon to be */
+ QUALIFIED_P (node) = 1; /* As soon as we turn / into . */
+ }
+ }
+ if (dirp)
+ closedir (dirp);
+
+ current_jcf = saved_jcf;
+}
+
+/* Possibly find a type in the import on demands specified
+ types. Returns 1 if an error occured, 0 otherwise. Run throught the
+ entire list, to detected potential double definitions. */
+
+static int
+find_in_imports_on_demand (class_type)
+ tree class_type;
+{
+ tree node, import, node_to_use;
+ int seen_once = -1;
+ tree cl;
+
+ for (import = ctxp->import_demand_list; import; import = TREE_CHAIN (import))
+ {
+ char *id_name;
+ tree found;
+ obstack_grow (&temporary_obstack,
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))),
+ IDENTIFIER_LENGTH (EXPR_WFL_NODE (TREE_PURPOSE (import))));
+ obstack_1grow (&temporary_obstack, '/');
+ obstack_grow0 (&temporary_obstack,
+ IDENTIFIER_POINTER (TYPE_NAME (class_type)),
+ IDENTIFIER_LENGTH (TYPE_NAME (class_type)));
+ id_name = obstack_finish (&temporary_obstack);
+
+ node = maybe_get_identifier (id_name);
+ if (node && IS_A_CLASSFILE_NAME (node))
+ {
+ if (seen_once < 0)
+ {
+ cl = TREE_PURPOSE (import);
+ seen_once = 1;
+ node_to_use = node;
+ }
+ else
+ {
+ seen_once++;
+ parse_error_context
+ (import, "Type `%s' also potentially defined in package `%s'",
+ IDENTIFIER_POINTER (TYPE_NAME (class_type)),
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (TREE_PURPOSE (import))));
+ }
+ }
+ }
+
+ if (seen_once == 1)
+ {
+ /* Setup lineno so that it refers to the line of the import (in
+ case we parse a class file and encounter errors */
+ tree decl;
+ int saved_lineno = lineno;
+ lineno = EXPR_WFL_LINENO (cl);
+ TYPE_NAME (class_type) = ident_subst (IDENTIFIER_POINTER (node_to_use),
+ IDENTIFIER_LENGTH (node_to_use),
+ "", '/', '.', "");
+ QUALIFIED_P (TYPE_NAME (class_type)) = 1;
+ decl = IDENTIFIER_CLASS_VALUE (TYPE_NAME (class_type));
+ /* If there is no DECL set for the class or if the class isn't
+ loaded and not seen in source yet, the load */
+ if (!decl || (!CLASS_LOADED_P (TREE_TYPE (decl))
+ && !CLASS_FROM_SOURCE_P (TREE_TYPE (decl))))
+ load_class (node_to_use, 0);
+ lineno = saved_lineno;
+ return check_pkg_class_access (TYPE_NAME (class_type), cl);
+ }
+ else
+ return (seen_once < 0 ? 0 : seen_once); /* It's ok not to have found */
+}
+
+/* Check that CLASS_NAME refers to a PUBLIC class. Return 0 if no
+ access violations were found, 1 otherwise. */
+
+static int
+check_pkg_class_access (class_name, cl)
+ tree class_name;
+ tree cl;
+{
+ tree type;
+ int access;
+
+ if (!QUALIFIED_P (class_name) || !IDENTIFIER_CLASS_VALUE (class_name))
+ return 0;
+
+ if (!(type = TREE_TYPE (IDENTIFIER_CLASS_VALUE (class_name))))
+ return 0;
+
+ if (!CLASS_PUBLIC (TYPE_NAME (type)))
+ {
+ parse_error_context
+ (cl, "Can't access %s `%s'. Only public classes and interfaces in "
+ "other packages can be accessed",
+ (CLASS_INTERFACE (TYPE_NAME (type)) ? "interface" : "class"),
+ IDENTIFIER_POINTER (class_name));
+ return 1;
+ }
+ return 0;
+}
+
+/* Local variable declaration. */
+
+static void
+declare_local_variables (modifier, type, vlist)
+ int modifier;
+ tree type;
+ tree vlist;
+{
+ tree decl, current, returned_type, type_wfl, init_stmt = NULL_TREE;
+ int must_chain = 0;
+
+ /* Push a new block if statement were seen between the last time we
+ pushed a block and now. Keep a cound of block to close */
+ if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (current_function_decl)))
+ {
+ tree body = DECL_FUNCTION_BODY (current_function_decl);
+ tree b = enter_block ();
+ BLOCK_EXPR_ORIGIN(b) = body;
+ }
+
+ if (modifier)
+ {
+ int i;
+ for (i = 0; i <= 10; i++) if (1 << i & modifier) break;
+ parse_error_context
+ (ctxp->modifier_ctx [i],
+ (modifier == ACC_FINAL ?
+ "Unsupported JDK1.1 `final' locals" :
+ "Only `final' is allowed as a local variables modifier"));
+ return;
+ }
+
+ if (unresolved_type_p (type, &returned_type))
+ {
+ if (returned_type)
+ type = returned_type;
+ else
+ {
+ type_wfl = type;
+ type = obtain_incomplete_type (type);
+ must_chain = 1;
+ }
+ }
+
+ for (current = vlist; current; current = TREE_CHAIN (current))
+ {
+ tree wfl = TREE_PURPOSE (current);
+ tree name = EXPR_WFL_NODE (wfl);
+ tree init = TREE_VALUE (current);
+ tree other = lookup_name_in_blocks (name);
+
+ /* Don't try to use an INIT statement when an error was found */
+ if (init && java_error_count)
+ init = NULL_TREE;
+
+ if (other)
+ parse_error_context
+ (wfl, "Variable `%s' is already defined in this method and was "
+ "declared `%s %s' in line %d",
+ IDENTIFIER_POINTER (name), lang_printable_name (TREE_TYPE (other)),
+ IDENTIFIER_POINTER (name), DECL_SOURCE_LINE (other));
+ else
+ {
+ if (!must_chain && TREE_CODE (type) == RECORD_TYPE)
+ type = promote_type (type);
+ /* Never layout this decl. This will be done when its scope
+ will be entered */
+ decl = build_decl_no_layout (VAR_DECL, name, type);
+ BLOCK_CHAIN_DECL (decl);
+
+ /* Add the initialization function to the current function's code */
+ if (init)
+ {
+ tree wfl;
+ MODIFY_EXPR_FROM_INITIALIZATION_P (init) = 1;
+ java_method_add_stmt
+ (current_function_decl,
+ build_debugable_stmt (EXPR_WFL_LINECOL (init), init));
+ }
+
+ if (must_chain)
+ {
+ jdep *dep;
+ register_incomplete_type (JDEP_VARIABLE, type_wfl, decl, type);
+ dep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_GET_PATCH (dep) = &TREE_TYPE (decl);
+ }
+ }
+ }
+ SOURCE_FRONTEND_DEBUG (("Defined locals"));
+}
+
+/* Called during parsing. Build decls from argument list. */
+
+static void
+source_start_java_method (fndecl)
+ tree fndecl;
+{
+ tree tem;
+ tree parm_decl;
+ int i;
+
+ extern tree current_binding_level;
+ current_function_decl = fndecl;
+
+ /* New scope for the function */
+ enter_block ();
+ for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
+ tem != NULL_TREE; tem = TREE_CHAIN (tem), i++)
+ {
+ tree type = TREE_VALUE (tem);
+ tree name = TREE_PURPOSE (tem);
+
+ /* If type is incomplete. Layout can't take place
+ now. Create an incomplete decl and ask for the decl to be
+ patched later */
+ if (INCOMPLETE_TYPE_P (type))
+ {
+ jdep *jdep;
+ parm_decl = build_decl_no_layout (PARM_DECL, name, type);
+
+ register_incomplete_type (JDEP_PARM, NULL_TREE, NULL_TREE, type);
+ jdep = CLASSD_LAST (ctxp->classd_list);
+ JDEP_MISC (jdep) = name;
+ JDEP_GET_PATCH (jdep) = &TREE_TYPE (parm_decl);
+ }
+ else
+ parm_decl = build_decl (PARM_DECL, name, type);
+
+ BLOCK_CHAIN_DECL (parm_decl);
+ }
+ tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
+ BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl)) =
+ nreverse (tem);
+ DECL_ARG_SLOT_COUNT (current_function_decl) = i;
+}
+
+/* Called during expansion. Push decls formerly built from argument
+ list so they're usable during expansion. */
+
+static void
+expand_start_java_method (fndecl)
+ tree fndecl;
+{
+ tree tem, *ptr;
+ tree parm_decl;
+
+ extern tree current_binding_level;
+ current_function_decl = fndecl;
+
+ announce_function (fndecl);
+ pushlevel (1); /* Push parameters */
+ ptr = &DECL_ARGUMENTS (fndecl);
+ tem = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (current_function_decl));
+ while (tem)
+ {
+ tree next = TREE_CHAIN (tem);
+ DECL_ARG_TYPE (tem) = TREE_TYPE (tem);
+ layout_decl (tem, 0);
+ pushdecl (tem);
+ INITIALIZED_P (tem) = 1; /* Parms are initialized */
+ *ptr = tem;
+ ptr = &TREE_CHAIN (tem);
+ tem = next;
+ }
+ *ptr = NULL_TREE;
+ pushdecl_force_head (DECL_ARGUMENTS (fndecl));
+ lineno = DECL_SOURCE_LINE_FIRST (fndecl);
+ complete_start_java_method (fndecl);
+}
+
+/* Terminate a function and expand its body. */
+
+static void
+source_end_java_method ()
+{
+ tree fndecl = current_function_decl;
+
+ java_parser_context_save_global ();
+ lineno = ctxp->last_ccb_indent1;
+
+ /* Generate function's code */
+ if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl))
+ && ! flag_emit_class_files)
+ expand_expr_stmt (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)));
+
+ /* pop out of its parameters */
+ pushdecl_force_head (DECL_ARGUMENTS (fndecl));
+ poplevel (1, 0, 1);
+ BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
+
+ /* Generate rtl for function exit. */
+ if (! flag_emit_class_files)
+ {
+ lineno = DECL_SOURCE_LINE_LAST (fndecl);
+ expand_function_end (input_filename, lineno, 0);
+
+ /* Run the optimizers and output assembler code for this function. */
+ rest_of_compilation (fndecl);
+ }
+
+ current_function_decl = NULL_TREE;
+ /* permanent_allocation (1); */
+ java_parser_context_restore_global ();
+}
+
+/* Record EXPR in the current function block. Complements compound
+ expression second operand if necessary. */
+
+tree
+java_method_add_stmt (fndecl, expr)
+ tree fndecl, expr;
+{
+ tree body = BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl));
+ tree node;
+
+ if (java_error_count)
+ return body;
+ if ((node = add_stmt_to_compound (body, NULL_TREE, expr)) == body)
+ return body;
+
+ BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (fndecl)) = node;
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* Add STMT to EXISTING if possible, otherwise create a new
+ COMPOUND_EXPR and add STMT to it. */
+
+static tree
+add_stmt_to_compound (existing, type, stmt)
+ tree existing, type, stmt;
+{
+ tree node;
+
+ if (existing && (TREE_CODE (existing) == COMPOUND_EXPR)
+ && TREE_OPERAND (existing, 1) == size_zero_node)
+ {
+ TREE_OPERAND (existing, 1) = stmt;
+ TREE_TYPE (existing) = type;
+ return existing;
+ }
+ else if (existing)
+ node = build (COMPOUND_EXPR, type, existing, stmt);
+ else
+ node = build (COMPOUND_EXPR, type, stmt, size_zero_node);
+
+ return node;
+}
+
+/* Hold THIS for the scope of the current public method decl. */
+static tree current_this;
+
+/* Layout all class found during parsing */
+
+void
+java_layout_classes ()
+{
+ tree current;
+ for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+ {
+ current_class = TREE_TYPE (current);
+ TYPE_FIELDS (current_class) = nreverse (TYPE_FIELDS (current_class));
+ if (!TYPE_SIZE (current_class))
+ safe_layout_class (current_class);
+ }
+}
+
+/* Expand all methods in all registered classes. */
+
+void
+java_complete_expand_methods ()
+{
+ tree current;
+
+ for (current = ctxp->class_list; current; current = TREE_CHAIN (current))
+ {
+ extern tree current_constant_pool_data_ref;
+ tree class_type = CLASS_TO_HANDLE_TYPE (TREE_TYPE (current));
+ tree decl;
+ int saved_lineno;
+
+ current_class = TREE_TYPE (current);
+
+ /* Initialize a new constant pool */
+ init_outgoing_cpool ();
+
+ /* Don't process function bodies in interfaces */
+ if (!CLASS_INTERFACE (TYPE_NAME (current_class)))
+ for (decl = TYPE_METHODS (class_type); decl; decl = TREE_CHAIN (decl))
+ {
+ current_function_decl = decl;
+ /* Don't generate debug info on line zero when expanding a
+ generated constructor. */
+ if (DECL_CONSTRUCTOR_P (decl) && !DECL_FUNCTION_BODY (decl))
+ {
+ /* If we found errors, it's too dangerous to try to generate
+ and expand a constructor */
+ if (!java_error_count)
+ {
+ restore_line_number_status (1);
+ java_complete_expand_method (decl);
+ restore_line_number_status (0);
+ }
+ }
+ else
+ java_complete_expand_method (decl);
+ }
+
+ /* Make the class data, register it and run the rest of decl
+ compilation on it */
+ if (!java_error_count && ! flag_emit_class_files)
+ {
+ make_class_data (current_class);
+ register_class ();
+ rest_of_decl_compilation (TYPE_NAME (current_class), (char*) 0, 1, 0);
+ }
+ }
+}
+
+/* Complete and expand a method. */
+
+static void
+java_complete_expand_method (mdecl)
+ tree mdecl;
+{
+ tree node;
+ jdep *current;
+ int no_ac_found = 1;
+
+ /* We generate some code for an empty constructor */
+ if (DECL_CONSTRUCTOR_P (mdecl) && !DECL_FUNCTION_BODY (mdecl))
+ {
+ tree arg_list, func, call;
+ tree method_type = TREE_TYPE (mdecl);
+ tree class_type = CLASS_TO_HANDLE_TYPE (current_class);
+ tree self_type = (CLASSTYPE_SUPER (class_type) ?
+ CLASSTYPE_SUPER (class_type) : class_type);
+ tree method_signature =
+ TYPE_LANG_SPECIFIC (method_type)->signature;
+ tree method =
+ lookup_java_constructor (CLASS_TO_HANDLE_TYPE (self_type),
+ method_signature);
+ tree block, compound;
+
+ /* Fixe the begining/ending lines of the method so that with
+ no_line_numbers set to 1 it doesn't generate debug info at
+ line 1 for this artificial constructor. */
+ DECL_SOURCE_LINE (mdecl) = 1;
+ DECL_SOURCE_LINE_MERGE (mdecl, 1);
+ source_start_java_method (mdecl);
+ arg_list = BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl));
+ enter_block ();
+ func = build_known_method_ref (method, method_type, self_type,
+ method_signature, arg_list);
+
+ if (! flag_emit_class_files)
+ func = build1 (NOP_EXPR, build_pointer_type (method_type), func);
+ call = build (CALL_EXPR, TREE_TYPE (method_type), func,
+ build_tree_list (NULL_TREE, arg_list), NULL_TREE);
+ TREE_SIDE_EFFECTS (call) = 1;
+ call = build_class_init (self_type, call);
+ compound = java_method_add_stmt (mdecl, call);
+ block = exit_block ();
+ BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) = block;
+ /* The function decl, its block and the compound statement
+ within this block are all of void type. */
+ TREE_TYPE (block) = TREE_TYPE (compound) =
+ TREE_TYPE (DECL_FUNCTION_BODY (mdecl)) = void_type_node;
+ exit_block ();
+ no_ac_found = 0;
+ }
+
+ if (DECL_FUNCTION_BODY (mdecl))
+ {
+ expand_start_java_method (mdecl);
+
+ current_this
+ = (!METHOD_STATIC (mdecl) ?
+ BLOCK_EXPR_DECLS (DECL_FUNCTION_BODY (mdecl)) : NULL_TREE);
+
+ if (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)) && no_ac_found)
+ java_complete_tree (BLOCK_EXPR_BODY (DECL_FUNCTION_BODY (mdecl)));
+ /* Don't go any further if we've found error(s) during the
+ expansion */
+ if (!java_error_count)
+ source_end_java_method ();
+ }
+}
+
+/* Expand finals. */
+
+void
+java_expand_finals ()
+{
+}
+
+/* Wrap non WFL PRIMARY around a WFL and set EXPR_WFL_QUALIFICATION to
+ a tree list node containing RIGHT. Fore coming RIGHTs will be
+ chained to this hook. LOCATION contains the location of the
+ separating `.' operator. */
+
+static tree
+make_qualified_primary (primary, right, location)
+ tree primary, right;
+ int location;
+{
+ tree wfl;
+
+ /* We want to process THIS . xxx symbolicaly, to keep it consistent
+ with the way we're processing SUPER. A THIS from a primary as a
+ different form than a SUPER. Turn THIS into something symbolic */
+ if (TREE_CODE (primary) == JAVA_THIS_EXPR)
+ {
+ wfl = build_wfl_node (this_identifier_node, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary);
+ wfl = make_qualified_name (wfl, right, location);
+ PRIMARY_P (wfl) = 1;
+ return wfl;
+ }
+ /* Other non WFL node are wrapped around a WFL */
+ else if (TREE_CODE (primary) != EXPR_WITH_FILE_LOCATION)
+ {
+ wfl = build_expr_wfl (NULL_TREE, ctxp->filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (primary);
+ EXPR_WFL_QUALIFICATION (wfl) = build_tree_list (primary, NULL_TREE);
+ }
+ else
+ {
+ wfl = primary;
+ if (!EXPR_WFL_QUALIFICATION (primary))
+ EXPR_WFL_QUALIFICATION (primary) =
+ build_tree_list (primary, NULL_TREE);
+ }
+
+ EXPR_WFL_LINECOL (right) = location;
+ chainon (EXPR_WFL_QUALIFICATION (wfl), build_tree_list (right, NULL_TREE));
+ PRIMARY_P (wfl) = 1;
+ return wfl;
+}
+
+/* Simple merge of two name separated by a `.' */
+
+static tree
+merge_qualified_name (left, right)
+ tree left, right;
+{
+ tree node;
+ obstack_grow (&temporary_obstack, IDENTIFIER_POINTER (left),
+ IDENTIFIER_LENGTH (left));
+ obstack_1grow (&temporary_obstack, '.');
+ obstack_grow0 (&temporary_obstack, IDENTIFIER_POINTER (right),
+ IDENTIFIER_LENGTH (right));
+ node = get_identifier (obstack_base (&temporary_obstack));
+ obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
+ QUALIFIED_P (node) = 1;
+ return node;
+}
+
+/* Merge the two parts of a qualified name into LEFT. Set the
+ location information of the resulting node to LOCATION, usually
+ inherited from the location information of the `.' operator. */
+
+static tree
+make_qualified_name (left, right, location)
+ tree left, right;
+ int location;
+{
+ int qualified;
+ tree left_id = EXPR_WFL_NODE (left);
+ tree right_id = EXPR_WFL_NODE (right);
+ tree wfl, merge;
+
+ merge = merge_qualified_name (left_id, right_id);
+
+ /* Left wasn't qualified and is now qualified */
+ if (!QUALIFIED_P (left_id))
+ {
+ tree wfl = build_expr_wfl (left_id, ctxp->filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = EXPR_WFL_LINECOL (left);
+ EXPR_WFL_QUALIFICATION (left) = build_tree_list (wfl, NULL_TREE);
+ }
+
+ wfl = build_expr_wfl (right_id, ctxp->filename, 0, 0);
+ EXPR_WFL_LINECOL (wfl) = location;
+ chainon (EXPR_WFL_QUALIFICATION (left), build_tree_list (wfl, NULL_TREE));
+
+ EXPR_WFL_NODE (left) = merge;
+ return left;
+}
+
+/* Extract the last identifier component of the qualified in WFL. The
+ last identifier is removed from the linked list */
+
+static tree
+cut_identifier_in_qualified (wfl)
+ tree wfl;
+{
+ tree q;
+ tree previous = NULL_TREE;
+ for (q = EXPR_WFL_QUALIFICATION (wfl); ; previous = q, q = TREE_CHAIN (q))
+ if (!TREE_CHAIN (q))
+ {
+ if (!previous)
+ fatal ("Operating on a non qualified qualified WFL - "
+ "cut_identifier_in_qualified");
+ TREE_CHAIN (previous) = NULL_TREE;
+ return TREE_PURPOSE (q);
+ }
+}
+
+/* Resolve the expression name NAME. Return its decl. */
+
+static tree
+resolve_expression_name (id)
+ tree id;
+{
+ tree name = EXPR_WFL_NODE (id);
+ tree decl;
+
+ /* 6.5.5.1: Simple expression names */
+ if (!PRIMARY_P (id) && !QUALIFIED_P (name))
+ {
+ /* 15.13.1: NAME can appear within the scope of a local variable
+ declaration */
+ if ((decl = IDENTIFIER_LOCAL_VALUE (name)))
+ return decl;
+
+ /* 15.13.1: NAME can appear within a class declaration */
+ else
+ {
+ decl = lookup_field_wrapper (current_class, name);
+ if (decl)
+ {
+ int fs = FIELD_STATIC (decl);
+ /* Instance variable (8.3.1.1) can't appear within
+ static method, static initializer or initializer for
+ a static variable. */
+ if (!fs && METHOD_STATIC (current_function_decl))
+ {
+ parse_error_context
+ (id, "Can't make a static reference to nonstatic variable "
+ "`%s' in class `%s'",
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (DECL_NAME
+ (TYPE_NAME (current_class))));
+ return error_mark_node;
+ }
+ decl = build_field_ref ((fs ? NULL_TREE : current_this),
+ current_class, name);
+ return (fs ? build_class_init (current_class, decl) : decl);
+ }
+ /* Fall down to error report on undefined variable */
+ }
+ }
+ /* 6.5.5.2 Qualified Expression Names */
+ else
+ {
+ qualify_ambiguous_name (id);
+ /* 15.10.1 Field Access Using a Primary and/or Expression Name */
+ /* 15.10.2: Accessing Superclass Members using super */
+ return resolve_field_access (id, NULL, NULL);
+ }
+
+ /* We've got an error here */
+ parse_error_context (id, "Undefined variable `%s'",
+ IDENTIFIER_POINTER (name));
+
+ return error_mark_node;
+}
+
+/* 15.10.1 Field Acess Using a Primary and/or Expression Name.
+ We return something suitable to generate the field access. We also
+ return the field decl in FIELD_DECL and its type in FIELD_TYPE. If
+ recipient's address can be null. */
+
+static tree
+resolve_field_access (qual_wfl, field_decl, field_type)
+ tree qual_wfl;
+ tree *field_decl, *field_type;
+{
+ int is_static = 0;
+ tree field_ref;
+ tree decl, where_found, type_found;
+
+ if (resolve_qualified_expression_name (qual_wfl, &decl,
+ &where_found, &type_found))
+ return error_mark_node;
+
+ /* Resolve the LENGTH field of an array here */
+ if (DECL_NAME (decl) == length_identifier_node && TYPE_ARRAY_P (type_found)
+ && ! flag_emit_class_files)
+ {
+ tree length = build_java_array_length_access (where_found);
+ field_ref =
+ build_java_arraynull_check (type_found, length, int_type_node);
+ }
+ /* We might have been trying to resolve field.method(). In which
+ case, the resolution is over and decl is the answer */
+ else if (DECL_P (decl) && IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) == decl)
+ field_ref = decl;
+ else if (DECL_P (decl))
+ {
+ is_static = DECL_P (decl) && FIELD_STATIC (decl);
+ field_ref = build_field_ref ((is_static ? NULL_TREE : where_found),
+ type_found, DECL_NAME (decl));
+ if (field_ref == error_mark_node)
+ return error_mark_node;
+ if (is_static)
+ {
+ field_ref = build_class_init (type_found, field_ref);
+ /* If the static field was identified by an expression that
+ needs to be generated, make the field access a compound
+ expression whose first part of the evaluation of the
+ field selector part. */
+ if (where_found && TREE_CODE (where_found) != TYPE_DECL)
+ {
+ tree type = QUAL_DECL_TYPE (field_ref);
+ field_ref = build (COMPOUND_EXPR, type, where_found, field_ref);
+ }
+ }
+ }
+ else
+ field_ref = decl;
+
+ if (field_decl)
+ *field_decl = decl;
+ if (field_type)
+ *field_type = QUAL_DECL_TYPE (decl);
+ return field_ref;
+}
+
+/* 6.5.5.2: Qualified Expression Names */
+
+static int
+resolve_qualified_expression_name (wfl, found_decl, where_found, type_found)
+ tree wfl;
+ tree *found_decl, *type_found, *where_found;
+{
+ int from_type = 0; /* Field search initiated from a type */
+ int from_super = 0, from_cast = 0;
+ int previous_call_static = 0;
+ int is_static;
+ tree decl = NULL_TREE, type = NULL_TREE, q;
+ *where_found = NULL_TREE;
+
+ for (q = EXPR_WFL_QUALIFICATION (wfl); q; q = TREE_CHAIN (q))
+ {
+ tree qual_wfl = QUAL_WFL (q);
+
+ /* 15.10.1 Field Access Using a Primary */
+
+ switch (TREE_CODE (qual_wfl))
+ {
+ case CALL_EXPR:
+ case JAVA_NEW_CLASS_EXPR:
+ /* If the access to the function call is a non static field,
+ build the code to access it. */
+ if (DECL_P (decl) && !FIELD_STATIC (decl))
+ {
+ decl = maybe_access_field (decl, *where_found, type);
+ if (decl == error_mark_node)
+ return 1;
+ }
+ /* And code for the function call */
+ if (complete_function_arguments (qual_wfl))
+ return 1;
+ *where_found =
+ patch_method_invocation_stmt (qual_wfl, decl, type, &is_static);
+ if (*where_found == error_mark_node)
+ return 1;
+ *type_found = type = QUAL_DECL_TYPE (*where_found);
+
+ /* If the previous call was static and this one is too,
+ build a compound expression to hold the two (because in
+ that case, previous function calls aren't transported as
+ forcoming function's argument. */
+ if (previous_call_static && is_static)
+ {
+ decl = build (COMPOUND_EXPR, type, decl, *where_found);
+ TREE_SIDE_EFFECTS (decl) = 1;
+ }
+ else
+ {
+ previous_call_static = is_static;
+ decl = *where_found;
+ }
+ continue;
+
+ case CONVERT_EXPR:
+ *where_found = decl = java_complete_tree (qual_wfl);
+ if (decl == error_mark_node)
+ return 1;
+ *type_found = type = QUAL_DECL_TYPE (decl);
+ from_cast = 1;
+ continue;
+
+ case ARRAY_REF:
+ /* If the access to the function call is a non static field,
+ build the code to access it. */
+ if (DECL_P (decl) && !FIELD_STATIC (decl))
+ {
+ decl = maybe_access_field (decl, *where_found, type);
+ if (decl == error_mark_node)
+ return 1;
+ }
+ /* And code for the array reference expression */
+ decl = java_complete_tree (qual_wfl);
+ if (decl == error_mark_node)
+ return 1;
+ type = QUAL_DECL_TYPE (decl);
+ continue;
+ }
+
+ /* If we fall here, we weren't processing a (static) function call. */
+ previous_call_static = 0;
+
+ /* It can be the keyword THIS */
+ if (EXPR_WFL_NODE (qual_wfl) == this_identifier_node)
+ {
+ if (!current_this)
+ {
+ parse_error_context
+ (wfl, "Keyword `this' used outside allowed context");
+ return 1;
+ }
+ /* We have to generate code for intermediate acess */
+ *where_found = decl = current_this;
+ type = QUAL_DECL_TYPE (decl);
+ continue;
+ }
+
+ /* 15.10.2 Accessing Superclass Members using SUPER */
+ if (EXPR_WFL_NODE (qual_wfl) == super_identifier_node)
+ {
+ tree node;
+ /* Check on the restricted use of SUPER */
+ if (METHOD_STATIC (current_function_decl)
+ || current_class == object_type_node)
+ {
+ parse_error_context
+ (wfl, "Keyword `super' used outside allowed context");
+ return 1;
+ }
+ /* Otherwise, treat SUPER as (SUPER_CLASS)THIS */
+ node = build_cast (EXPR_WFL_LINECOL (qual_wfl),
+ CLASSTYPE_SUPER (current_class),
+ build_this (EXPR_WFL_LINECOL (qual_wfl)));
+ *where_found = decl = java_complete_tree (node);
+ *type_found = type = QUAL_DECL_TYPE (decl);
+ from_super = from_type = 1;
+ continue;
+ }
+
+ /* 15.13.1: Can't search for field name in packages, so we
+ assume a variable/class name was meant. */
+ if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
+ {
+ if (from_super || from_cast)
+ parse_error_context
+ ((from_cast ? qual_wfl : wfl),
+ "No variable `%s' defined in class `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
+ lang_printable_name (type));
+ else
+ parse_error_context
+ (qual_wfl, "Undefined variable or class name: `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)));
+ return 1;
+ }
+
+ /* We have a type name. It's been already resolved when the
+ expression was qualified. */
+ else if (RESOLVE_TYPE_NAME_P (qual_wfl))
+ {
+ if (!(decl = QUAL_RESOLUTION (q)))
+ return 1; /* Error reported already */
+
+ if (not_accessible_p (TREE_TYPE (decl), decl, 0))
+ {
+ parse_error_context
+ (qual_wfl, "Can't access %s field `%s.%s' from `%s'",
+ java_accstring_lookup (get_access_flags_from_decl (decl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))),
+ IDENTIFIER_POINTER (DECL_NAME (decl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
+ return 1;
+ }
+
+ type = TREE_TYPE (decl);
+ from_type = 1;
+ }
+ /* We resolve and expression name */
+ else
+ {
+ tree field_decl;
+
+ /* If there exists an early resolution, use it. That occurs
+ only once and we know that there are more things to
+ come. Don't do that when processing something after SUPER
+ (we need more thing to be put in place below */
+ if (!from_super && QUAL_RESOLUTION (q))
+ decl = QUAL_RESOLUTION (q);
+
+ /* We have to search for a field, knowing the type of its
+ container. The flag FROM_TYPE indicates that we resolved
+ the last member of the expression as a type name, which
+ means that for the resolution of this field, will check
+ on other errors than if the it was resolved as a member
+ of an other field. */
+ else
+ {
+ int is_static;
+ if (!from_type && !JREFERENCE_TYPE_P (type))
+ {
+ parse_error_context
+ (qual_wfl, "Attempt to reference field `%s' in `%s %s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
+ lang_printable_name (type),
+ IDENTIFIER_POINTER (DECL_NAME (field_decl)));
+ return 1;
+ }
+
+ if (!(field_decl =
+ lookup_field_wrapper (type, EXPR_WFL_NODE (qual_wfl))))
+ {
+ parse_error_context
+ (qual_wfl, "No variable `%s' defined in class `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
+ return 1;
+ }
+
+ /* Check on accessibility here */
+ if (not_accessible_p (type, field_decl, from_super))
+ {
+ parse_error_context
+ (qual_wfl,
+ "Can't access %s field `%s.%s' from `%s'",
+ java_accstring_lookup
+ (get_access_flags_from_decl (field_decl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))),
+ IDENTIFIER_POINTER (DECL_NAME (field_decl)),
+ IDENTIFIER_POINTER
+ (DECL_NAME (TYPE_NAME (current_class))));
+ return 1;
+ }
+
+ /* There are things to check when fields are accessed
+ from type. There are no restrictions on a static
+ declaration of the field when it is accessed from an
+ interface */
+ is_static = FIELD_STATIC (field_decl);
+ if (!from_super && from_type
+ && !TYPE_INTERFACE_P (type) && !is_static)
+ {
+ parse_error_context
+ (qual_wfl, "Can't make a static reference to nonstatic "
+ "variable `%s' in class `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (qual_wfl)),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
+ return 1;
+ }
+ from_cast = from_super = 0;
+
+ /* If we need to generate something to get a proper handle
+ on what this field is accessed from, do it now. */
+ if (!is_static)
+ {
+ decl = maybe_access_field (decl, *where_found, type);
+ if (decl == error_mark_node)
+ return 1;
+ }
+
+ /* We want to keep the location were found it, and the type
+ we found. */
+ *where_found = decl;
+ *type_found = type;
+
+ /* This is the decl found and eventually the next one to
+ search from */
+ decl = field_decl;
+ }
+
+ from_type = 0;
+ type = QUAL_DECL_TYPE (decl);
+ }
+ }
+ *found_decl = decl;
+ return 0;
+}
+
+/* 6.6 Qualified name and access control. Returns 1 if MEMBER (a decl)
+ can't be accessed from REFERENCE (a record type). */
+
+int not_accessible_p (reference, member, from_super)
+ tree reference, member;
+ int from_super;
+{
+ int access_flag = get_access_flags_from_decl (member);
+
+ /* Access always granted for members declared public */
+ if (access_flag & ACC_PUBLIC)
+ return 0;
+
+ /* Check access on protected members */
+ if (access_flag & ACC_PROTECTED)
+ {
+ /* Access granted if it occurs from within the package
+ containing the class in which the protected member is
+ declared */
+ if (class_in_current_package (DECL_CONTEXT (member)))
+ return 0;
+
+ if (TREE_CODE (member) == FUNCTION_DECL && DECL_CONSTRUCTOR_P (member))
+ {
+ /* Access from SUPER is granted */
+ if (from_super)
+ return 0;
+ /* Otherwise, access isn't granted */
+ return 1;
+ }
+ else
+ {
+ /* If accessed with the form `super.member', then access is
+ granted */
+ if (from_super)
+ return 0;
+
+ /* Otherwise, access is granted if occuring from the class where
+ member is declared or a subclass of it */
+ if (inherits_from_p (reference, current_class))
+ return 0;
+ }
+ return 1;
+ }
+
+ /* Check access on private members. Access is granted only if it
+ occurs from within the class in witch it is declared*/
+
+ if (access_flag & ACC_PRIVATE)
+ return (current_class == DECL_CONTEXT (member) ? 0 : 1);
+
+ /* Default access are permitted only when occuring within the
+ package in which the type (REFERENCE) is declared. In other words,
+ REFERENCE is defined in the current package */
+ if (ctxp->package)
+ return !class_in_current_package (reference);
+
+ /* Otherwise, access is granted */
+ return 0;
+}
+
+/* Returns 1 if class was declared in the current package, 0 otherwise */
+
+static int
+class_in_current_package (class)
+ tree class;
+{
+ static tree cache = NULL_TREE;
+ int qualified_flag;
+ tree left;
+
+ if (cache == class)
+ return 1;
+
+ qualified_flag = QUALIFIED_P (DECL_NAME (TYPE_NAME (class)));
+
+ /* If the current package is empty and the name of CLASS is
+ qualified, class isn't in the current package. If there is a
+ current package and the name of the CLASS is not qualified, class
+ isn't in the current package */
+ if (!ctxp->package && qualified_flag || ctxp->package && !qualified_flag)
+ return 0;
+
+ /* If there is not package and the name of CLASS isn't qualified,
+ they belong to the same unnamed package */
+ if (!ctxp->package && !qualified_flag)
+ return 1;
+
+ /* Compare the left part of the name of CLASS with the package name */
+ breakdown_qualified (&left, NULL, DECL_NAME (TYPE_NAME (class)));
+ if (ctxp->package == left)
+ {
+ cache = class;
+ return 1;
+ }
+ return 0;
+}
+
+/* This function may generate code to access DECL from WHERE. This is
+ done only if certain conditions meet. */
+
+static tree
+maybe_access_field (decl, where, type)
+ tree decl, where, type;
+{
+ if (DECL_P (decl) && decl != current_this
+ && (!(TREE_CODE (decl) != PARM_DECL
+ && FIELD_STATIC (decl)))
+ && !IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)))
+ decl = build_field_ref (where ? where : current_this,
+ type, DECL_NAME (decl));
+ return decl;
+}
+
+/* Build a method invocation statement, by patching PATCH. If non NULL
+ and according to the situation, PRIMARY and WHERE may be
+ used. IS_STATIC is set to 1 if the invoked function is static. */
+
+static tree
+patch_method_invocation_stmt (patch, primary, where, is_static)
+ tree patch, primary, where;
+ int *is_static;
+{
+ tree wfl = TREE_OPERAND (patch, 0);
+ tree args = TREE_OPERAND (patch, 1);
+ tree name = EXPR_WFL_NODE (wfl);
+ tree list, class_type;
+
+ /* Should be overriden if everything goes well. Otherwise, if
+ something fails, it should keep this value. It stop the
+ evaluation of a bogus assignment. See java_complete_tree,
+ MODIFY_EXPR: for the reasons why we sometimes want to keep on
+ evaluating an assignment */
+ TREE_TYPE (patch) = error_mark_node;
+
+ /* Since lookup functions are messing with line numbers, save the
+ context now. */
+ java_parser_context_save_global ();
+
+ /* 15.11.1: Compile-Time Step 1: Determine Class or Interface to Search */
+
+ /* Resolution of qualified name, excluding constructors */
+ if (QUALIFIED_P (name) && !CALL_CONSTRUCTOR_P (patch))
+ {
+ tree class_decl, identifier, identifier_wfl;
+ /* Extract the last IDENTIFIER of the qualified
+ expression. This is a wfl and we will use it's location
+ data during error report. */
+ identifier_wfl = cut_identifier_in_qualified (wfl);
+ identifier = EXPR_WFL_NODE (identifier_wfl);
+
+ /* Given the context, IDENTIFIER is syntactically qualified
+ as a MethodName. We need to qualify what's before */
+ qualify_ambiguous_name (wfl);
+
+ /* Package resolution are erroneous */
+ if (RESOLVE_PACKAGE_NAME_P (wfl))
+ {
+ tree remainder;
+ breakdown_qualified (&remainder, NULL, EXPR_WFL_NODE (wfl));
+ parse_error_context (wfl, "Can't search method `%s' in package "
+ "`%s'",IDENTIFIER_POINTER (identifier),
+ IDENTIFIER_POINTER (remainder));
+ return error_mark_node;
+ }
+ /* We're resolving a call from a type */
+ else if (RESOLVE_TYPE_NAME_P (wfl))
+ {
+ tree decl = QUAL_RESOLUTION (EXPR_WFL_QUALIFICATION (wfl));
+ tree name = DECL_NAME (decl);
+ tree type;
+
+ class_decl = resolve_and_layout (name, wfl);
+ if (CLASS_INTERFACE (decl))
+ {
+ parse_error_context
+ (identifier_wfl, "Can't make static reference to method "
+ "`%s' in interface `%s'", IDENTIFIER_POINTER (identifier),
+ IDENTIFIER_POINTER (name));
+ return error_mark_node;
+ }
+ /* Look the method up in the type selector. The method ought
+ to be static. */
+ type = TREE_TYPE (class_decl);
+ list = lookup_method_invoke (0, wfl, type, identifier, args);
+ if (list && !METHOD_STATIC (list))
+ {
+ char *fct_name = strdup ((char *)lang_printable_name (list));
+ parse_error_context
+ (identifier_wfl,
+ "Can't make static reference to method `%s %s' in class `%s'",
+ lang_printable_name (TREE_TYPE (TREE_TYPE (list))), fct_name,
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
+ free (fct_name);
+ return error_mark_node;
+ }
+ }
+ /* We're resolving an expression name */
+ else
+ {
+ tree field, type;
+
+ /* 1- Find the field to which the call applies */
+ field = resolve_field_access (wfl, NULL, &type);
+ if (field == error_mark_node)
+ return error_mark_node;
+
+ /* 2- Do the layout of the class where the last field
+ was found, so we can search it. */
+ class_decl =
+ resolve_and_layout (DECL_NAME (TYPE_NAME (type)), NULL_TREE);
+
+ /* 3- Retrieve a filtered list of method matches, Refine
+ if necessary. In any cases, point out errors. */
+ list = lookup_method_invoke (0, identifier_wfl, type,
+ identifier, args);
+
+ /* 4- Add the field as an argument */
+ args = tree_cons (NULL_TREE, field, args);
+ }
+
+ /* CLASS_TYPE is used during the call to not_accessible_p and
+ IDENTIFIER_WFL will be used to report any problem further */
+ class_type = TREE_TYPE (class_decl);
+ wfl = identifier_wfl;
+ }
+ /* Resolution of simple names, names generated after a primary: or
+ constructors */
+ else
+ {
+ tree class_to_search;
+ int lc; /* Looking for Constructor */
+
+ /* We search constructor in their target class */
+ if (CALL_CONSTRUCTOR_P (patch))
+ {
+ class_to_search = resolve_no_layout (EXPR_WFL_NODE (wfl), NULL_TREE);
+ if (!class_to_search)
+ {
+ parse_error_context
+ (wfl, "Class `%s' not found in type declaration",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
+ return error_mark_node;
+ }
+
+ /* Can't instantiate an abstract class */
+ if (CLASS_ABSTRACT (class_to_search))
+ {
+ parse_error_context
+ (wfl, "Class `%s' is an abstract class. It can't be "
+ "instantiated", IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl)));
+ return error_mark_node;
+ }
+ class_to_search = TREE_TYPE (class_to_search);
+ lc = 1;
+ }
+ /* This is a regular search in the local class, unless an
+ alternate class is specified. */
+ else
+ {
+ class_to_search = (where ? where : current_class);
+ lc = 0;
+ }
+
+ /* NAME is a simple identifier or comes from a primary. Search
+ in the class whose declaration contain the method being
+ invoked. */
+ list = lookup_method_invoke (lc, wfl, class_to_search, name, args);
+
+ /* Don't continue if no method were found, as the next statement
+ can't be executed then. */
+ if (!list) return error_mark_node;
+
+ /* Check for static reference if non static methods */
+ if (check_for_static_method_reference (wfl, patch, list,
+ class_to_search, primary))
+ return error_mark_node;
+
+ /* Non static/constructor methods are called with the current
+ object extra argument. If method is resolved as a primary,
+ use the primary otherwise use the current THIS. */
+ if (!CALL_CONSTRUCTOR_P (patch) && !METHOD_STATIC (list))
+ args = tree_cons (NULL_TREE, primary ? primary : current_this, args);
+
+ class_type = class_to_search;
+ }
+
+ /* Merge point of all resolution schemes. If we have nothing, this
+ is an error, already signaled */
+ if (!list) return error_mark_node;
+
+ /* Check accessibility, position the is_static flag, build and
+ return the call */
+ if (not_accessible_p (class_type, list, 0))
+ {
+ char *fct_name = strdup ((char *)lang_printable_name (list));
+ parse_error_context
+ (wfl, "Can't access %s method `%s %s.%s' from `%s'",
+ java_accstring_lookup (get_access_flags_from_decl (list)),
+ lang_printable_name (TREE_TYPE (TREE_TYPE (list))),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class_type))), fct_name,
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class))));
+ free (fct_name);
+ return error_mark_node;
+ }
+
+ if (is_static)
+ *is_static = METHOD_STATIC (list);
+ java_parser_context_restore_global ();
+ return patch_invoke (patch, list, args, wfl);
+}
+
+/* Check that we're not trying to do a static reference to a method in
+ non static method. Return 1 if it's the case, 0 otherwise. */
+
+static int
+check_for_static_method_reference (wfl, node, method, where, primary)
+ tree wfl, node, method, where, primary;
+{
+ if (METHOD_STATIC (current_function_decl)
+ && !METHOD_STATIC (method) && !primary && !CALL_CONSTRUCTOR_P (node))
+ {
+ char *fct_name = strdup ((char *)lang_printable_name (method));
+ parse_error_context
+ (wfl, "Can't make static reference to method `%s %s' in class `%s'",
+ lang_printable_name (TREE_TYPE (TREE_TYPE (method))), fct_name,
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (where))));
+ free (fct_name);
+ return 1;
+ }
+ return 0;
+}
+
+/* Patch an invoke expression METHOD and ARGS, based on its invocation
+ mode. */
+
+static tree
+patch_invoke (patch, method, args, cl)
+ tree patch, method, args;
+ tree cl;
+{
+ tree dtable, func;
+ tree signature = build_java_signature (TREE_TYPE (method));
+ tree original_call;
+
+ switch (invocation_mode (method, 0))
+ {
+ case INVOKE_VIRTUAL:
+ dtable = invoke_build_dtable (0, args);
+ func = build_invokevirtual (dtable, method);
+ break;
+ case INVOKE_STATIC:
+ func = build_known_method_ref (method, TREE_TYPE (method),
+ DECL_CONTEXT (method),
+ signature, args);
+ args = nreverse (args);
+ break;
+
+ default:
+ fatal ("Unknown invocation mode - build_invoke");
+ return NULL_TREE;
+ }
+
+
+ /* Ensure self_type is initialized, (invokestatic). FIXME */
+ func = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (method)), func);
+ TREE_TYPE (patch) = TREE_TYPE (TREE_TYPE (method));
+ TREE_OPERAND (patch, 0) = func;
+ TREE_OPERAND (patch, 1) = args;
+ original_call = patch;
+
+ /* We're calling a constructor. New is called an its returned value
+ is an argument to the constructor. We build a COMPOUND_EXPR and
+ use saved expression so that the overall NEW expression value is
+ a pointer to a newly created and initialized class. */
+ if (CALL_CONSTRUCTOR_P (original_call))
+ {
+ tree class = DECL_CONTEXT (method);
+ tree c1, saved_new, size, new;
+ if (!TYPE_SIZE (class))
+ safe_layout_class (class);
+ size = size_in_bytes (class);
+ new = build (CALL_EXPR, promote_type (class),
+ build_address_of (alloc_object_node),
+ tree_cons (NULL_TREE, build_class_ref (class),
+ build_tree_list (NULL_TREE,
+ size_in_bytes (class))),
+ NULL_TREE);
+ saved_new = save_expr (new);
+ c1 = build_tree_list (NULL_TREE, saved_new);
+ TREE_CHAIN (c1) = TREE_OPERAND (original_call, 1);
+ TREE_OPERAND (original_call, 1) = c1;
+ TREE_SET_CODE (original_call, CALL_EXPR);
+ patch = build (COMPOUND_EXPR, TREE_TYPE (new), patch, saved_new);
+ }
+ return patch;
+}
+
+static int
+invocation_mode (method, super)
+ tree method;
+ int super;
+{
+ int access = get_access_flags_from_decl (method);
+
+ if (access & ACC_STATIC)
+ return INVOKE_STATIC;
+
+ if (CLASS_FINAL (TYPE_NAME (DECL_CONTEXT (method))))
+ return INVOKE_STATIC;
+
+ if (super)
+ return INVOKE_SUPER;
+
+ if (CLASS_INTERFACE (TYPE_NAME (DECL_CONTEXT (method))))
+ return INVOKE_INTERFACE;
+
+ if (DECL_CONSTRUCTOR_P (method))
+ return INVOKE_STATIC;
+
+ return INVOKE_VIRTUAL;
+}
+
+/* Retrieve a refined list of matching methods. */
+
+static tree
+lookup_method_invoke (lc, cl, class, name, arg_list)
+ int lc;
+ tree cl;
+ tree class, name, arg_list;
+{
+ tree method = make_node (FUNCTION_TYPE);
+ tree arg_type_list = NULL_TREE;
+ tree signature, list, node, scratch;
+
+ for (node = arg_list; node; node = TREE_CHAIN (node))
+ {
+ tree current_arg;
+ current_arg =
+ build_tree_list (NULL_TREE,
+ promote_type (TREE_TYPE (TREE_VALUE (node))));
+ arg_type_list = chainon (current_arg, arg_type_list);
+ }
+ TYPE_ARG_TYPES (method) = arg_type_list;
+
+ if (!lc)
+ {
+ signature = build_java_argument_signature (method);
+ list = match_java_method (class, name, signature);
+ list = refine_accessible_methods_list (lc, list);
+ }
+ else
+ {
+ TREE_TYPE (method) = void_type_node;
+ signature = build_java_signature (method);
+ list = lookup_java_constructor (class, signature);
+ }
+
+ if (!list)
+ {
+ parse_error_context (cl, "Can't find method `%s(%s)' in class `%s'",
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (signature),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class))));
+ return NULL_TREE;
+ }
+
+ if (lc)
+ return list;
+
+ if (TREE_CHAIN (list))
+ {
+ tree most_specific_list = NULL_TREE;
+ tree current;
+ /* 15.11.2.2 Choose the Most Specific Method */
+ for (current = list; current; current = TREE_CHAIN (current))
+ {
+ tree rest;
+ tree method = TREE_VALUE (list);
+ tree class_from = DECL_CONTEXT (method);
+ for (rest = TREE_CHAIN (current); rest; rest = TREE_CHAIN (rest))
+ {
+ tree other = TREE_VALUE (rest);
+
+ /* METHOD can be declared more specific with regard to OTHER iif:
+
+ - The class METHOD belongs can be converted to the
+ class OTHER belongs by method invocation conversion
+ (5.3). Since we're dealing with classes here, it is
+ covered by the identity conversion or the windening
+ primitive conversion.
+
+ - The types of the arguments of METHOD can be
+ converted to the types of the arguments of OTHER by
+ method invocation conversion (5.3). */
+
+ if (valid_ref_assignconv_cast_p (class_from,
+ DECL_CONTEXT (other), 0)
+ && 1) /* Test on args non implemented */
+ most_specific_list = tree_cons (NULL_TREE, method,
+ most_specific_list);
+ }
+ }
+ list = most_specific_list;
+ }
+
+ if (!list || TREE_CHAIN (list))
+ {
+ parse_error_context (cl, "Can't find method `%s(%s)' in class `%s'",
+ IDENTIFIER_POINTER (name),
+ IDENTIFIER_POINTER (signature),
+ IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (class))));
+ return NULL_TREE;
+ }
+
+ /* 15.11.3 Is the Chosen Method Appropriate ? */
+ else
+ return TREE_VALUE (list);
+}
+
+/* Refine accessible methods from the raw matching method list, as
+ specified in 15.11.4.3. Return a (possibly empty) new method
+ list. */
+
+static tree
+refine_accessible_methods_list (lc, list)
+ int lc; /* Looking for Constructor */
+ tree list;
+{
+#define ADD_TO_LIST_AND_CONTINUE \
+ { \
+ refined_list = tree_cons (NULL_TREE, method, refined_list); \
+ continue; \
+ }
+ tree node, refined_list = NULL_TREE;
+ tree current_class_name = DECL_NAME (TYPE_NAME (current_class));
+
+ for (node = list; node; node = TREE_CHAIN (node))
+ {
+ int access, identical;
+ tree class_from, method, class_from_name;
+
+ method = TREE_VALUE (node);
+
+ /* Constructor not retained here, unless were specifically
+ looking for them. */
+ if (lc && DECL_CONSTRUCTOR_P (method))
+ ADD_TO_LIST_AND_CONTINUE;
+
+ access = get_access_flags_from_decl (method);
+ class_from = DECL_CONTEXT (method);
+ class_from_name = DECL_NAME (TYPE_NAME (class_from));
+
+ identical = identical_subpath_p (current_class_name, class_from_name);
+
+ /* Check accessibility of class_from from the current one: This
+ test has been already carried out when qualify_ambiguous_name
+ tried to resolve a type found in an other package. It is not
+ necessary to retest things here, the error has been already
+ reported. */
+
+ /* Public method are always OK */
+ if (access & ACC_PUBLIC)
+ ADD_TO_LIST_AND_CONTINUE;
+
+ /* Protected method access is OK if classes are from the
+ same package or part of the same inheritance lineage */
+ if ((access & ACC_PROTECTED)
+ && (inherits_from_p (current_class, class_from) || identical))
+ ADD_TO_LIST_AND_CONTINUE;
+
+ /* Methods with default (package) access are OK if classes are
+ from the same default package. */
+ if (identical ||
+ (!QUALIFIED_P (class_from_name) && !QUALIFIED_P (current_class_name)))
+ ADD_TO_LIST_AND_CONTINUE;
+
+ /* Private method accessible iff current class is the node where
+ the method is defined */
+ if ((access & ACC_PRIVATE) && (class_from == current_class))
+ ADD_TO_LIST_AND_CONTINUE;
+ }
+#undef ADD_TO_LIST_AND_CONTINUE
+ return refined_list;
+}
+
+/* Qualification routines */
+
+static void
+qualify_ambiguous_name (id)
+ tree id;
+{
+ tree qual, qual_wfl, name, decl, ptr_type, saved_current_class;
+ int again, super_found = 0, this_found = 0;
+
+ /* We first qualify the first element, then derive qualification of
+ others based on the first one. If the first element is qualified
+ by a resolution (field or type), this resolution is stored in the
+ QUAL_RESOLUTION of the qual element being examined. We need to
+ save the current_class since the use of SUPER might change the
+ its value. */
+ saved_current_class = current_class;
+ qual = EXPR_WFL_QUALIFICATION (id);
+ do {
+
+ /* Simple qualified expression feature a qual_wfl that is a
+ WFL. Expression derived from a primary feature more complicated
+ things like a CALL_EXPR. Expression from primary need to be
+ worked out to extract the part on which the qualification will
+ take place. */
+ qual_wfl = QUAL_WFL (qual);
+ switch (TREE_CODE (qual_wfl))
+ {
+ case CALL_EXPR:
+ qual_wfl = TREE_OPERAND (qual_wfl, 0);
+ if (TREE_CODE (qual_wfl) != EXPR_WITH_FILE_LOCATION)
+ {
+ qual = EXPR_WFL_QUALIFICATION (qual_wfl);
+ qual_wfl = QUAL_WFL (qual);
+ }
+ break;
+ case JAVA_NEW_CLASS_EXPR:
+ case CONVERT_EXPR:
+ case ARRAY_REF:
+ qual_wfl = TREE_OPERAND (qual_wfl, 0);
+ break;
+ }
+ name = EXPR_WFL_NODE (qual_wfl);
+ ptr_type = current_class;
+ again = 0;
+ /* If we have a THIS (from a primary), we set the context accordingly */
+ if (name == this_identifier_node)
+ {
+ qual = TREE_CHAIN (qual);
+ qual_wfl = QUAL_WFL (qual);
+ name = EXPR_WFL_NODE (qual_wfl);
+ this_found = 1;
+ }
+ /* If we have a SUPER, we set the context accordingly */
+ if (name == super_identifier_node)
+ {
+ current_class = CLASSTYPE_SUPER (ptr_type);
+ /* Check that there is such a thing as a super class. If not,
+ return. The error will be caught later on, during the
+ resolution */
+ if (!current_class)
+ {
+ current_class = saved_current_class;
+ return;
+ }
+ qual = TREE_CHAIN (qual);
+ /* Do one more interation to set things up */
+ super_found = again = 1;
+ }
+ } while (again);
+
+ /* If name appears within the scope of a location variable
+ declaration or parameter declaration, then it is an expression
+ name. We don't carry this test out if we're in the context of the
+ use of SUPER or THIS */
+
+ if (!this_found && !super_found && (decl = IDENTIFIER_LOCAL_VALUE (name)))
+ {
+ RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+ QUAL_RESOLUTION (qual) = decl;
+ }
+
+ /* If within the class/interface NAME was found to be used there
+ exists a (possibly inherited) field named NAME, then this is an
+ expression name. */
+ else if ((decl = lookup_field_wrapper (ptr_type, name)))
+ {
+ RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+ QUAL_RESOLUTION (qual) = decl;
+ }
+
+ /* We reclassify NAME as a type name if:
+ - NAME is a class/interface declared within the compilation
+ unit containing NAME,
+ - NAME is imported via a single-type-import declaration,
+ - NAME is declared in an another compilation unit of the package
+ of the compilation unit containing NAME,
+ - NAME is declared by exactly on type-import-on-demand declaration
+ of the compilation unit containing NAME. */
+ else if ((decl = resolve_and_layout (name, NULL_TREE)))
+ {
+ RESOLVE_TYPE_NAME_P (qual_wfl) = 1;
+ QUAL_RESOLUTION (qual) = decl;
+ }
+
+ /* Method call are expression name */
+ else if (TREE_CODE (QUAL_WFL (qual)) == CALL_EXPR)
+ RESOLVE_EXPRESSION_NAME_P (qual_wfl) = 1;
+
+ /* Check here that NAME isn't declared by more than one
+ type-import-on-demand declaration of the compilation unit
+ containing NAME. FIXME */
+
+ /* Otherwise, NAME is reclassified as a package name */
+ else
+ RESOLVE_PACKAGE_NAME_P (qual_wfl) = 1;
+
+ /* Propagate the qualification accross other components of the
+ qualified name */
+ for (qual = TREE_CHAIN (qual); qual;
+ qual_wfl = QUAL_WFL (qual), qual = TREE_CHAIN (qual))
+ {
+ if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
+ RESOLVE_PACKAGE_NAME_P (QUAL_WFL (qual)) = 1;
+ else
+ RESOLVE_EXPRESSION_NAME_P (QUAL_WFL (qual)) = 1;
+ }
+
+ /* Store the global qualification for the ambiguous part of ID back
+ into ID fields */
+ if (RESOLVE_EXPRESSION_NAME_P (qual_wfl))
+ RESOLVE_EXPRESSION_NAME_P (id) = 1;
+ else if (RESOLVE_TYPE_NAME_P (qual_wfl))
+ RESOLVE_TYPE_NAME_P (id) = 1;
+ else if (RESOLVE_PACKAGE_NAME_P (qual_wfl))
+ RESOLVE_PACKAGE_NAME_P (id) = 1;
+
+ /* Restore the current class */
+ current_class = saved_current_class;
+}
+
+static int
+breakdown_qualified (left, right, source)
+ tree *left, *right, source;
+{
+ char *p = IDENTIFIER_POINTER (source), *base;
+ int l = IDENTIFIER_LENGTH (source);
+
+ /* Breakdown NAME into REMAINDER . IDENTIFIER */
+ base = p;
+ p += (l-1);
+ while (*p != '.' && p != base)
+ p--;
+
+ /* We didn't find a '.'. Return an error */
+ if (p == base)
+ return 1;
+
+ *p = '\0';
+ if (right)
+ *right = get_identifier (p+1);
+ *left = get_identifier (IDENTIFIER_POINTER (source));
+ *p = '.';
+
+ return 0;
+}
+
+/* Return 1 if N1 and N2 have identical sub-path. */
+
+static int
+identical_subpath_p (n1, n2)
+ tree n1, n2;
+{
+ tree left1, left2;
+
+ if (!QUALIFIED_P (n1) || !QUALIFIED_P (n2))
+ return n1 == n2;
+
+ breakdown_qualified (&left1, NULL, n1);
+ breakdown_qualified (&left2, NULL, n2);
+
+ return left1 == left2;
+}
+
+static int
+not_initialized_as_it_should_p (decl)
+ tree decl;
+{
+ if (DECL_P (decl))
+ {
+ if (TREE_CODE (decl) == FIELD_DECL
+ && METHOD_STATIC (current_function_decl))
+ return 0;
+ return DECL_P (decl) && !INITIALIZED_P (decl);
+ }
+ return 0;
+}
+
+/* Patch tree nodes in a function body. When a BLOCK is found, push
+ local variable decls if present. */
+
+static tree
+java_complete_tree (node)
+ tree node;
+{
+ tree nn, cn, wfl_op1, wfl_op2;
+ int flag, location;
+
+ /* CONVERT_EXPR always has its type set, even though it needs to be
+ worked out */
+ if (TREE_TYPE (node) && TREE_CODE (node) != CONVERT_EXPR)
+ return node;
+
+ /* The switch block implements cases processing container nodes
+ first. Contained nodes are always written back. Leaves come
+ next and return a value. */
+ switch (TREE_CODE (node))
+ {
+ case BLOCK:
+
+ /* 1- Block section.
+ Set the local values on decl names so we can identify them
+ faster when they're referenced. At that stage, identifiers
+ are legal so we don't check for declaration errors. */
+ for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
+ {
+ DECL_CONTEXT (cn) = current_function_decl;
+ IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = cn;
+ INITIALIZED_P (cn) = 0;
+ }
+ if (BLOCK_EXPR_BODY (node))
+ {
+ BLOCK_EXPR_BODY (node) = java_complete_tree (BLOCK_EXPR_BODY (node));
+ if (BLOCK_EXPR_BODY (node) == error_mark_node)
+ return error_mark_node;
+ }
+ /* Turn local bindings to null */
+ for (cn = BLOCK_EXPR_DECLS (node); cn; cn = TREE_CHAIN (cn))
+ IDENTIFIER_LOCAL_VALUE (DECL_NAME (cn)) = NULL_TREE;
+
+ TREE_TYPE (node) = void_type_node;
+ break;
+
+ /* 2- They are expressions but ultimately deal with statements */
+ case LABELED_BLOCK_EXPR:
+ PUSH_LABELED_BLOCK (node);
+ if (LABELED_BLOCK_BODY (node))
+ COMPLETE_CHECK_OP_1 (node);
+ TREE_TYPE (node) = void_type_node;
+ POP_LABELED_BLOCK ();
+ return node;
+
+ case EXIT_BLOCK_EXPR:
+ /* We don't complete operand 1, because it's the return value of
+ the EXIT_BLOCK_EXPR which doesn't exist it Java */
+ return patch_bc_statement (node);
+
+ case LOOP_EXPR:
+ PUSH_LOOP (node);
+ /* Check whether the loop was enclosed in a labeled
+ statement. If not, create one, insert the loop in it and
+ return the node */
+ nn = patch_loop_statement (node);
+ /* Anyways, walk the body of the loop */
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ TREE_TYPE (nn) = TREE_TYPE (node) = void_type_node;
+ /* If we returned something different, that's because we
+ inserted a label. Pop the label too. */
+ if (nn != node)
+ POP_LABELED_BLOCK ();
+ POP_LOOP ();
+ return nn;
+
+ case EXIT_EXPR:
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ return patch_exit_expr (node);
+
+ case COND_EXPR:
+ /* Condition */
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ /* then-else branches */
+ TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ TREE_OPERAND (node, 2) = java_complete_tree (TREE_OPERAND (node, 2));
+ if (TREE_OPERAND (node, 2) == error_mark_node)
+ return error_mark_node;
+ return patch_if_else_statement (node);
+ break;
+
+ /* 3- Expression section */
+ case COMPOUND_EXPR:
+ TREE_OPERAND (node, 0) = java_complete_tree (TREE_OPERAND (node, 0));
+ TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
+ break;
+
+ case RETURN_EXPR:
+ return patch_return (node);
+
+ case EXPR_WITH_FILE_LOCATION:
+ if (!EXPR_WFL_NODE (node) /* Or a PRIMARY flag ? */
+ || TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
+ return resolve_expression_name (node);
+ else
+ {
+ EXPR_WFL_NODE (node) = java_complete_tree (EXPR_WFL_NODE (node));
+ TREE_SIDE_EFFECTS (node) = 1;
+ if (EXPR_WFL_NODE (node) == error_mark_node)
+ {
+ /* Its important for the evaluation of assignment that
+ this mark on the TREE_TYPE is propagated. */
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+ else
+ TREE_TYPE (node) = TREE_TYPE (EXPR_WFL_NODE (node));
+ }
+ break;
+
+ case JAVA_NEW_ARRAY_EXPR:
+ /* Patch all the dimensions */
+ flag = 0;
+ for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
+ {
+ int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
+ tree dim = java_complete_tree (TREE_VALUE (cn));
+ if (dim == error_mark_node)
+ {
+ flag = 1;
+ continue;
+ }
+ else
+ {
+ TREE_VALUE (cn) = save_expr (dim);
+ /* Setup the location of the current dimension, for
+ later error report. */
+ TREE_PURPOSE (cn) =
+ build_expr_wfl (NULL_TREE, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (TREE_PURPOSE (cn)) = location;
+ }
+ }
+ /* They complete the array creation expression, if no errors
+ were found. */
+ return (flag ? error_mark_node : patch_newarray (node));
+
+ case JAVA_NEW_CLASS_EXPR:
+ case CALL_EXPR:
+ /* Complete function's argument first */
+ if (complete_function_arguments (node))
+ return error_mark_node;
+ else
+ return patch_method_invocation_stmt (node, NULL_TREE, NULL_TREE, NULL);
+
+ case MODIFY_EXPR:
+ /* Save potential wfls */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ wfl_op2 = TREE_OPERAND (node, 1);
+ TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+
+ if (COMPOUND_ASSIGN_P (wfl_op2))
+ {
+ tree lvalue;
+ tree other =
+ java_complete_tree (TREE_OPERAND (wfl_op2, 0));
+
+ /* Hand stablize the lhs on both places */
+ lvalue = stabilize_reference (other);
+ TREE_OPERAND (node, 0) = lvalue;
+ TREE_OPERAND (TREE_OPERAND (node, 1), 0) = lvalue;
+ }
+
+ /* There are cases where the type of RHS is fixed. In those
+ cases, if the evaluation of the RHS fails, we further the
+ evaluation of the assignment to detect more errors. */
+ nn = java_complete_tree (TREE_OPERAND (node, 1));
+ if (nn == error_mark_node)
+ {
+ /* It's hopeless, but we can further things on to discover
+ an error during the assignment. In any cases, the
+ assignment operation fails. */
+ if (TREE_CODE (TREE_OPERAND (node, 1)) != EXPR_WITH_FILE_LOCATION
+ && TREE_TYPE (TREE_OPERAND (node, 1)) != error_mark_node)
+ patch_assignment (node, wfl_op1, wfl_op2);
+
+ /* Now, we still mark the lhs as initialized */
+ if (DECL_P (TREE_OPERAND (node, 0)))
+ INITIALIZED_P (TREE_OPERAND (node, 0)) = 1;
+
+ return error_mark_node;
+ }
+ TREE_OPERAND (node, 1) = nn;
+ return patch_assignment (node, wfl_op1, wfl_op2);
+
+ case MULT_EXPR:
+ case PLUS_EXPR:
+ case MINUS_EXPR:
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ case URSHIFT_EXPR:
+ case BIT_AND_EXPR:
+ case BIT_XOR_EXPR:
+ case BIT_IOR_EXPR:
+ case TRUNC_MOD_EXPR:
+ case RDIV_EXPR:
+ case TRUTH_ANDIF_EXPR:
+ case TRUTH_ORIF_EXPR:
+ case EQ_EXPR:
+ case NE_EXPR:
+ case GT_EXPR:
+ case GE_EXPR:
+ case LT_EXPR:
+ case LE_EXPR:
+ /* Operands 0 and 1 are WFL in certain cases only. patch_binop
+ knows how to handle those cases. */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ wfl_op2 = TREE_OPERAND (node, 1);
+ TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ return patch_binop (node, wfl_op1, wfl_op2);
+
+ case JAVA_UNARY_PLUS_EXPR:
+ case NEGATE_EXPR:
+ case TRUTH_NOT_EXPR:
+ case BIT_NOT_EXPR:
+ case PREDECREMENT_EXPR:
+ case PREINCREMENT_EXPR:
+ case POSTDECREMENT_EXPR:
+ case POSTINCREMENT_EXPR:
+ case CONVERT_EXPR:
+ /* There are cases were wfl_op1 is a WFL. patch_unaryop knows
+ how to handle those cases. */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ return patch_unaryop (node, wfl_op1);
+
+ case ARRAY_REF:
+ /* There are cases were wfl_op1 is a WFL. patch_array_ref knows
+ how to handle those cases. */
+ wfl_op1 = TREE_OPERAND (node, 0);
+ TREE_OPERAND (node, 0) = java_complete_tree (wfl_op1);
+ if (TREE_OPERAND (node, 0) == error_mark_node)
+ return error_mark_node;
+ /* The same applies to wfl_op2 */
+ wfl_op2 = TREE_OPERAND (node, 1);
+ TREE_OPERAND (node, 1) = java_complete_tree (wfl_op2);
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ return patch_array_ref (node, wfl_op1, wfl_op2);
+
+ case JAVA_THIS_EXPR:
+ /* Can't use THIS in a static environment */
+ if (!current_this)
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+ parse_error_context (wfl_operator, "Keyword `this' used outside "
+ "allowed context");
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+ return current_this;
+
+ case STRING_CST:
+ /* Build the internal string representation */
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ node = get_identifier (TREE_STRING_POINTER (node));
+ location = alloc_name_constant (CONSTANT_String, node);
+ node = build_ref_from_constant_pool (location);
+ TREE_TYPE (node) = promote_type (string_type_node);
+ return node;
+
+ default:
+ fatal ("No case for tree code `%s' - java_complete_tree\n",
+ tree_code_name [TREE_CODE (node)]);
+ }
+ return node;
+}
+
+/* Complete function call's argument. Return a non zero value is an
+ error was found. */
+
+static int
+complete_function_arguments (node)
+ tree node;
+{
+ int flag = 0;
+ tree cn;
+
+ for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
+ {
+ tree wfl = TREE_VALUE (cn), parm;
+ parm = java_complete_tree (wfl);
+ if (parm == error_mark_node)
+ {
+ flag = 1;
+ continue;
+ }
+ if (TREE_CODE (TREE_TYPE (parm)) == RECORD_TYPE)
+ TREE_VALUE (cn) = convert (promote_type (TREE_TYPE (parm)), parm);
+ else
+ TREE_VALUE (cn) = save_expr (parm);
+ if (not_initialized_as_it_should_p (parm))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl, EXPR_WFL_NODE (wfl));
+ INITIALIZED_P (parm) = 1;
+ }
+ }
+ return flag;
+}
+
+/* Sometimes (for loops and variable initialized during their
+ declaration), we want to wrap a statement around a WFL and turn it
+ debugable. */
+
+static tree
+build_debugable_stmt (location, stmt)
+ int location;
+ tree stmt;
+{
+ if (TREE_CODE (stmt) != EXPR_WITH_FILE_LOCATION)
+ {
+ stmt = build_expr_wfl (stmt, input_filename, 0, 0);
+ EXPR_WFL_LINECOL (stmt) = location;
+ }
+ JAVA_MAYBE_GENERATE_DEBUG_INFO (stmt);
+ return stmt;
+}
+
+static tree
+build_expr_block (body, decls)
+ tree body, decls;
+{
+ tree node = make_node (BLOCK);
+ BLOCK_EXPR_DECLS (node) = decls;
+ BLOCK_EXPR_BODY (body);
+ if (body)
+ TREE_TYPE (node) = TREE_TYPE (body);
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* Create a new function block and link its supercontext to the
+ previous block. The current function DECL is used as supercontext
+ when enter_block is called for the first time for a given
+ function. The current function body (DECL_FUNCTION_BODY) is set to
+ the newly created block. */
+
+static block_level = 0;
+
+static tree
+enter_block ()
+{
+ tree b = build_expr_block (NULL_TREE, NULL_TREE);
+ tree fndecl = current_function_decl;
+
+ if (!DECL_FUNCTION_BODY (fndecl))
+ {
+ BLOCK_SUPERCONTEXT (b) = fndecl;
+ DECL_FUNCTION_BODY (fndecl) = b;
+ }
+ else
+ {
+ BLOCK_SUPERCONTEXT (b) = DECL_FUNCTION_BODY (fndecl);
+ DECL_FUNCTION_BODY (fndecl) = b;
+ }
+ return b;
+}
+
+/* Exit a block by changing the current function body
+ (DECL_FUNCTION_BODY) to the current block super context, only if
+ the block being exited isn't the method's top level one. */
+
+static tree
+exit_block ()
+{
+ tree b = DECL_FUNCTION_BODY (current_function_decl);
+
+ if (BLOCK_SUPERCONTEXT (b) != current_function_decl)
+ DECL_FUNCTION_BODY (current_function_decl) = BLOCK_SUPERCONTEXT (b);
+
+ return b;
+}
+
+/* Lookup for NAME in the nested function's blocks, all the way up to
+ the current toplevel one. It complies with Java's local variable
+ scoping rules. */
+
+static tree
+lookup_name_in_blocks (name)
+ tree name;
+{
+ tree b = DECL_FUNCTION_BODY (current_function_decl);
+
+ while (b != current_function_decl)
+ {
+ tree current;
+
+ /* Paranoid sanity check. To be removed */
+ if (TREE_CODE (b) != BLOCK)
+ fatal ("non block expr function body - lookup_name_in_blocks");
+
+ for (current = BLOCK_EXPR_DECLS (b); current;
+ current = TREE_CHAIN (current))
+ if (DECL_NAME (current) == name)
+ return current;
+ b = BLOCK_SUPERCONTEXT (b);
+ }
+ return NULL_TREE;
+}
+
+static void
+maybe_absorb_scoping_blocks ()
+{
+ while (BLOCK_EXPR_ORIGIN (DECL_FUNCTION_BODY (current_function_decl)))
+ {
+ tree b = exit_block ();
+ java_method_add_stmt (current_function_decl, b);
+ SOURCE_FRONTEND_DEBUG (("Absorbing scoping block at line %d", lineno));
+ }
+}
+
+\f
+/* This section of the source is reserved to build_* functions that
+ are building incomplete tree nodes and the patch_* functions that
+ are completing them. */
+
+/* Build an incomplete CALL_EXPR node. Encapsulate it within a WFL */
+
+static tree
+build_method_invocation (name, args)
+ tree name;
+ tree args;
+{
+ tree call = build (CALL_EXPR, NULL_TREE, name, args, NULL_TREE);
+ TREE_SIDE_EFFECTS (call) = 1;
+ /* Check on cases where NAME isn't a WFL. FIXME */
+ EXPR_WFL_LINECOL (call) = EXPR_WFL_LINECOL (name);
+ return call;
+}
+
+/* Build an incomplete assignment expression. */
+
+static tree
+build_assignment (op, op_location, lhs, rhs)
+ int op, op_location;
+ tree lhs, rhs;
+{
+ tree assignment;
+ /* Build the corresponding binop if we deal with a Compound
+ Assignment operator. Mark the binop sub-tree as part of a
+ Compound Assignment expression */
+ if (op != ASSIGN_TK)
+ {
+ rhs = build_binop (BINOP_LOOKUP (op), op_location, lhs, rhs);
+ COMPOUND_ASSIGN_P (rhs) = 1;
+ }
+ assignment = build (MODIFY_EXPR, NULL_TREE, lhs, rhs);
+ TREE_SIDE_EFFECTS (assignment) = 1;
+ EXPR_WFL_LINECOL (assignment) = op_location;
+ return assignment;
+}
+
+/* Print an INTEGER_CST node in a static buffer, and return the buffer. */
+
+static char *
+print_int_node (node)
+ tree node;
+{
+ static char buffer [80];
+ if (TREE_CONSTANT_OVERFLOW (node))
+ sprintf (buffer, "<overflow>");
+
+ if (TREE_INT_CST_HIGH (node) == 0)
+ sprintf (buffer, HOST_WIDE_INT_PRINT_UNSIGNED,
+ TREE_INT_CST_LOW (node));
+ else if (TREE_INT_CST_HIGH (node) == -1
+ && TREE_INT_CST_LOW (node) != 0)
+ {
+ buffer [0] = '-';
+ sprintf (&buffer [1], HOST_WIDE_INT_PRINT_UNSIGNED,
+ -TREE_INT_CST_LOW (node));
+ }
+ else
+ sprintf (buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
+ TREE_INT_CST_HIGH (node), TREE_INT_CST_LOW (node));
+
+ return buffer;
+}
+
+/* 15.25 Assignment operators. */
+
+static tree
+patch_assignment (node, wfl_op1, wfl_op2)
+ tree node;
+ tree wfl_op1;
+ tree wfl_op2;
+{
+ tree rhs = TREE_OPERAND (node, 1);
+ tree lvalue = TREE_OPERAND (node, 0);
+ tree lhs_type, rhs_type, new_rhs = NULL_TREE;
+ int all_primitive;
+ int error_found = 0;
+ int lvalue_from_array = 0;
+
+ /* Can't assign to a final. */
+ if (DECL_P (lvalue) && FIELD_FINAL (lvalue))
+ {
+ parse_error_context
+ (wfl_op1, "Can't assign a value to the final variable `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl_op1)));
+ error_found = 1;
+ }
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* Lhs can be a named variable */
+ if (DECL_P (lvalue))
+ {
+ INITIALIZED_P (lvalue) = 1;
+ lhs_type = TREE_TYPE (lvalue);
+ }
+ /* Or Lhs can be a array acccess. Should that be lvalue ? FIXME +
+ comment on reason why */
+ else if (TREE_CODE (wfl_op1) == ARRAY_REF)
+ {
+ lhs_type = TREE_TYPE (lvalue);
+ lvalue_from_array = 1;
+ }
+ /* Or a field access */
+ else if (TREE_CODE (lvalue) == COMPONENT_REF)
+ lhs_type = TREE_TYPE (lvalue);
+ /* Or a function return slot */
+ else if (TREE_CODE (lvalue) == RESULT_DECL)
+ lhs_type = TREE_TYPE (lvalue);
+ /* Otherwise, this is an error */
+ else
+ {
+ parse_error_context (wfl_op1, "Invalid left hand side of assignment");
+ error_found = 1;
+ }
+
+ rhs_type = TREE_TYPE (rhs);
+
+ /* 5.2 Begin Assignment conversion */
+
+ /* 5.1.1 Try Identity Conversion */
+ if (lhs_type == rhs_type)
+ new_rhs = rhs;
+
+ /* 5.1.2 Try Widening Primitive Conversion */
+ all_primitive = JPRIMITIVE_TYPE_P (lhs_type) && JPRIMITIVE_TYPE_P (rhs_type);
+ if (all_primitive && JINTEGRAL_TYPE_P (rhs_type)
+ && ((TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type))
+ || (JFLOAT_TYPE_P (lhs_type) &&
+ TYPE_PRECISION (rhs_type) == TYPE_PRECISION (lhs_type))))
+ new_rhs = convert (lhs_type, rhs);
+ else if (all_primitive && JFLOAT_TYPE_P (rhs_type)
+ && (TYPE_PRECISION (rhs_type) < TYPE_PRECISION (lhs_type)))
+ new_rhs = convert (lhs_type, rhs);
+
+ /* Try a narrowing primitive conversion:
+ - expression is a constant expression of type int AND
+ - variable is byte, short or char AND
+ - The value of the expression is representable in the type of the
+ variable */
+ else if (rhs_type == int_type_node && TREE_CONSTANT (rhs)
+ && (lhs_type == byte_type_node || lhs_type == char_type_node
+ || lhs_type == short_type_node))
+ {
+ if (int_fits_type_p (rhs, lhs_type))
+ new_rhs = convert (lhs_type, rhs);
+ else
+ parse_warning_context
+ (wfl_op1, "Constant expression `%s' to wide for narrowing "
+ "primitive conversion to `%s'",
+ print_int_node (rhs), lang_printable_name (lhs_type));
+ /* Reported a warning that will turn into an error further
+ down, so we don't return */
+ }
+
+ /* 5.2 Try a reference conversion */
+ else if (!JPRIMITIVE_TYPE_P (rhs_type) && JREFERENCE_TYPE_P (lhs_type))
+ {
+ /* `null' may be assigned to any reference type */
+ if (rhs == null_pointer_node)
+ new_rhs = null_pointer_node;
+ /* Try the reference assignment conversion */
+ else if (valid_ref_assignconv_cast_p (rhs_type, lhs_type, 0))
+ new_rhs = rhs;
+ if (new_rhs)
+ lhs_type = promote_type (rhs_type);
+ }
+
+ /* 15.25.2 If we have a compound assignment, convert RHS into the
+ type of the LHS */
+ else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
+ new_rhs = convert (lhs_type, rhs);
+
+ /* Explicit cast required. This is an error */
+ if (!new_rhs)
+ {
+ char *t1 = strdup ((char *)lang_printable_name (TREE_TYPE (rhs)));
+ char *t2 = strdup ((char *)lang_printable_name (lhs_type));
+ tree wfl;
+ char operation [32]; /* Max size known */
+
+ /* If the assignment is part of a declaration, we use the WFL of
+ the declared variable to point out the error and call it a
+ declaration problem. If the assignment is a genuine =
+ operator, we call is a operator `=' problem, otherwise we
+ call it an assignment problem. In both of these last cases,
+ we use the WFL of the operator to indicate the error. */
+
+ if (MODIFY_EXPR_FROM_INITIALIZATION_P (node))
+ {
+ wfl = wfl_op1;
+ strcpy (operation, "declaration");
+ }
+ else
+ {
+ wfl = wfl_operator;
+ if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
+ strcpy (operation, "assignment");
+ else if (TREE_CODE (TREE_OPERAND (node, 0)) == RESULT_DECL)
+ strcpy (operation, "`return'");
+ else
+ strcpy (operation, "`='");
+ }
+
+ parse_error_context
+ (wfl, (!can_cast_to_p (rhs_type, lhs_type) ?
+ "Incompatible type for %s. Can't convert `%s' to `%s'" :
+ "Incompatible type for %s. Explicit cast "
+ "needed to convert `%s' to `%s'"), operation, t1, t2);
+ free (t1); free (t2);
+ error_found = 1;
+ }
+
+ /* Before reporting type incompatibility errors, check that the rhs
+ is initialized, if a variable */
+ if (not_initialized_as_it_should_p (rhs))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl_op2, DECL_NAME (rhs));
+ INITIALIZED_P (rhs) = 1;
+ }
+
+ if (error_found)
+ return error_mark_node;
+
+ /* If we built a compound expression as the result of a reference
+ assignment into an array element, return it here. */
+ if (TREE_CODE (node) == COMPOUND_EXPR)
+ return node;
+
+ TREE_OPERAND (node, 0) = lvalue;
+ TREE_OPERAND (node, 1) = new_rhs;
+ TREE_TYPE (node) = lhs_type;
+ return node;
+}
+
+/* Check that SOURCE can be converted into DEST, at least with a
+ cast. If the convertion can't occur at all, return 0 otherwise
+ 1. This function is used to produce accurate error messages on the
+ reasons why an assignment failed. */
+
+static int
+can_cast_to_p (source, dest)
+ tree source;
+ tree dest;
+{
+ if (TREE_CODE (source) == POINTER_TYPE)
+ source = TREE_TYPE (source);
+ if (TREE_CODE (dest) == POINTER_TYPE)
+ dest = TREE_TYPE (dest);
+
+ if (TREE_CODE (source) == RECORD_TYPE && TREE_CODE (dest) == RECORD_TYPE)
+ return valid_ref_assignconv_cast_p (source, dest, 1);
+
+ else if (JNUMERIC_TYPE_P (source) && JNUMERIC_TYPE_P (dest))
+ return 1;
+
+ return 0;
+}
+
+/* Check that something of SOURCE type can be assigned or cast to
+ something of DEST type at runtime. Return 1 if the operation is
+ valid, 0 otherwise. If CAST is set to 1, we're treating the case
+ were SOURCE is cast into DEST, which borrows a lot of the
+ assignment check. */
+
+static int
+valid_ref_assignconv_cast_p (source, dest, cast)
+ tree source;
+ tree dest;
+ int cast;
+{
+ if (TREE_CODE (source) == POINTER_TYPE)
+ source = TREE_TYPE (source);
+ if (TREE_CODE (dest) == POINTER_TYPE)
+ dest = TREE_TYPE (dest);
+ /* Case where SOURCE is a class type */
+ if (TYPE_CLASS_P (source))
+ {
+ if (TYPE_CLASS_P (dest))
+ return source == dest || inherits_from_p (source, dest)
+ || cast && inherits_from_p (dest, source);
+ if (TYPE_INTERFACE_P (dest))
+ {
+ /* If doing a cast and SOURCE is final, the operation is
+ always correct a compile time (because even if SOURCE
+ does not implement DEST, a subclass of SOURCE might). */
+ if (cast && !CLASS_FINAL (TYPE_NAME (source)))
+ return 1;
+ /* Otherwise, SOURCE must implement DEST */
+ return interface_of_p (dest, source);
+ }
+ /* DEST is an array, cast permited if SOURCE is of Object type */
+ return (cast && source == object_type_node ? 1 : 0);
+ }
+ if (TYPE_INTERFACE_P (source))
+ {
+ if (TYPE_CLASS_P (dest))
+ {
+ /* If not casting, DEST must be the Object type */
+ if (!cast)
+ return dest == object_type_node;
+ /* We're doing a cast. The cast is always valid is class
+ DEST is not final, otherwise, DEST must implement SOURCE */
+ else if (!CLASS_FINAL (TYPE_NAME (source)))
+ return 1;
+ else
+ return interface_of_p (source, dest);
+ }
+ if (TYPE_INTERFACE_P (dest))
+ {
+ /* If doing a cast, then if SOURCE and DEST contain method
+ with the same signature but different return type, then
+ this is a (compile time) error */
+ if (cast)
+ {
+ tree method_source, method_dest;
+ tree source_type;
+ tree source_sig, dest_sig;
+ tree source_name;
+ for (method_source = TYPE_METHODS (source); method_source;
+ method_source = TREE_CHAIN (method_source))
+ {
+ source_sig =
+ build_java_argument_signature (TREE_TYPE (method_source));
+ source_type = TREE_TYPE (TREE_TYPE (method_source));
+ source_name = DECL_NAME (method_source);
+ for (method_dest = TYPE_METHODS (dest);
+ method_dest; method_dest = TREE_CHAIN (method_dest))
+ if (source_sig ==
+ build_java_argument_signature (TREE_TYPE (method_dest))
+ && source_name == DECL_NAME (method_dest)
+ && source_type != TREE_TYPE (TREE_TYPE (method_dest)))
+ return 0;
+ }
+ return 1;
+ }
+ else
+ return source == dest || interface_of_p (dest, source);
+ }
+ else /* Array */
+ return 0;
+ }
+ if (TYPE_ARRAY_P (source))
+ {
+ if (TYPE_CLASS_P (dest))
+ return dest == object_type_node;
+ if (TYPE_INTERFACE_P (dest))
+ return 0; /* Install test on Clonable. FIXME */
+ else /* Arrays */
+ {
+ tree source_element_type = TYPE_ARRAY_ELEMENT (source);
+ tree dest_element_type = TYPE_ARRAY_ELEMENT (dest);
+
+ if (source_element_type == dest_element_type)
+ return 1;
+ return valid_ref_assignconv_cast_p (source_element_type,
+ dest_element_type, cast);
+ }
+ return 0;
+ }
+ return 0;
+}
+
+/* Build an incomplete binop expression. */
+
+static tree
+build_binop (op, op_location, op1, op2)
+ enum tree_code op;
+ int op_location;
+ tree op1, op2;
+{
+ tree wfl;
+
+ /* URSHIFT_EXPR is not part of what GCC understands, we can't directly build
+ a node with it */
+ tree binop =
+ build ((op == URSHIFT_EXPR ? RSHIFT_EXPR : op), NULL_TREE, op1, op2);
+ if (op == URSHIFT_EXPR)
+ TREE_SET_CODE (binop, op);
+
+ TREE_SIDE_EFFECTS (binop) = 1;
+ /* Store the location of the operator, for better error report. The
+ string of the operator will be rebuild based on the OP value. */
+ EXPR_WFL_LINECOL (binop) = op_location;
+ return binop;
+}
+
+/* Build the string of the operator retained by NODE. If NODE is part
+ of a compound expression, add an '=' at the end of the string. This
+ function is called when an error needs to be reported on an
+ operator. The string is returned as a pointer to a static character
+ buffer. */
+
+static char *
+operator_string (node)
+ tree node;
+{
+#define BUILD_OPERATOR_STRING(S) \
+ { \
+ sprintf (buffer, "%s%s", S, (COMPOUND_ASSIGN_P (node) ? "=" : "")); \
+ return buffer; \
+ }
+
+ static char buffer [10];
+ switch (TREE_CODE (node))
+ {
+ case MULT_EXPR: BUILD_OPERATOR_STRING ("*");
+ case RDIV_EXPR: BUILD_OPERATOR_STRING ("/");
+ case TRUNC_MOD_EXPR: BUILD_OPERATOR_STRING ("%");
+ case PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
+ case MINUS_EXPR: BUILD_OPERATOR_STRING ("-");
+ case LSHIFT_EXPR: BUILD_OPERATOR_STRING ("<<");
+ case RSHIFT_EXPR: BUILD_OPERATOR_STRING (">>");
+ case URSHIFT_EXPR: BUILD_OPERATOR_STRING (">>>");
+ case BIT_AND_EXPR: BUILD_OPERATOR_STRING ("&");
+ case BIT_XOR_EXPR: BUILD_OPERATOR_STRING ("^");
+ case BIT_IOR_EXPR: BUILD_OPERATOR_STRING ("|");
+ case TRUTH_ANDIF_EXPR: BUILD_OPERATOR_STRING ("&&");
+ case TRUTH_ORIF_EXPR: BUILD_OPERATOR_STRING ("||");
+ case EQ_EXPR: BUILD_OPERATOR_STRING ("==");
+ case NE_EXPR: BUILD_OPERATOR_STRING ("!=");
+ case GT_EXPR: BUILD_OPERATOR_STRING (">");
+ case GE_EXPR: BUILD_OPERATOR_STRING (">=");
+ case LT_EXPR: BUILD_OPERATOR_STRING ("<");
+ case LE_EXPR: BUILD_OPERATOR_STRING ("<=");
+ case JAVA_UNARY_PLUS_EXPR: BUILD_OPERATOR_STRING ("+");
+ case NEGATE_EXPR: BUILD_OPERATOR_STRING ("-");
+ case TRUTH_NOT_EXPR: BUILD_OPERATOR_STRING ("!");
+ case BIT_NOT_EXPR: BUILD_OPERATOR_STRING ("~");
+ case PREINCREMENT_EXPR: /* Fall through */
+ case POSTINCREMENT_EXPR: BUILD_OPERATOR_STRING ("++");
+ case PREDECREMENT_EXPR: /* Fall through */
+ case POSTDECREMENT_EXPR: BUILD_OPERATOR_STRING ("--");
+ default:
+ fatal ("unregistered operator %s - operator_string",
+ tree_code_name [TREE_CODE (node)]);
+ }
+ return NULL;
+#undef BUILD_OPERATOR_STRING
+}
+
+/* Binary operators (15.16 up to 15.18). We return error_mark_node on
+ errors but we modify NODE so that it contains the type computed
+ according to the expression, when it's fixed. Otherwise, we write
+ error_mark_node as the type. It allows us to further the analysis
+ of remaining nodes and detects more errors in certain cases. */
+
+static tree
+patch_binop (node, wfl_op1, wfl_op2)
+ tree node;
+ tree wfl_op1;
+ tree wfl_op2;
+{
+ tree op1 = TREE_OPERAND (node, 0);
+ tree op2 = TREE_OPERAND (node, 1);
+ tree op1_type = TREE_TYPE (op1);
+ tree op2_type = TREE_TYPE (op2);
+ tree prom_type;
+ int code = TREE_CODE (node);
+ /* If 1, tell the routine that we have to return error_mark_node
+ after checking for the initialization of the RHS */
+ int error_found = 0;
+
+ /* Figure what is going to be checked first for initialization prior
+ its use. If NODE is part of a compound assignment, we check the
+ second operand first, otherwise the first one first. We also
+ initialize the matching WFL for the error report. `cfi' stands
+ for Check For Initialization */
+ tree cfi = (COMPOUND_ASSIGN_P (node) ? op2 : op1);
+ tree cfi_wfl = (COMPOUND_ASSIGN_P (node) ? wfl_op2 : wfl_op1);
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* Check initialization of LHS first. We then silence further error
+ message if the variable wasn't initialized */
+ if (not_initialized_as_it_should_p (cfi))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (cfi_wfl, DECL_NAME (cfi));
+ INITIALIZED_P (op1) = 1;
+ }
+
+ switch (code)
+ {
+ /* 15.16 Multiplicative operators */
+ case MULT_EXPR: /* 15.16.1 Multiplication Operator * */
+ case RDIV_EXPR: /* 15.16.2 Division Operator / */
+ case TRUNC_MOD_EXPR: /* 15.16.3 Remainder operator % */
+ if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
+ {
+ if (!JPRIMITIVE_TYPE_P (op1_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
+ if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ break;
+ }
+ prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+ /* Change the division operator if necessary */
+ if (code == RDIV_EXPR && TREE_CODE (prom_type) == INTEGER_TYPE)
+ TREE_SET_CODE (node, TRUNC_DIV_EXPR);
+ /* This one is more complicated. FLOATs are processed by a function
+ call to soft_fmod. */
+ if (code == TRUNC_MOD_EXPR)
+ return build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
+ break;
+
+ /* 15.17 Additive Operators */
+ case PLUS_EXPR: /* 15.17.1 String Concatenation Operator + */
+ if (JSTRING_TYPE_P (op1_type) || JSTRING_TYPE_P (op2_type))
+ fatal ("operator `+' non implemented on String - patch_binop");
+ case MINUS_EXPR: /* 15.17.2 Additive Operators (+ and -) for
+ Numeric Types */
+ if (!JPRIMITIVE_TYPE_P (op1_type) || !JPRIMITIVE_TYPE_P (op2_type))
+ {
+ if (!JPRIMITIVE_TYPE_P (op1_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
+ if (!JPRIMITIVE_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ break;
+ }
+ prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+ break;
+
+ /* 15.18 Shift Operators */
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ case URSHIFT_EXPR:
+ if (!JINTEGRAL_TYPE_P (op1_type) || !JINTEGRAL_TYPE_P (op2_type))
+ {
+ if (!JINTEGRAL_TYPE_P (op1_type))
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
+ else
+ parse_error_context
+ (wfl_operator, (JPRIMITIVE_TYPE_P (op2_type) ?
+ "Incompatible type for `%s'. Explicit cast needed to convert "
+ "shift distance from `%s' to integral" :
+ "Incompatible type for `%s'. Can't convert shift distance from "
+ "`%s' to integral"),
+ operator_string (node), lang_printable_name (op2_type));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ break;
+ }
+
+ /* Unary numeric promotion (5.6.1) is performed on each operand
+ separatly */
+ op1 = convert (promote_type (op1_type), op1);
+ op2 = convert (promote_type (op2_type), op2);
+
+ /* The type of the shift expression is the type of the promoted
+ type of the left-hand operand */
+ prom_type = TREE_TYPE (op1);
+
+ /* Shift int only up to 0x1f and long up to 0x3f */
+ if (prom_type == int_type_node)
+ op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
+ build_int_2 (0x1f, 0)));
+ else
+ op2 = fold (build (BIT_AND_EXPR, int_type_node, op2,
+ build_int_2 (0x3f, 0)));
+
+ /* The >>> operator is a >> operating on unsigned quantities */
+ if (code == URSHIFT_EXPR)
+ {
+ op1 = convert (unsigned_type (prom_type), op1);
+ TREE_SET_CODE (node, RSHIFT_EXPR);
+ }
+ break;
+
+
+ /* 15.21 Bitwise and Logical Operators */
+ case BIT_AND_EXPR:
+ case BIT_XOR_EXPR:
+ case BIT_IOR_EXPR:
+ if (JINTEGRAL_TYPE_P (op1_type) && JINTEGRAL_TYPE_P (op2_type))
+ /* Binary numeric promotion is performed on both operand and the
+ expression retain that type */
+ prom_type = binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+
+ else if (TREE_CODE (op1_type) == BOOLEAN_TYPE
+ && TREE_CODE (op1_type) == BOOLEAN_TYPE)
+ /* The type of the bitwise operator expression is BOOLEAN */
+ prom_type = boolean_type_node;
+ else
+ {
+ if (!JINTEGRAL_TYPE_P (op1_type))
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op1_type);
+ if (!JINTEGRAL_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ /* Insert a break here if adding thing before the switch's
+ break for this case */
+ }
+ break;
+
+ /* 15.22 Conditional-And Operator */
+ case TRUTH_ANDIF_EXPR:
+ /* 15.23 Conditional-Or Operator */
+ case TRUTH_ORIF_EXPR:
+ /* Operands must be of BOOLEAN type */
+ if (TREE_CODE (op1_type) != BOOLEAN_TYPE ||
+ TREE_CODE (op2_type) != BOOLEAN_TYPE)
+ {
+ if (TREE_CODE (op1_type) != BOOLEAN_TYPE)
+ ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op1_type);
+ if (TREE_CODE (op2_type) != BOOLEAN_TYPE && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ break;
+ }
+ /* The type of the conditional operators is BOOLEAN */
+ prom_type = boolean_type_node;
+ break;
+
+ /* 15.19.1 Numerical Comparison Operators <, <=, >, >= */
+ case LT_EXPR:
+ case GT_EXPR:
+ case LE_EXPR:
+ case GE_EXPR:
+ /* The type of each of the operands must be a primitive numeric
+ type */
+ if (!JNUMERIC_TYPE_P (op1_type) || ! JNUMERIC_TYPE_P (op2_type))
+ {
+ if (!JNUMERIC_TYPE_P (op1_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op1_type);
+ if (!JNUMERIC_TYPE_P (op2_type) && (op1_type != op2_type))
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op2_type);
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ break;
+ }
+ /* Binary numeric promotion is performed on the operands */
+ binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+ /* The type of the relation expression is always BOOLEAN */
+ prom_type = boolean_type_node;
+ break;
+
+ /* 15.20 Equality Operator */
+ case EQ_EXPR:
+ case NE_EXPR:
+ /* 15.20.1 Numerical Equality Operators == and != */
+ /* Binary numeric promotion is performed on the operands */
+ if (JPRIMITIVE_TYPE_P (op1_type) && JPRIMITIVE_TYPE_P (op2_type))
+ binary_numeric_promotion (op1_type, op2_type, &op1, &op2);
+
+ /* 15.20.2 Boolean Equality Operators == and != */
+ else if (TREE_CODE (op1_type) == BOOLEAN_TYPE &&
+ TREE_CODE (op2_type) == BOOLEAN_TYPE)
+ ; /* Nothing to do here */
+
+ /* 15.20.3 Reference Equality Operators == and != */
+ /* Types have to be either references or the null type */
+ else if ((op1 == null_pointer_node || op2 == null_pointer_node
+ || JREFERENCE_TYPE_P (op1_type)
+ || JREFERENCE_TYPE_P (op2_type))
+ && ((op1_type == op2_type)
+ /* The should use a can_cast_to_p() */
+ ))
+ ; /* Nothing to do here */
+
+ /* Else we have an error figure what can't be converted into
+ what and report the error */
+ else
+ {
+ char *t1;
+ t1 = strdup ((char *)lang_printable_name (op1_type));
+ parse_error_context
+ (wfl_operator, "Incompatible type for `%s'. Can't convert `%s' "
+ "to `%s'", operator_string (node), t1,
+ lang_printable_name (op2_type));
+ free (t1);
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ break;
+ }
+ prom_type = boolean_type_node;
+ break;
+ }
+
+ /* Then check the initialization of the RHS. We don't do that if
+ we're dealing with a node that is part of a compound
+ assignment. We then silence further error message if the variable
+ wasn't initialized */
+ if (not_initialized_as_it_should_p (op2) && !COMPOUND_ASSIGN_P (node))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl_op2, DECL_NAME (op2));
+ INITIALIZED_P (op2) = 1;
+ }
+
+ if (error_found)
+ return error_mark_node;
+
+ TREE_OPERAND (node, 0) = op1;
+ TREE_OPERAND (node, 1) = op2;
+ TREE_TYPE (node) = prom_type;
+ return fold (node);
+}
+
+/* Build an incomplete unary operator expression. Unary `+' node is
+ build as a CONV_EXPR, even though its tree code is overridden by a
+ JAVA_UNARY_PLUS_EXPR that isn't a tree code, to differentiate it during
+ the walk. */
+
+static tree
+build_unaryop (op_token, op_location, op1)
+ int op_token, op_location;
+ tree op1;
+{
+ enum tree_code op;
+ tree unaryop;
+ switch (op_token)
+ {
+ case PLUS_TK: op = CONVERT_EXPR; break;
+ case MINUS_TK: op = NEGATE_EXPR; break;
+ case NEG_TK: op = TRUTH_NOT_EXPR; break;
+ case NOT_TK: op = BIT_NOT_EXPR; break;
+ default: fatal ("Unknown token `%d' for unary operator - build_unaryop",
+ op_token);
+ }
+
+ unaryop = build1 (op, NULL_TREE, op1);
+ if (op_token == PLUS_TK)
+ TREE_SET_CODE (unaryop, JAVA_UNARY_PLUS_EXPR);
+
+ TREE_SIDE_EFFECTS (unaryop) = 1;
+ /* Store the location of the operator, for better error report. The
+ string of the operator will be rebuild based on the OP value. */
+ EXPR_WFL_LINECOL (unaryop) = op_location;
+ return unaryop;
+}
+
+/* Special case for the ++/-- operators, since they require an extra
+ argument to build, which is set to NULL and patched
+ later. IS_POST_P is 1 if the operator, 0 otherwise. */
+
+static tree
+build_incdec (op_token, op_location, op1, is_post_p)
+ int op_token, op_location;
+ tree op1;
+ int is_post_p;
+{
+ static enum tree_code lookup [2][2] =
+ {
+ { PREDECREMENT_EXPR, PREINCREMENT_EXPR, },
+ { POSTDECREMENT_EXPR, POSTINCREMENT_EXPR, },
+ };
+ tree node = build (lookup [is_post_p][(op_token - DECR_TK)],
+ NULL_TREE, op1, NULL_TREE);
+ TREE_SIDE_EFFECTS (node) = 1;
+ /* Store the location of the operator, for better error report. The
+ string of the operator will be rebuild based on the OP value. */
+ EXPR_WFL_LINECOL (node) = op_location;
+ return node;
+}
+
+/* Build an incomplete cast operator, based on the use of the
+ CONVERT_EXPR. Note that TREE_TYPE of the constructed node is
+ set. java_complete_tree is trained to walk a CONVERT_EXPR even
+ though its type is already set. */
+
+static tree
+build_cast (location, type, exp)
+ int location;
+ tree type, exp;
+{
+ tree node = build1 (CONVERT_EXPR, type, exp);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+/* 15.14 Unary operators. We return error_mark_node in case of error,
+ but preserve the type of NODE if the type is fixed. */
+
+static tree
+patch_unaryop (node, wfl_op)
+ tree node;
+ tree wfl_op;
+{
+ tree op = TREE_OPERAND (node, 0);
+ tree op_type = TREE_TYPE (op);
+ tree prom_type, value;
+ int code = TREE_CODE (node);
+ int error_found = 0;
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ switch (code)
+ {
+ /* 15.13.2 Postfix Increment Operator ++ */
+ case POSTINCREMENT_EXPR:
+ /* 15.13.3 Postfix Increment Operator -- */
+ case POSTDECREMENT_EXPR:
+ /* 15.14.1 Prefix Increment Operator ++ */
+ case PREINCREMENT_EXPR:
+ /* 15.14.2 Prefix Decrement Operator -- */
+ case PREDECREMENT_EXPR:
+ if (!DECL_P (op))
+ {
+ parse_error_context (wfl_operator, "Invalid argument to `%s'",
+ operator_string (node));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else if (FIELD_FINAL (op))
+ {
+ parse_error_context
+ (wfl_op, "Can't assign a value to the final variable `%s'",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (wfl_op)));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ /* From now on, we know that op if a variable and that it has a
+ valid wfl. We use wfl_op to locate errors related to the
+ ++/-- operand. */
+ else if (!JNUMERIC_TYPE_P (op_type))
+ {
+ parse_error_context
+ (wfl_op, "Invalid argument type `%s' to `%s'",
+ lang_printable_name (op_type), operator_string (node));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else
+ {
+ /* Before the addition, binary numeric promotion if performed on
+ both operands */
+ value = integer_one_node;
+ prom_type = binary_numeric_promotion (op_type, TREE_TYPE (value),
+ &op, &value);
+ /* And write the promoted increment back */
+ TREE_OPERAND (node, 1) = value;
+ }
+ break;
+
+ /* 15.14.3 Unary Plus Operator + */
+ case JAVA_UNARY_PLUS_EXPR:
+ /* 15.14.4 Unary Minus Operator - */
+ case NEGATE_EXPR:
+ if (!JNUMERIC_TYPE_P (op_type))
+ {
+ ERROR_CANT_CONVERT_TO_NUMERIC (wfl_operator, node, op_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ /* Unary numeric promotion is performed on operand */
+ else
+ {
+ prom_type = promote_type (op_type);
+ op = convert (prom_type, op);
+ if (code == JAVA_UNARY_PLUS_EXPR)
+ node = op;
+ }
+ break;
+
+ /* 15.14.5 Bitwise Complement Operator ~ */
+ case BIT_NOT_EXPR:
+ if (!JINTEGRAL_TYPE_P (op_type))
+ {
+ ERROR_CAST_NEEDED_TO_INTEGRAL (wfl_operator, node, op_type);
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else
+ {
+ prom_type = promote_type (op_type);
+ op = convert (prom_type, op);
+ }
+ break;
+
+ /* 15.14.6 Logical Complement Operator ! */
+ case TRUTH_NOT_EXPR:
+ if (TREE_CODE (op_type) != BOOLEAN_TYPE)
+ {
+ ERROR_CANT_CONVERT_TO_BOOLEAN (wfl_operator, node, op_type);
+ TREE_TYPE (node) = boolean_type_node;
+ error_found = 1;
+ }
+ else
+ prom_type = boolean_type_node;
+ break;
+
+ /* 15.15 Cast Expression */
+ case CONVERT_EXPR:
+ value = patch_cast (node, wfl_op, wfl_operator);
+ if (value == error_mark_node)
+ {
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+ else
+ node = value;
+ break;
+ }
+
+ /* Check variable initialization */
+ if (not_initialized_as_it_should_p (op))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl_op, DECL_NAME (op));
+ INITIALIZED_P (op) = 1;
+ }
+
+ if (error_found)
+ return error_mark_node;
+ /* In the case of JAVA_UNARY_PLUS_EXPR, we replaced NODE by a new one */
+ else if (code != JAVA_UNARY_PLUS_EXPR && code != CONVERT_EXPR)
+ {
+ TREE_OPERAND (node, 0) = op;
+ TREE_TYPE (node) = prom_type;
+ }
+ return fold (node);
+}
+
+/* Generic type resolution that sometimes takes place during node
+ patching. Returned the resolved type or generate an error
+ message. Return the resolved type or NULL_TREE. */
+
+static tree
+resolve_type_during_patch (type)
+ tree type;
+{
+ if (unresolved_type_p (type, NULL))
+ {
+ tree type_decl = resolve_no_layout (EXPR_WFL_NODE (type), NULL_TREE);
+ if (!type_decl)
+ {
+ parse_error_context (type,
+ "Class `%s' not found in type declaration",
+ IDENTIFIER_POINTER (EXPR_WFL_NODE (type)));
+ return NULL_TREE;
+ }
+ else
+ return TREE_TYPE (type_decl);
+ }
+ return type;
+}
+/* 5.5 Casting Conversion. error_mark_node is returned if an error is
+ found. Otherwise NODE or something meant to replace it is returned. */
+
+static tree
+patch_cast (node, wfl_op, wfl_operator)
+ tree node;
+ tree wfl_op;
+ tree wfl_operator;
+{
+ tree op = TREE_OPERAND (node, 0);
+ tree op_type = TREE_TYPE (op);
+ tree cast_type = TREE_TYPE (node);
+ char *t1;
+
+ /* First resolve OP_TYPE if unresolved */
+ if (!(cast_type = resolve_type_during_patch (cast_type)))
+ return error_mark_node;
+
+ /* Check on cast that are proven correct at compile time */
+ if (JNUMERIC_TYPE_P (cast_type) && JNUMERIC_TYPE_P (op_type))
+ {
+ static tree convert_narrow ();
+ /* Same type */
+ if (cast_type == op_type)
+ return node;
+
+ /* Try widening/narowwing convertion. Potentially, things need
+ to be worked out in gcc so we implement the extreme cases
+ correctly. fold_convert() needs to be fixed. */
+ return convert (cast_type, op);
+ }
+
+ /* The remaining legal casts involve conversion between reference
+ types. Check for their compile time correctness. */
+ if (JREFERENCE_TYPE_P (op_type) && JREFERENCE_TYPE_P (cast_type)
+ && valid_ref_assignconv_cast_p (op_type, cast_type, 1))
+ {
+ TREE_TYPE (node) = promote_type (cast_type);
+ /* Now, the case can be determined correct at compile time if
+ OP_TYPE can be converted into CAST_TYPE by assignment
+ conversion (5.2) */
+
+ if (valid_ref_assignconv_cast_p (op_type, cast_type, 0))
+ return node;
+
+ /* The cast requires a run-time check */
+ return build (CALL_EXPR, promote_type (cast_type),
+ build_address_of (soft_checkcast_node),
+ tree_cons (NULL_TREE, build_class_ref (cast_type),
+ build_tree_list (NULL_TREE, op)),
+ NULL_TREE);
+ }
+
+ /* Any other casts are proven incorrect at compile time */
+ t1 = strdup ((char *)lang_printable_name (op_type));
+ parse_error_context (wfl_operator, "Invalid cast from `%s' to `%s'",
+ t1, lang_printable_name (cast_type));
+ free (t1);
+ return error_mark_node;
+}
+
+/* Build an ARRAY_REF incomplete tree node. Note that operand 1 isn't
+ a list of indices. */
+static tree
+build_array_ref (location, array, index)
+ int location;
+ tree array, index;
+{
+ tree node = build (ARRAY_REF, NULL_TREE, array, index);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+/* 15.12 Array Access Expression */
+
+static tree
+patch_array_ref (node, wfl_array, wfl_index)
+ tree node, wfl_array, wfl_index;
+{
+ tree array = TREE_OPERAND (node, 0);
+ tree array_type = TREE_TYPE (array);
+ tree index = TREE_OPERAND (node, 1);
+ tree index_type = TREE_TYPE (index);
+ tree promoted_index_type;
+ int error_found = 0;
+
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ if (not_initialized_as_it_should_p (array))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl_array, DECL_NAME (array));
+ INITIALIZED_P (array) = 1;
+ }
+ if (! flag_emit_class_files)
+ array = save_expr (array);
+
+ if (TREE_CODE (array_type) == POINTER_TYPE)
+ array_type = TREE_TYPE (array_type);
+
+ /* The array reference must be an array */
+ if (!TYPE_ARRAY_P (array_type))
+ {
+ parse_error_context
+ (wfl_operator, "`[]' can only be applied to arrays. It can't be "
+ "applied to `%s'", lang_printable_name (array_type));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+
+ /* The array index underdoes unary numeric promotion. The promoted
+ type must be int */
+ promoted_index_type = promote_type (index_type);
+ if (promoted_index_type != int_type_node)
+ {
+ int could_cast = can_cast_to_p (index_type, int_type_node);
+ parse_error_context
+ (wfl_operator,
+ (could_cast ? "Incompatible type for `[]'. Explicit cast needed to "
+ "convert `%s' to `int'" : "Incompatible type for `[]'. "
+ "Can't convert `%s' to `int'"),
+ lang_printable_name (index_type));
+ TREE_TYPE (node) = error_mark_node;
+ error_found = 1;
+ }
+
+ /* Now if the index is a var/parm decl, check on its initialization */
+ if (not_initialized_as_it_should_p (index))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (wfl_index, DECL_NAME (index));
+ INITIALIZED_P (index) = 1;
+ }
+
+ if (error_found)
+ return error_mark_node;
+ index = convert (promoted_index_type, index);
+
+ if (TREE_CODE (array_type) == RECORD_TYPE)
+ array_type = promote_type (TYPE_ARRAY_ELEMENT (array_type));
+ if (flag_emit_class_files)
+ {
+ TREE_OPERAND (node, 0)= array;
+ TREE_OPERAND (node, 1)= index;
+ }
+ else
+ node = build_java_arrayaccess (array, array_type, index);
+ TREE_TYPE (node) = array_type;
+ return node;
+}
+
+/* 15.9 Array Creation Expressions */
+
+static tree
+build_newarray_node (type, dims, extra_dims)
+ tree type;
+ tree dims;
+ int extra_dims;
+{
+ tree node =
+ build (CALL_EXPR, NULL_TREE, type, nreverse (dims),
+ build_int_2 (extra_dims, 0));
+ TREE_SET_CODE (node, JAVA_NEW_ARRAY_EXPR);
+ return node;
+}
+
+static tree
+patch_newarray (node)
+ tree node;
+{
+ tree type = TREE_OPERAND (node, 0);
+ tree dims = TREE_OPERAND (node, 1);
+ tree cdim, array_type;
+ int error_found = 0;
+ int ndims = 0;
+ int xdims = TREE_INT_CST_LOW (TREE_OPERAND (node, 2));
+ int total_dims;
+
+ /* Dimension types are verified. It's better for the types to be
+ verified in order. */
+ for (cdim = dims, ndims = 0; cdim; cdim = TREE_CHAIN (cdim), ndims++ )
+ {
+ int dim_error = 0;
+ tree dim = TREE_VALUE (cdim);
+
+ /* Dim might have been saved during its evaluation */
+ dim = (TREE_CODE (dim) == SAVE_EXPR ? dim = TREE_OPERAND (dim, 0) : dim);
+
+ /* The type of each specified dimension must be an integral type. */
+ if (!JINTEGRAL_TYPE_P (TREE_TYPE (dim)))
+ dim_error = 1;
+
+ /* Each expression undergoes an unary numeric promotion (5.6.1) and the
+ promoted type must be int. */
+ else
+ {
+ dim = convert (promote_type (TREE_TYPE (dim)), dim);
+ if (TREE_TYPE (dim) != int_type_node)
+ dim_error = 1;
+ }
+
+ /* Report errors on types here */
+ if (dim_error)
+ {
+ parse_error_context
+ (TREE_PURPOSE (cdim),
+ "Incompatible type for dimension in array creation expression. "
+ "%s convert `%s' to `int'",
+ (can_cast_to_p (TREE_TYPE (dim), int_type_node) ?
+ "Explicit cast needed to" : "Can't"),
+ lang_printable_name (TREE_TYPE (dim)));
+ error_found = 1;
+ }
+
+ /* Check for uninitialized variables */
+ if (not_initialized_as_it_should_p (dim))
+ {
+ ERROR_VARIABLE_NOT_INITIALIZED (TREE_PURPOSE (cdim),
+ DECL_NAME (dim));
+ INITIALIZED_P (dim) = 1;
+ error_found = 1;
+ }
+
+ TREE_PURPOSE (cdim) = NULL_TREE;
+ }
+
+ /* Resolve array base type if unresolved */
+ if (!(type = resolve_type_during_patch (type)))
+ error_found = 1;
+
+ if (error_found)
+ {
+ /* We don't want further evaluation of this bogus array creation
+ operation */
+ TREE_TYPE (node) = error_mark_node;
+ return error_mark_node;
+ }
+
+ /* The node is transformed into a function call. Things are done
+ differently according to the number of dimensions. If the number
+ of dimension is equal to 1, then the nature of the base type
+ (primitive or not) matters. */
+ total_dims = xdims + ndims;
+ if (total_dims == 1)
+ {
+ if (JPRIMITIVE_TYPE_P (type))
+ {
+ int type_code;
+ if (type == boolean_type_node)
+ type_code = 4;
+ else if (type == char_type_node)
+ type_code = 5;
+ else if (type == float_type_node)
+ type_code = 6;
+ else if (type == double_type_node)
+ type_code = 7;
+ else if (type == byte_type_node)
+ type_code = 8;
+ else if (type == short_type_node)
+ type_code = 9;
+ else if (type == int_type_node)
+ type_code = 10;
+ else if (type == long_type_node)
+ type_code = 11;
+ else
+ fatal ("Can't compute type code - patch_newarray");
+ return build_newarray (type_code, TREE_VALUE (dims));
+ }
+ else
+ return build_anewarray (type, TREE_VALUE (dims));
+ }
+
+ /* Add extra dimensions as unknown dimensions */
+ while (xdims--)
+ dims =
+ chainon (dims, build_tree_list (NULL_TREE, integer_negative_one_node));
+ dims = chainon (dims, build_tree_list (NULL_TREE, integer_zero_node));
+
+ /* Can't reuse what's already written in expr.c because it uses the
+ JVM stack representation. Provide a build_multianewarray. FIXME */
+ array_type = type;
+ for (cdim = TREE_CHAIN (dims); cdim; cdim = TREE_CHAIN (cdim))
+ array_type = build_java_array_type (promote_type (array_type),
+ TREE_CODE (cdim) == INTEGER_CST ?
+ TREE_INT_CST_LOW (cdim) : -1);
+ return build (CALL_EXPR,
+ promote_type (array_type),
+ build_address_of (soft_multianewarray_node),
+ tree_cons (NULL_TREE, build_class_ref (array_type),
+ tree_cons (NULL_TREE,
+ build_int_2 (total_dims, 0), dims )),
+ NULL_TREE);
+}
+
+static tree
+build_this (location)
+ int location;
+{
+ tree node = build_wfl_node (this_identifier_node, input_filename, 0, 0);
+ TREE_SET_CODE (node, JAVA_THIS_EXPR);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+/* 14.15 The return statement. It builds a modify expression that
+ assigns the returned value to the RESULT_DECL that hold the value
+ to be returned. */
+
+static tree
+build_return (location, op)
+ int location;
+ tree op;
+{
+ tree node = build1 (RETURN_EXPR, NULL_TREE, op);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+static tree
+patch_return (node)
+ tree node;
+{
+ tree return_exp = TREE_OPERAND (node, 0);
+ tree meth = current_function_decl;
+ tree mtype = TREE_TYPE (TREE_TYPE (current_function_decl));
+ tree modify;
+ int error_found = 0;
+
+ TREE_TYPE (node) = error_mark_node;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* It's invalid to have a return value within a function that is
+ declared with the keyword void or that is a constructor */
+ if (return_exp && (mtype == void_type_node || DECL_CONSTRUCTOR_P (meth)))
+ error_found = 1;
+
+ /* It's invalid to have a no return value within a function that
+ isn't declared with the keyword `void' */
+ if (!return_exp && (mtype != void_type_node && !DECL_CONSTRUCTOR_P (meth)))
+ error_found = 2;
+
+ if (error_found)
+ {
+ char *t = strdup ((char *)lang_printable_name (mtype));
+ parse_error_context (wfl_operator, "`return' with%s value from `%s %s'",
+ (error_found == 1 ? "" : "out"), t,
+ lang_printable_name (meth));
+ free (t);
+ return error_mark_node;
+ }
+
+ /* If we have a return_exp, build a modify expression and expand it */
+ if (return_exp)
+ {
+ modify = build (MODIFY_EXPR, NULL_TREE, DECL_RESULT (meth), return_exp);
+ EXPR_WFL_LINECOL (modify) = EXPR_WFL_LINECOL (node);
+ modify = java_complete_tree (modify);
+ if (modify != error_mark_node)
+ {
+ TREE_SIDE_EFFECTS (modify) = 1;
+ TREE_OPERAND (node, 0) = modify;
+ }
+ else
+ return error_mark_node;
+ }
+ TREE_TYPE (node) = void_type_node;
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* 14.8 The if Statement */
+
+static tree
+build_if_else_statement (location, expression, if_body, else_body)
+ int location;
+ tree expression, if_body, else_body;
+{
+ tree node;
+ /* FIXME: make else body be a void node, where this function is
+ called */
+ if (!else_body)
+ else_body = build (COMPOUND_EXPR, void_type_node, NULL_TREE, NULL_TREE);
+ node = build (COND_EXPR, NULL_TREE, expression, if_body, else_body);
+ EXPR_WFL_LINECOL (node) = location;
+ return node;
+}
+
+static tree
+patch_if_else_statement (node)
+ tree node;
+{
+ tree expression = TREE_OPERAND (node, 0);
+
+ TREE_TYPE (node) = error_mark_node;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* The type of expression must be boolean */
+ if (TREE_TYPE (expression) != boolean_type_node)
+ {
+ parse_error_context
+ (wfl_operator,
+ "Incompatible type for `if'. Can't convert `%s' to `boolean'",
+ lang_printable_name (TREE_TYPE (expression)));
+ return error_mark_node;
+ }
+
+ TREE_TYPE (node) = void_type_node;
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* 14.6 Labeled Statements */
+
+/* Action taken when a lableled statement is parsed. a new
+ LABELED_BLOCK_EXPR is created. No statement is attached to the
+ label, yet. */
+
+static tree
+build_labeled_block (location, label, wfl)
+ int location;
+ tree label, wfl;
+{
+ tree label_name = merge_qualified_name (label_id, label);
+ tree label_decl, node;
+
+ /* Issue a warning if we try to reuse a label that was previously
+ declared */
+ if (IDENTIFIER_LOCAL_VALUE (label_name))
+ {
+ EXPR_WFL_LINECOL (wfl_operator) = location;
+ parse_warning_context (wfl_operator, "Declaration of `%s' shadows "
+ "a previous declaration",
+ IDENTIFIER_POINTER (label));
+ EXPR_WFL_LINECOL (wfl_operator) =
+ EXPR_WFL_LINECOL (IDENTIFIER_LOCAL_VALUE (label_name));
+ parse_warning_context (wfl_operator, "This is the location of the "
+ "previous declaration of label `%s'",
+ IDENTIFIER_POINTER (label));
+ java_warning_count--;
+ }
+
+ label_decl = create_label_decl (label_name);
+ node = build (LABELED_BLOCK_EXPR, NULL_TREE, label_decl, NULL_TREE);
+ EXPR_WFL_LINECOL (node) = location;
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* Generate a label crafting a unique name for it. This is used to
+ implicitely label loops that aren't the body part of labeled
+ statement. */
+
+static tree
+generate_labeled_block ()
+{
+ static int l_number = 0;
+ char buf [20];
+ tree label_name;
+
+ sprintf (buf, "$a%d", l_number++);
+ return build_labeled_block (0, get_identifier (buf), NULL_TREE);
+}
+
+/* A labeled statement LBE is attached a statement. If the statement
+ happens to be a loop, a link from the loop back to the label is
+ installed. */
+
+static tree
+complete_labeled_statement (lbe, statement)
+ tree lbe; /* Labeled block expr */
+ tree statement;
+{
+ /* In anyways, tie the loop to its statement */
+ LABELED_BLOCK_BODY (lbe) = statement;
+
+ /* Ok, if statement is a for loop, we have to attach the labeled
+ statement to the block the for loop belongs to and return the
+ block instead */
+ if (TREE_CODE (statement) == LOOP_EXPR && IS_FOR_LOOP_P (statement))
+ {
+ java_method_add_stmt (current_function_decl, lbe);
+ return exit_block ();
+ }
+
+ return lbe;
+}
+
+/* 14.10, 14.11, 14.12 Loop Statements */
+
+/* Create an empty LOOP_EXPR and make it the last in the nested loop
+ list. */
+
+static tree
+build_new_loop (loop_body)
+ tree loop_body;
+{
+ tree loop = build (LOOP_EXPR, NULL_TREE, loop_body);
+ TREE_SIDE_EFFECTS (loop) = 1;
+ PUSH_LOOP (loop);
+ return loop;
+}
+
+/* Create a loop body according to the following structure:
+ COMPOUND_EXPR
+ COMPOUND_EXPR (loop main body)
+ EXIT_EXPR (this order is for while/for loops.
+ LABELED_BLOCK_EXPR the order is reversed for do loops)
+ LABEL_DECL (continue occurding here branche at the
+ BODY end of this labeled block)
+ INCREMENT (if any)
+
+ REVERSED, if non zero, tells that the loop condition expr comes
+ after the body, like in the do-while loop. */
+
+static tree
+build_loop_body (location, condition, reversed)
+ int location;
+ tree condition;
+ int reversed;
+{
+ tree first, second, label, body;
+
+ condition = build (EXIT_EXPR, NULL_TREE, condition); /* Force walk */
+ EXPR_WFL_LINECOL (condition) = location; /* For accurate error report */
+ condition = build_debugable_stmt (location, condition);
+ TREE_SIDE_EFFECTS (condition) = 1;
+
+ body = generate_labeled_block ();
+ first = (reversed ? body : condition);
+ second = (reversed ? condition : body);
+ return
+ build (COMPOUND_EXPR, NULL_TREE,
+ build (COMPOUND_EXPR, NULL_TREE, first, second), size_zero_node);
+}
+
+/* Install CONDITION (if any) and loop BODY (using REVERSED to tell
+ their order) on the current loop. Unlink the current loop from the
+ loop list. */
+
+static tree
+complete_loop_body (location, condition, body, reversed)
+ int location;
+ tree condition, body;
+ int reversed;
+{
+ tree to_return = ctxp->current_loop;
+ tree loop_body = LOOP_EXPR_BODY (to_return);
+ if (condition)
+ {
+ tree cnode = LOOP_EXPR_BODY_CONDITION_EXPR (loop_body, reversed);
+ /* We wrapped the EXIT_EXPR around a WFL so we can debug it.
+ The real EXIT_EXPR is one operand further. */
+ EXPR_WFL_LINECOL (cnode) = location;
+ /* This one is for accurate error reports */
+ EXPR_WFL_LINECOL (TREE_OPERAND (cnode, 0)) = location;
+ TREE_OPERAND (TREE_OPERAND (cnode, 0), 0) = condition;
+ }
+ LOOP_EXPR_BODY_BODY_EXPR (loop_body, reversed) = body;
+ POP_LOOP ();
+ return to_return;
+}
+
+/* Tailored version of complete_loop_body for FOR loops, when FOR
+ loops feature the condition part */
+
+static tree
+complete_for_loop (location, condition, update, body)
+ int location;
+ tree condition, update, body;
+{
+ /* Put the condition and the loop body in place */
+ tree loop = complete_loop_body (location, condition, body, 0);
+ /* LOOP is the current loop which has been now popped of the loop
+ stack. Install the update block */
+ LOOP_EXPR_BODY_UPDATE_BLOCK (LOOP_EXPR_BODY (loop)) = update;
+ return loop;
+}
+
+/* If the loop isn't surrounded by a labeled statement, create one and
+ insert LOOP as it's body. */
+
+static tree
+patch_loop_statement (loop)
+ tree loop;
+{
+ tree cbl, loop_label, to_return_as_loop;
+
+ if (LOOP_HAS_LABEL_P (loop))
+ {
+ loop_label = ctxp->current_labeled_block;
+ to_return_as_loop = loop;
+ }
+ else
+ {
+ loop_label = generate_labeled_block ();
+ LABELED_BLOCK_BODY (loop_label) = loop;
+ PUSH_LABELED_BLOCK (loop_label);
+ to_return_as_loop = loop_label;
+ }
+ TREE_TYPE (to_return_as_loop) = void_type_node;
+ return to_return_as_loop;
+}
+
+/* 14.13, 14.14: break and continue Statements */
+
+/* Build a break or a continue statement. a null NAME indicates an
+ unlabeled break/continue statement. */
+
+static tree
+build_bc_statement (location, is_break, name)
+ int location, is_break;
+ tree name;
+{
+ tree break_continue, label_block_expr = NULL_TREE;
+
+ if (name)
+ {
+ if (!(label_block_expr = IDENTIFIER_LOCAL_VALUE
+ (merge_qualified_name (label_id, EXPR_WFL_NODE (name)))))
+ /* Null means that we don't have a target for this named
+ break/continue. In this case, we make the target to be the
+ label name, so that the error can be reported accuratly in
+ patch_bc_statement. */
+ label_block_expr = EXPR_WFL_NODE (name);
+ }
+ /* Unlabeled break/continue will be handled during the
+ break/continue patch operation */
+ break_continue
+ = build (EXIT_BLOCK_EXPR, NULL_TREE, label_block_expr, NULL_TREE);
+
+ IS_BREAK_STMT_P (break_continue) = is_break;
+ TREE_SIDE_EFFECTS (break_continue) = 1;
+ EXPR_WFL_LINECOL (break_continue) = location;
+ return break_continue;
+}
+
+/* Verification of a break/continue statement. */
+
+static tree
+patch_bc_statement (node)
+ tree node;
+{
+ tree bc_label = EXIT_BLOCK_LABELED_BLOCK (node), target_stmt;
+ int is_unlabeled = 0;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* Not having a target means that the break/continue statement is
+ unlabeled. We try to find a descent label for it */
+ if (!bc_label)
+ {
+ is_unlabeled = 1;
+ /* There should be a loop to branch to */
+ if (ctxp->current_loop)
+ {
+ /* At that stage, we're in the loop body, which is
+ encapsulated around a LABELED_BLOCK_EXPR. So searching
+ the current loop label requires us to consider the
+ labeled block before the current one. */
+ if (!LOOP_HAS_LABEL_SKIP_P (ctxp->current_loop))
+ fatal ("unlabeled loop has not installed label -- "
+ "patch_bc_statement");
+ bc_label = TREE_CHAIN (ctxp->current_labeled_block);
+ }
+ /* Not having a loop to break/continue to is an error */
+ else
+ {
+ parse_error_context (wfl_operator, "`%s' must be in loop%s",
+ (IS_BREAK_STMT_P (node) ? "break" : "continue"),
+ (IS_BREAK_STMT_P (node) ? " or switch" : ""));
+ return error_mark_node;
+ }
+ }
+ /* Having an identifier here means that the target is unknown. */
+ else if (TREE_CODE (bc_label) == IDENTIFIER_NODE)
+ {
+ parse_error_context (wfl_operator, "No label definition found for `%s'",
+ IDENTIFIER_POINTER (bc_label));
+ return error_mark_node;
+ }
+
+ /* Find the statement we're targeting. */
+ target_stmt = LABELED_BLOCK_BODY (bc_label);
+
+ /* 14.13 The break Statement */
+ if (IS_BREAK_STMT_P (node))
+ {
+ /* Named break are always fine, as far as they have a target
+ (already verified). Anonymous break need to target
+ while/do/for/switch */
+ if (is_unlabeled &&
+ !(TREE_CODE (target_stmt) == LOOP_EXPR /* do/while/for */
+ || 0)) /* switch FIXME */
+ {
+ parse_error_context (wfl_operator,
+ "`break' must be in loop or switch");
+ return error_mark_node;
+ }
+ /* If previously unlabeled, install the new found label */
+ if (is_unlabeled)
+ EXIT_BLOCK_LABELED_BLOCK (node) = bc_label;
+ }
+ /* 14.14 The continue Statement */
+ /* The continue statement must always target a loop */
+ else
+ {
+ if (TREE_CODE (target_stmt) != LOOP_EXPR) /* do/while/for */
+ {
+ parse_error_context (wfl_operator, "`continue' must be in loop");
+ return error_mark_node;
+ }
+ /* Everything looks good. We can fix the `continue' jump to go
+ at the place in the loop were the continue is. The continue
+ is the current labeled block, by construction. */
+ EXIT_BLOCK_LABELED_BLOCK (node) = ctxp->current_labeled_block;
+ }
+
+ /* Our break/continue don't return values. */
+ TREE_TYPE (node) = void_type_node;
+ /* Encapsulate the break within a compound statement so that it's
+ expanded all the times by expand_expr (and not clobered
+ sometimes, like after a if statement) */
+ node = add_stmt_to_compound (NULL_TREE, void_type_node, node);
+ TREE_SIDE_EFFECTS (node) = 1;
+ return node;
+}
+
+/* Process the exit expression belonging to a loop. Its type must be
+ boolean. */
+
+static tree
+patch_exit_expr (node)
+ tree node;
+{
+ tree expression = TREE_OPERAND (node, 0);
+ TREE_TYPE (node) = error_mark_node;
+ EXPR_WFL_LINECOL (wfl_operator) = EXPR_WFL_LINECOL (node);
+
+ /* The type of expression must be boolean */
+ if (TREE_TYPE (expression) != boolean_type_node)
+ {
+ parse_error_context
+ (wfl_operator,
+ "Incompatible type for loop conditional. Can't convert `%s' to "
+ "`boolean'",
+ lang_printable_name (TREE_TYPE (expression)));
+ return error_mark_node;
+ }
+ /* Now we know things are allright, invert the condition, fold and
+ return */
+ TREE_OPERAND (node, 0) =
+ fold (build1 (TRUTH_NOT_EXPR, boolean_type_node, expression));
+ TREE_TYPE (node) = void_type_node;
+ return node;
+}
--- /dev/null
+/* Handle types for the GNU compiler for the Java(TM) language.
+ Copyright (C) 1996 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Written by Per Bothner <bothner@cygnus.com> */
+
+#include "config.h"
+#include "tree.h"
+#include "obstack.h"
+#include "java-tree.h"
+#include "jcf.h"
+#include "convert.h"
+
+tree * type_map;
+extern struct obstack permanent_obstack;
+
+/* Set the type of the local variable with index SLOT to TYPE. */
+
+void
+set_local_type (slot, type)
+ int slot;
+ tree type;
+{
+ int max_locals = DECL_MAX_LOCALS(current_function_decl);
+ int nslots = TYPE_IS_WIDE (type) ? 2 : 1;
+ if (slot < 0 || slot + nslots - 1 >= max_locals)
+ fatal ("invalid local variable index");
+ type_map[slot] = type;
+ while (--nslots > 0)
+ type_map[++slot] = void_type_node;
+}
+
+extern tree convert_to_integer (tree type, tree expr);
+extern tree convert_to_real (tree type, tree expr);
+extern tree convert_to_pointer (tree type, tree expr);
+
+/* 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 enum tree_code code = TREE_CODE (type);
+
+ if (type == TREE_TYPE (expr)
+ || TREE_CODE (expr) == ERROR_MARK)
+ return expr;
+ if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
+ return error_mark_node;
+ if (code == BOOLEAN_TYPE)
+ return fold (convert_to_boolean (type, expr));
+ if (code == INTEGER_TYPE)
+ return fold (convert_to_integer (type, expr));
+ if (code == REAL_TYPE)
+ return fold (convert_to_real (type, expr));
+ if (code == CHAR_TYPE)
+ return fold (convert_to_char (type, expr));
+ if (code == POINTER_TYPE)
+ return fold (convert_to_pointer (type, expr));
+ error ("conversion to non-scalar type requested");
+ return error_mark_node;
+}
+
+tree
+convert_to_char (type, expr)
+ tree type, expr;
+{
+ return build1 (NOP_EXPR, type, expr);
+}
+
+tree
+convert_to_boolean (type, expr)
+ tree type, expr;
+{
+ return build1 (NOP_EXPR, type, expr);
+}
+
+/* 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;
+{
+ error ("internal error - use of undefined type");
+}
+
+/* Return a data type that has machine mode MODE.
+ If the mode is an integer,
+ then UNSIGNEDP selects between signed and unsigned types. */
+
+tree
+type_for_mode (mode, unsignedp)
+ enum machine_mode mode;
+ int unsignedp;
+{
+ if (mode == TYPE_MODE (int_type_node))
+ return unsignedp ? unsigned_int_type_node : int_type_node;
+ if (mode == TYPE_MODE (long_type_node))
+ return unsignedp ? unsigned_long_type_node : long_type_node;
+ if (mode == TYPE_MODE (short_type_node))
+ return unsignedp ? unsigned_short_type_node : short_type_node;
+ if (mode == TYPE_MODE (byte_type_node))
+ return unsignedp ? unsigned_byte_type_node : byte_type_node;
+ if (mode == TYPE_MODE (float_type_node))
+ return float_type_node;
+ if (mode == TYPE_MODE (double_type_node))
+ return double_type_node;
+
+#if 0
+ if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
+ return build_pointer_type (char_type_node);
+
+ if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
+ return build_pointer_type (integer_type_node);
+#endif
+
+ return 0;
+}
+
+/* Return an integer type with BITS bits of precision,
+ that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
+
+tree
+type_for_size (bits, unsignedp)
+ unsigned bits;
+ int unsignedp;
+{
+ if (bits <= TYPE_PRECISION (byte_type_node))
+ return unsignedp ? unsigned_byte_type_node : byte_type_node;
+ if (bits <= TYPE_PRECISION (short_type_node))
+ return unsignedp ? unsigned_short_type_node : short_type_node;
+ if (bits <= TYPE_PRECISION (int_type_node))
+ return unsignedp ? unsigned_int_type_node : int_type_node;
+ if (bits <= TYPE_PRECISION (long_type_node))
+ return unsignedp ? unsigned_long_type_node : long_type_node;
+ return 0;
+}
+
+/* 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 (! INTEGRAL_TYPE_P (type))
+ return type;
+ if (TYPE_PRECISION (type) == TYPE_PRECISION (int_type_node))
+ return unsignedp ? unsigned_int_type_node : int_type_node;
+ if (TYPE_PRECISION (type) == TYPE_PRECISION (byte_type_node))
+ return unsignedp ? unsigned_byte_type_node : byte_type_node;
+ if (TYPE_PRECISION (type) == TYPE_PRECISION (short_type_node))
+ return unsignedp ? unsigned_short_type_node : short_type_node;
+ if (TYPE_PRECISION (type) == TYPE_PRECISION (long_type_node))
+ return unsignedp ? unsigned_long_type_node : long_type_node;
+ return type;
+}
+
+/* Return a signed type the same as TYPE in other respects. */
+
+tree
+signed_type (type)
+ tree type;
+{
+ return signed_or_unsigned_type (0, type);
+}
+
+/* Return an unsigned type the same as TYPE in other respects. */
+
+tree
+unsigned_type (type)
+ tree type;
+{
+ return signed_or_unsigned_type (1, type);
+
+}
+
+/* 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. */
+
+int
+mark_addressable (exp)
+ tree exp;
+{
+ register tree x = exp;
+ while (1)
+ switch (TREE_CODE (x))
+ {
+ case ADDR_EXPR:
+ case COMPONENT_REF:
+ case ARRAY_REF:
+ case REALPART_EXPR:
+ case IMAGPART_EXPR:
+ x = TREE_OPERAND (x, 0);
+ break;
+
+ case TRUTH_ANDIF_EXPR:
+ case TRUTH_ORIF_EXPR:
+ case COMPOUND_EXPR:
+ x = TREE_OPERAND (x, 1);
+ break;
+
+ case COND_EXPR:
+ return mark_addressable (TREE_OPERAND (x, 1))
+ & mark_addressable (TREE_OPERAND (x, 2));
+
+ case CONSTRUCTOR:
+ TREE_ADDRESSABLE (x) = 1;
+ return 1;
+
+ case INDIRECT_REF:
+ /* We sometimes add a cast *(TYPE*)&FOO to handle type and mode
+ incompatibility problems. Handle this case by marking FOO. */
+ if (TREE_CODE (TREE_OPERAND (x, 0)) == NOP_EXPR
+ && TREE_CODE (TREE_OPERAND (TREE_OPERAND (x, 0), 0)) == ADDR_EXPR)
+ {
+ x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
+ break;
+ }
+ if (TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
+ {
+ x = TREE_OPERAND (x, 0);
+ break;
+ }
+ return 1;
+
+ case VAR_DECL:
+ case CONST_DECL:
+ case PARM_DECL:
+ case RESULT_DECL:
+ case FUNCTION_DECL:
+ TREE_ADDRESSABLE (x) = 1;
+#if 0 /* poplevel deals with this now. */
+ if (DECL_CONTEXT (x) == 0)
+ TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
+#endif
+ /* drops through */
+ default:
+ return 1;
+ }
+}
+
+/* Thorough checking of the arrayness of TYPE. */
+
+int
+is_array_type_p (type)
+ tree type;
+{
+ return TREE_CODE (type) == POINTER_TYPE
+ && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
+ && TYPE_ARRAY_P (TREE_TYPE (type));
+}
+
+/* Return the length of a Java array type.
+ Return -1 if the length is unknown or non-constant. */
+
+HOST_WIDE_INT
+java_array_type_length (array_type)
+ tree array_type;
+{
+ tree arfld;
+ if (TREE_CODE (array_type) == POINTER_TYPE)
+ array_type = TREE_TYPE (array_type);
+ arfld = TREE_CHAIN (TREE_CHAIN (TYPE_FIELDS (array_type)));
+ if (arfld != NULL_TREE)
+ {
+ tree index_type = TYPE_DOMAIN (TREE_TYPE (arfld));
+ tree high = TYPE_MAX_VALUE (index_type);
+ if (TREE_CODE (high) == INTEGER_CST)
+ return TREE_INT_CST_LOW (high) + 1;
+ }
+ return -1;
+}
+
+tree
+build_prim_array_type (element_type, length)
+ tree element_type;
+ HOST_WIDE_INT length;
+{
+ tree max_index = build_int_2 (length - 1, 0);
+ TREE_TYPE (max_index) = sizetype;
+ return build_array_type (element_type, build_index_type (max_index));
+}
+
+/* Return a Java array type with a given ELEMENT_TYPE and LENGTH.
+ These are hashed (shared) using IDENTIFIER_SIGNATURE_TYPE.
+ The LENGTH is -1 if the length is unknown. */
+
+tree
+build_java_array_type (element_type, length)
+ tree element_type;
+ HOST_WIDE_INT length;
+{
+ tree sig, t, fld;
+ char buf[12];
+ tree elsig = build_java_signature (element_type);
+ tree el_name = element_type;
+ sprintf (buf, length >= 0 ? "[%d" : "[", length);
+ sig = ident_subst (IDENTIFIER_POINTER (elsig), IDENTIFIER_LENGTH (elsig),
+ buf, 0, 0, "");
+ t = IDENTIFIER_SIGNATURE_TYPE (sig);
+ if (t != NULL_TREE)
+ return t;
+ t = make_class ();
+ IDENTIFIER_SIGNATURE_TYPE (sig) = t;
+ TYPE_ARRAY_P (t) = 1;
+
+ if (TREE_CODE (el_name) == POINTER_TYPE)
+ el_name = TREE_TYPE (el_name);
+ el_name = TYPE_NAME (el_name);
+ if (TREE_CODE (el_name) == TYPE_DECL)
+ el_name = DECL_NAME (el_name);
+ TYPE_NAME (t) = identifier_subst (el_name, "", '.', '.', "[]");
+
+ set_java_signature (t, sig);
+ set_super_info (0, t, object_type_node, 0);
+ TYPE_ARRAY_ELEMENT (t) = element_type;
+
+ /* Add length pseudo-field. */
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ fld = build_decl (FIELD_DECL, get_identifier ("length"), int_type_node);
+ TYPE_FIELDS (t) = fld;
+ DECL_CONTEXT (fld) = t;
+ FIELD_PUBLIC (fld) = 1;
+ FIELD_FINAL (fld) = 1;
+
+ if (length >= 0)
+ {
+ tree atype = build_prim_array_type (element_type, length);
+ tree arfld = build_decl (FIELD_DECL, get_identifier ("data"), atype);
+ DECL_CONTEXT (arfld) = t;
+ TREE_CHAIN (fld) = arfld;
+ }
+ else
+ TYPE_ALIGN (t) = TYPE_ALIGN (element_type);
+ pop_obstacks ();
+
+ layout_class (t);
+ return t;
+}
+
+/* Promote TYPE to the type actually used for fields and parameters. */
+
+tree
+promote_type (type)
+ tree type;
+{
+ switch (TREE_CODE (type))
+ {
+ case RECORD_TYPE:
+ return build_pointer_type (CLASS_TO_HANDLE_TYPE (type));
+ case BOOLEAN_TYPE:
+ if (type == boolean_type_node)
+ return promoted_boolean_type_node;
+ goto handle_int;
+ case CHAR_TYPE:
+ if (type == char_type_node)
+ return promoted_char_type_node;
+ goto handle_int;
+ case INTEGER_TYPE:
+ handle_int:
+ if (TYPE_PRECISION (type) < TYPE_PRECISION (int_type_node))
+ {
+ if (type == short_type_node)
+ return promoted_short_type_node;
+ if (type == byte_type_node)
+ return promoted_byte_type_node;
+ return int_type_node;
+ }
+ /* ... else fall through ... */
+ default:
+ return type;
+ }
+}
+
+/* Parse a signature string, starting at *PTR and ending at LIMIT.
+ Return the seen TREE_TYPE, updating *PTR. */
+
+static tree
+parse_signature_type (ptr, limit)
+ const unsigned char **ptr, *limit;
+{
+ if ((*ptr) >= limit)
+ fatal ("bad signature string");
+ switch (*(*ptr))
+ {
+ case 'B': (*ptr)++; return byte_type_node;
+ case 'C': (*ptr)++; return char_type_node;
+ case 'D': (*ptr)++; return double_type_node;
+ case 'F': (*ptr)++; return float_type_node;
+ case 'S': (*ptr)++; return short_type_node;
+ case 'I': (*ptr)++; return int_type_node;
+ case 'J': (*ptr)++; return long_type_node;
+ case 'Z': (*ptr)++; return boolean_type_node;
+ case 'V': (*ptr)++; return void_type_node;
+ case '[':
+ for ((*ptr)++; (*ptr) < limit && isdigit (**ptr); ) (*ptr)++;
+ {
+ tree element_type = parse_signature_type (ptr, limit);
+ if (TREE_CODE (element_type) == RECORD_TYPE)
+ element_type = promote_type (element_type);
+ return build_java_array_type (element_type, -1);
+ }
+ case 'L':
+ {
+ const unsigned char *start = ++(*ptr);
+ register const unsigned char *str = start;
+ for ( ; ; str++)
+ {
+ if (str >= limit)
+ fatal ("bad signature string");
+ if (*str == ';')
+ break;
+ }
+ *ptr = str+1;
+ return lookup_class (unmangle_classname (start, str - start));
+ }
+ default:
+ fatal ("unrecognized signature string");
+ }
+}
+
+/* Parse a Java "mangled" signature string, starting at SIG_STRING,
+ and SIG_LENGTH bytes long.
+ Return a gcc type node. */
+
+tree
+parse_signature_string (sig_string, sig_length)
+ const unsigned char *sig_string;
+ int sig_length;
+{
+ tree result_type;
+ const unsigned char *str = sig_string;
+ const unsigned char *limit = str + sig_length;
+
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ if (str < limit && str[0] == '(')
+ {
+ tree argtype_list = NULL_TREE;
+ str++;
+ while (str < limit && str[0] != ')')
+ {
+ tree argtype = promote_type (parse_signature_type (&str, limit));
+ argtype_list = tree_cons (NULL_TREE, argtype, argtype_list);
+ }
+ if (str++, str >= limit)
+ fatal ("bad signature string");
+ result_type = promote_type (parse_signature_type (&str, limit));
+ result_type = build_function_type (result_type,
+ nreverse (argtype_list));
+ }
+ else
+ result_type = parse_signature_type (&str, limit);
+ if (str != limit)
+ error ("junk at end of signature string");
+ pop_obstacks ();
+ return result_type;
+}
+
+/* Convert a signature to its type.
+ * Uses IDENTIFIER_SIGNATURE_TYPE as a cache (except for primitive types).
+ */
+
+tree
+get_type_from_signature (tree signature)
+{
+ unsigned char *sig = (unsigned char *) IDENTIFIER_POINTER (signature);
+ int len = IDENTIFIER_LENGTH (signature);
+ tree type;
+ /* Primitive types aren't cached. */
+ if (len <= 1)
+ return parse_signature_string (sig, len);
+ type = IDENTIFIER_SIGNATURE_TYPE (signature);
+ if (type == NULL_TREE)
+ {
+ type = parse_signature_string (sig, len);
+ IDENTIFIER_SIGNATURE_TYPE (signature) = type;
+ }
+ return type;
+}
+
+/* Return the signature string for the arguments of method type TYPE. */
+
+tree
+build_java_argument_signature (type)
+ tree type;
+{
+ extern struct obstack temporary_obstack;
+ tree sig = TYPE_ARGUMENT_SIGNATURE (type);
+ if (sig == NULL_TREE)
+ {
+ tree args = TYPE_ARG_TYPES (type);
+ if (TREE_CODE (type) == METHOD_TYPE)
+ args = TREE_CHAIN (args); /* Skip "this" argument. */
+ for (; args != NULL_TREE; args = TREE_CHAIN (args))
+ {
+ tree t = build_java_signature (TREE_VALUE (args));
+ obstack_grow (&temporary_obstack,
+ IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
+ }
+ obstack_1grow (&temporary_obstack, '\0');
+
+ sig = get_identifier (obstack_base (&temporary_obstack));
+ TYPE_ARGUMENT_SIGNATURE (type) = sig;
+ obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));
+ }
+ return sig;
+}
+
+/* Return the signature of the given TYPE. */
+
+tree
+build_java_signature (type)
+ tree type;
+{
+ tree sig, t;
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+ while (TREE_CODE (type) == POINTER_TYPE)
+ type = TREE_TYPE (type);
+ if (TYPE_LANG_SPECIFIC (type) == NULL)
+ {
+ TYPE_LANG_SPECIFIC (type) = (struct lang_type *)
+ perm_calloc (1, sizeof (struct lang_type));
+
+ }
+ sig = TYPE_LANG_SPECIFIC (type)->signature;
+ if (sig == NULL_TREE)
+ {
+ char sg[2];
+ switch (TREE_CODE (type))
+ {
+ case BOOLEAN_TYPE: sg[0] = 'Z'; goto native;
+ case CHAR_TYPE: sg[0] = 'C'; goto native;
+ case VOID_TYPE: sg[0] = 'V'; goto native;
+ case INTEGER_TYPE:
+ switch (TYPE_PRECISION (type))
+ {
+ case 8: sg[0] = 'B'; goto native;
+ case 16: sg[0] = 'S'; goto native;
+ case 32: sg[0] = 'I'; goto native;
+ case 64: sg[0] = 'J'; goto native;
+ default: goto bad_type;
+ }
+ case REAL_TYPE:
+ switch (TYPE_PRECISION (type))
+ {
+ case 32: sg[0] = 'F'; goto native;
+ case 64: sg[0] = 'D'; goto native;
+ default: goto bad_type;
+ }
+ native:
+ sg[1] = 0;
+ sig = get_identifier (sg);
+ break;
+ case RECORD_TYPE:
+ if (TYPE_ARRAY_P (type))
+ {
+ t = build_java_signature (TYPE_ARRAY_ELEMENT (type));
+ sig = ident_subst (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t),
+ "[", 0, 0, "");
+ }
+ else
+ {
+ t = DECL_NAME (TYPE_NAME (type));
+ sig = ident_subst (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t),
+ "L", '.', '/', ";");
+ }
+ break;
+ case METHOD_TYPE:
+ case FUNCTION_TYPE:
+ {
+ extern struct obstack temporary_obstack;
+ sig = build_java_argument_signature (type);
+ obstack_1grow (&temporary_obstack, '(');
+ obstack_grow (&temporary_obstack,
+ IDENTIFIER_POINTER (sig), IDENTIFIER_LENGTH (sig));
+ obstack_1grow (&temporary_obstack, ')');
+
+ t = build_java_signature (TREE_TYPE (type));
+ obstack_grow0 (&temporary_obstack,
+ IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
+
+ sig = get_identifier (obstack_base (&temporary_obstack));
+ obstack_free (&temporary_obstack,
+ obstack_base (&temporary_obstack));
+ }
+ break;
+ bad_type:
+ default:
+ fatal ("internal error - build_java_signature passed invalid type");
+ }
+ TYPE_LANG_SPECIFIC (type)->signature = sig;
+ }
+ pop_obstacks ();
+ return sig;
+}
+
+/* Save signature string SIG (an IDENTIFIER_NODE) in TYPE for future use. */
+
+void
+set_java_signature (type, sig)
+ tree type;
+ tree sig;
+{
+ tree old_sig;
+ while (TREE_CODE (type) == POINTER_TYPE)
+ type = TREE_TYPE (type);
+ if (TYPE_LANG_SPECIFIC (type) == NULL)
+ {
+ TYPE_LANG_SPECIFIC (type) = (struct lang_type *)
+ perm_calloc (1, sizeof (struct lang_type));
+
+ }
+ old_sig = TYPE_LANG_SPECIFIC (type)->signature;
+ if (old_sig != NULL_TREE && old_sig != sig)
+ fatal ("internal error - set_java_signature");
+ TYPE_LANG_SPECIFIC (type)->signature = sig;
+#if 0 /* careful about METHOD_TYPE */
+ if (IDENTIFIER_SIGNATURE_TYPE (sig) == NULL_TREE && TREE_PERMANENT (type))
+ IDENTIFIER_SIGNATURE_TYPE (sig) = type;
+#endif
+}
+
+/* Search in class CLAS (and its superclasses) for a method
+ matching METHOD_NAME and argument signature METHOD_SIGNATURE.
+ Return a FUNCTION_DECL on success, or NULL_TREE if none found.
+ (Contrast lookup_java_method, which takes into account return type.) */
+
+tree
+lookup_argument_method (clas, method_name, method_signature)
+ tree clas, method_name, method_signature;
+{
+ tree method;
+ while (clas != NULL_TREE)
+ {
+ for (method = TYPE_METHODS (clas);
+ method != NULL_TREE; method = TREE_CHAIN (method))
+ {
+ tree method_sig = build_java_argument_signature (TREE_TYPE (method));
+ if (DECL_NAME (method) == method_name && method_sig == method_signature)
+ return method;
+ }
+ clas = CLASSTYPE_SUPER (clas);
+ }
+ return NULL_TREE;
+}
+
+/* Search in class CLAS (and its superclasses) for a method
+ matching METHOD_NAME and signature METHOD_SIGNATURE.
+ Return a FUNCTION_DECL on success, or NULL_TREE if none found.
+ (Contrast lookup_argument_method, which ignores return type.) */
+
+tree
+lookup_java_method (clas, method_name, method_signature)
+ tree clas, method_name, method_signature;
+{
+ tree method;
+ while (clas != NULL_TREE)
+ {
+ for (method = TYPE_METHODS (clas);
+ method != NULL_TREE; method = TREE_CHAIN (method))
+ {
+ tree method_sig = build_java_signature (TREE_TYPE (method));
+ if (DECL_NAME (method) == method_name && method_sig == method_signature)
+ return method;
+ }
+ clas = CLASSTYPE_SUPER (clas);
+ }
+ return NULL_TREE;
+}
+
+/* Search in class CLAS (and its superclasses) for methods matching
+ METHOD_NAME and METHOD_SIGNATURE. Return a list of FUNCTION_DECLs.
+ When called from here, build_java_signature doesn't take the
+ returned type into account. */
+
+tree
+match_java_method (clas, method_name, method_signature)
+ tree clas, method_name, method_signature;
+{
+ tree method;
+ tree list = NULL_TREE;
+ while (clas != NULL_TREE)
+ {
+ for (method = TYPE_METHODS (clas);
+ method != NULL_TREE; method = TREE_CHAIN (method))
+ {
+ tree method_sig = build_java_argument_signature (TREE_TYPE (method));
+ if (DECL_NAME (method) == method_name
+ && method_sig == method_signature)
+ list = tree_cons (NULL_TREE, method, list);
+ }
+ clas = CLASSTYPE_SUPER (clas);
+ }
+ return list;
+}
+
+/* Search in class CLAS for a constructor matching METHOD_SIGNATURE.
+ Return a FUNCTION_DECL on success, or NULL_TREE if none found. */
+
+tree
+lookup_java_constructor (clas, method_signature)
+ tree clas, method_signature;
+{
+ tree method = TYPE_METHODS (clas);
+ for ( ; method != NULL_TREE; method = TREE_CHAIN (method))
+ {
+ tree method_sig = build_java_signature (TREE_TYPE (method));
+ if (DECL_CONSTRUCTOR_P (method) && method_sig == method_signature)
+ return method;
+ }
+ return NULL_TREE;
+}
+
+/* Return a type which is the Binary Numeric Promotion of the pair T1,
+ T2 and convert EXP1 and/or EXP2. See 5.6.2 Binary Numeric
+ Promotion. It assumes that both T1 and T2 are elligible to BNP. */
+
+tree
+binary_numeric_promotion (t1, t2, exp1, exp2)
+ tree t1;
+ tree t2;
+ tree *exp1;
+ tree *exp2;
+{
+ if (t1 == double_type_node || t2 == double_type_node)
+ {
+ if (t1 != double_type_node)
+ *exp1 = convert (double_type_node, *exp1);
+ if (t2 != double_type_node)
+ *exp2 = convert (double_type_node, *exp2);
+ return double_type_node;
+ }
+ if (t1 == float_type_node || t2 == float_type_node)
+ {
+ if (t1 != float_type_node)
+ *exp1 = convert (float_type_node, *exp1);
+ if (t2 != float_type_node)
+ *exp2 = convert (float_type_node, *exp2);
+ return float_type_node;
+ }
+ if (t1 == long_type_node || t2 == long_type_node)
+ {
+ if (t1 != long_type_node)
+ *exp1 = convert (long_type_node, *exp1);
+ if (t2 != long_type_node)
+ *exp2 = convert (long_type_node, *exp2);
+ return long_type_node;
+ }
+
+ if (t1 != int_type_node)
+ *exp1 = convert (int_type_node, *exp1);
+ if (t2 != int_type_node)
+ *exp2 = convert (int_type_node, *exp2);
+ return int_type_node;
+}
--- /dev/null
+/* Handle verification of bytecoded methods for the GNU compiler for
+ the Java(TM) language.
+ Copyright (C) 1997 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, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+#include <stdio.h>
+#include "config.h"
+#include "tree.h"
+#include "java-tree.h"
+#include "javaop.h"
+#include "java-opcodes.h"
+#include "jcf.h"
+#include "java-except.h"
+
+extern int stack_pointer;
+
+/* During verification, start of the current subroutine (jsr target). */
+tree current_subr;
+
+/* A list of pending blocks, chained using LABEL_PENDING_CHAIN.
+ A pending block is one that has LABEL_CHANGED set, which means
+ it requires (re-) verification. */
+tree pending_blocks;
+
+/* Append TARGET_LABEL to the pending_block stack unless already in it. */
+
+void
+push_pending_label (target_label)
+ tree target_label;
+{
+ if (! LABEL_CHANGED (target_label))
+ {
+ LABEL_PENDING_CHAIN (target_label) = pending_blocks;
+ pending_blocks = target_label;
+ LABEL_CHANGED (target_label) = 1;
+ }
+}
+
+/* Note that TARGET_LABEL is a possible successor instruction.
+ Merge the type state etc.
+ Return NULL on sucess, or an error message on failure. */
+
+static char *
+check_pending_block (target_label)
+ tree target_label;
+{
+ int changed = merge_type_state (target_label);
+
+ if (changed)
+ {
+ if (changed < 0)
+ return "types could not be merged";
+ push_pending_label (target_label);
+ }
+
+ if (current_subr == NULL)
+ {
+ if (LABEL_IN_SUBR (target_label))
+ return "might transfer control into subroutine";
+ }
+ else
+ {
+ if (LABEL_IN_SUBR (target_label))
+ {
+ if (LABEL_SUBR_START (target_label) != current_subr)
+ return "transfer out of subroutine";
+ }
+ else if (! LABEL_VERIFIED (target_label))
+ {
+ LABEL_IN_SUBR (target_label) = 1;
+ LABEL_SUBR_START (target_label) = current_subr;
+ }
+ else
+ return "transfer out of subroutine";
+ }
+ return NULL;
+}
+
+/* Return the "merged" types of TYPE1 and TYPE2.
+ If either is primitive, the other must match (after promotion to int).
+ For reference types, return the common super-class.
+ Return TYPE_UNKNOWN if the types cannot be merged. */
+
+tree
+merge_types (type1, type2)
+ tree type1, type2;
+{
+ if (type1 == type2)
+ return type1;
+ if (type1 == TYPE_UNKNOWN || type2 == TYPE_UNKNOWN
+ || type1 == TYPE_RETURN_ADDR || type2 == TYPE_RETURN_ADDR)
+ return TYPE_UNKNOWN;
+ if (TREE_CODE (type1) == POINTER_TYPE && TREE_CODE (type2) == POINTER_TYPE)
+ {
+ int depth1, depth2;
+ tree tt1, tt2;
+ /* ptr_type_node is only used for a null reference,
+ which is compatible with any reference type. */
+ if (type1 == ptr_type_node || type2 == object_ptr_type_node)
+ return type2;
+ if (type2 == ptr_type_node || type1 == object_ptr_type_node)
+ return type1;
+
+ tt1 = HANDLE_TO_CLASS_TYPE (TREE_TYPE (type1));
+ tt2 = HANDLE_TO_CLASS_TYPE (TREE_TYPE (type2));
+
+ if (TYPE_ARRAY_P (tt1) || TYPE_ARRAY_P (tt2))
+ {
+ if (TYPE_ARRAY_P (tt1) == TYPE_ARRAY_P (tt2))
+ {
+ tree el_type1 = TYPE_ARRAY_ELEMENT (tt1);
+ tree el_type2 = TYPE_ARRAY_ELEMENT (tt2);
+ tree el_type = NULL_TREE;
+ if (el_type1 == el_type2)
+ el_type = el_type1;
+ else if (TREE_CODE (el_type1) == POINTER_TYPE
+ && TREE_CODE (el_type2) == POINTER_TYPE)
+ el_type = merge_types (el_type1, el_type2);
+ if (el_type != NULL_TREE)
+ {
+ HOST_WIDE_INT len1 = java_array_type_length (tt1);
+ HOST_WIDE_INT len2 = java_array_type_length (tt2);
+ if (len1 != len2)
+ len1 = -1;
+ else if (el_type1 == el_type2)
+ return type1;
+ return promote_type (build_java_array_type (el_type, len1));
+ }
+ }
+ return object_ptr_type_node;
+ }
+ type1 = tt1;
+ type2 = tt2;
+
+ depth1 = class_depth (type1);
+ depth2 = class_depth (type2);
+ for ( ; depth1 > depth2; depth1--)
+ type1 = TYPE_BINFO_BASETYPE (type1, 0);
+ for ( ; depth2 > depth1; depth2--)
+ type2 = TYPE_BINFO_BASETYPE (type2, 0);
+ while (type1 != type2)
+ {
+ type1 = TYPE_BINFO_BASETYPE (type1, 0);
+ type2 = TYPE_BINFO_BASETYPE (type2, 0);
+ }
+ return promote_type (type1);
+ }
+ if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2)
+ && TYPE_PRECISION (type1) <= 32 && TYPE_PRECISION (type2) <= 32)
+ return int_type_node;
+ return TYPE_UNKNOWN;
+}
+
+/* Merge the current type state with that at LABEL.
+ Return -1 the the states are incompatible (i.e. on error),
+ 0 if there was no change, and 1 if there was a change. */
+
+int
+merge_type_state (label)
+ tree label;
+{
+ int nlocals = DECL_MAX_LOCALS(current_function_decl);
+ int cur_length = stack_pointer + nlocals;
+ tree vec = LABEL_TYPE_STATE (label);
+ tree return_map;
+ if (vec == NULL_TREE)
+ {
+ vec = make_tree_vec (cur_length);
+ LABEL_TYPE_STATE (label) = vec;
+ while (--cur_length >= 0)
+ TREE_VEC_ELT (vec, cur_length) = type_map [cur_length];
+ return 1;
+ }
+ else
+ {
+ int i;
+ int changed = 0;
+ if (LABEL_IS_SUBR_START (label) && LABEL_VERIFIED (label)
+ && current_subr != label)
+ return_map = LABEL_RETURN_TYPE_STATE (label);
+ else
+ return_map = NULL_TREE;
+ if (TREE_VEC_LENGTH (vec) != cur_length)
+ {
+ return -1;
+ }
+ for (i = 0; i < cur_length; i++)
+ {
+ tree old_type = TREE_VEC_ELT (vec, i);
+ tree new_type = merge_types (old_type, type_map [i]);
+ if (TREE_VEC_ELT (vec, i) != new_type)
+ {
+ /* If there has been a change, note that since we must re-verify.
+ However, if the label is the start of a subroutine,
+ we don't care about local variables that are neither
+ set nor used in the sub-routine. */
+ if (return_map == NULL_TREE || i >= nlocals
+ || TREE_VEC_ELT (return_map, i) != TYPE_UNUSED
+ || (TYPE_IS_WIDE (new_type)
+ && TREE_VEC_ELT (return_map, i+1) != TYPE_UNUSED))
+ changed = 1;
+ }
+ TREE_VEC_ELT (vec, i) = new_type;
+ if (new_type == TYPE_UNKNOWN)
+ {
+ if (i >= nlocals)
+ return -1;
+ }
+ else if (TYPE_IS_WIDE (new_type))
+ i++;
+ }
+ return changed;
+ }
+}
+
+/* Handle dup-like operations. */
+
+static void
+type_stack_dup (size, offset)
+ int size, offset;
+{
+ tree type[4];
+ int index;
+ if (size + offset > stack_pointer)
+ error ("stack underflow - dup* operation");
+ for (index = 0; index < size + offset; index++)
+ {
+ type[index] = stack_type_map[stack_pointer - 1];
+ if (type[index] == void_type_node)
+ {
+ index++;
+ type[index] = stack_type_map[stack_pointer - 2];
+ if (! TYPE_IS_WIDE (type[index]))
+ fatal ("internal error - dup operation");
+ if (index == size || index == size + offset)
+ fatal ("dup operation splits 64-bit number");
+ }
+ pop_type (type[index]);
+ }
+ for (index = size; --index >= 0; )
+ {
+ if (type[index] != void_type_node)
+ push_type (type[index]);
+ }
+
+ for (index = size + offset; --index >= 0; )
+ {
+ if (type[index] != void_type_node)
+ push_type (type[index]);
+ }
+}
+
+/* This causes the next iteration to ignore the next instruction
+ and look for some other unhandled instruction. */
+#define INVALIDATE_PC (prevpc = -1, oldpc = PC, PC = INVALID_PC)
+#define INVALID_PC (-1)
+
+#define VERIFICATION_ERROR(MESSAGE) \
+ do { message = MESSAGE; goto verify_error; } while (0)
+
+#define PUSH_PENDING(LABEL) \
+ do { if ((message = check_pending_block (LABEL)) != NULL) \
+ goto verify_error; } while (0)
+
+#ifdef __GNUC__
+#define CHECK_PC_IN_RANGE(PC) ({if (PC < 0 || PC > length) goto bad_pc; 1;})
+#else
+#define CHECK_PC_IN_RANGE(PC) (PC < 0 || PC > length ? \
+ (fatal("Bad byte codes.\n"), 0) : 1)
+#endif
+
+#define BCODE byte_ops
+
+/* Verify the bytecodes of the current method.
+ Return 1 on sucess, 0 on failure. */
+int
+verify_jvm_instructions (jcf, byte_ops, length)
+ JCF* jcf;
+ unsigned char* byte_ops;
+ long length;
+{
+ tree label;
+ int wide = 0;
+ int op_code;
+ int PC;
+ int oldpc; /* PC of start of instruction. */
+ int prevpc; /* If >= 0, PC of previous instruction. */
+ char *message;
+ int i;
+ register unsigned char *p;
+ struct eh_range *prev_eh_ranges = NULL_EH_RANGE;
+ struct eh_range *eh_ranges;
+
+ jint int_value = -1;
+
+ pending_blocks = NULL_TREE;
+
+ /* Handle the exception table. */
+ method_init_exceptions ();
+ JCF_SEEK (jcf, DECL_CODE_OFFSET (current_function_decl) + length);
+ i = JCF_readu2 (jcf);
+
+ /* We read the exception backwards. */
+ p = jcf->read_ptr + 8 * i;
+ while (--i >= 0)
+ {
+ int start_pc = GET_u2 (p-8);
+ int end_pc = GET_u2 (p-6);
+ int handler_pc = GET_u2 (p-4);
+ int catch_type = GET_u2 (p-2);
+ p -= 8;
+
+ if (start_pc < 0 || start_pc >= length
+ || end_pc < 0 || end_pc > length || start_pc >= end_pc
+ || handler_pc < 0 || handler_pc >= length
+ || (handler_pc >= start_pc && handler_pc < end_pc)
+ || ! (instruction_bits [start_pc] & BCODE_INSTRUCTION_START)
+ || ! (instruction_bits [end_pc] & BCODE_INSTRUCTION_START)
+ || ! (instruction_bits [handler_pc] & BCODE_INSTRUCTION_START))
+ {
+ error ("bad pc in exception_table");
+ return 0;
+ }
+
+ if (! add_handler (start_pc, end_pc,
+ lookup_label (handler_pc),
+ catch_type == 0 ? NULL_TREE
+ : get_class_constant (jcf, catch_type)))
+ {
+ error ("overlapping exception ranges are not supported");
+ return 0;
+ }
+
+ instruction_bits [handler_pc] |= BCODE_EXCEPTION_TARGET;
+ }
+
+ for (PC = 0;;)
+ {
+ int index;
+ tree type, tmp;
+ if (((PC != INVALID_PC
+ && instruction_bits [PC] & BCODE_TARGET) != 0)
+ || PC == 0)
+ {
+ PUSH_PENDING (lookup_label (PC));
+ INVALIDATE_PC;
+ }
+ if (PC == INVALID_PC)
+ {
+ label = pending_blocks;
+ if (label == NULL_TREE)
+ break; /* We're done! */
+ pending_blocks = LABEL_PENDING_CHAIN (label);
+ LABEL_CHANGED (label) = 0;
+
+ if (LABEL_IN_SUBR (label))
+ current_subr = LABEL_SUBR_START (label);
+ else
+ current_subr = NULL_TREE;
+
+ /* Restore type_map and stack_pointer from
+ LABEL_TYPE_STATE (label), and continue
+ compiling from there. */
+ load_type_state (label);
+ PC = LABEL_PC (label);
+ }
+ else if (PC >= length)
+ VERIFICATION_ERROR ("falling through end of method");
+
+ oldpc = PC;
+
+ if (!(instruction_bits [PC] & BCODE_INSTRUCTION_START) && ! wide)
+ VERIFICATION_ERROR ("PC not at instruction start");
+
+ instruction_bits[PC] |= BCODE_VERIFIED;
+
+ eh_ranges = find_handler (oldpc);
+
+ op_code = byte_ops[PC++];
+ switch (op_code)
+ {
+ int is_static, is_putting;
+ case OPCODE_nop:
+ break;
+ case OPCODE_iconst_m1:
+ case OPCODE_iconst_0: case OPCODE_iconst_1: case OPCODE_iconst_2:
+ case OPCODE_iconst_3: case OPCODE_iconst_4: case OPCODE_iconst_5:
+ i = op_code - OPCODE_iconst_0;
+ goto push_int;
+ push_int:
+ if (byte_ops[PC] == OPCODE_newarray
+ || byte_ops[PC] == OPCODE_newarray)
+ int_value = i;
+ push_type (int_type_node); break;
+ case OPCODE_lconst_0: case OPCODE_lconst_1:
+ push_type (long_type_node); break;
+ case OPCODE_fconst_0: case OPCODE_fconst_1: case OPCODE_fconst_2:
+ push_type (float_type_node); break;
+ case OPCODE_dconst_0: case OPCODE_dconst_1:
+ push_type (double_type_node); break;
+ case OPCODE_bipush:
+ i = IMMEDIATE_s1;
+ goto push_int;
+ case OPCODE_sipush:
+ i = IMMEDIATE_s2;
+ goto push_int;
+ case OPCODE_iload: type = int_type_node; goto general_load;
+ case OPCODE_lload: type = long_type_node; goto general_load;
+ case OPCODE_fload: type = float_type_node; goto general_load;
+ case OPCODE_dload: type = double_type_node; goto general_load;
+ case OPCODE_aload: type = ptr_type_node; goto general_load;
+ general_load:
+ index = wide ? IMMEDIATE_u2 : IMMEDIATE_u1;
+ wide = 0;
+ goto load;
+ case OPCODE_iload_0: type = int_type_node; index = 0; goto load;
+ case OPCODE_iload_1: type = int_type_node; index = 1; goto load;
+ case OPCODE_iload_2: type = int_type_node; index = 2; goto load;
+ case OPCODE_iload_3: type = int_type_node; index = 3; goto load;
+ case OPCODE_lload_0: type = long_type_node; index = 0; goto load;
+ case OPCODE_lload_1: type = long_type_node; index = 1; goto load;
+ case OPCODE_lload_2: type = long_type_node; index = 2; goto load;
+ case OPCODE_lload_3: type = long_type_node; index = 3; goto load;
+ case OPCODE_fload_0: type = float_type_node; index = 0; goto load;
+ case OPCODE_fload_1: type = float_type_node; index = 1; goto load;
+ case OPCODE_fload_2: type = float_type_node; index = 2; goto load;
+ case OPCODE_fload_3: type = float_type_node; index = 3; goto load;
+ case OPCODE_dload_0: type = double_type_node; index = 0; goto load;
+ case OPCODE_dload_1: type = double_type_node; index = 1; goto load;
+ case OPCODE_dload_2: type = double_type_node; index = 2; goto load;
+ case OPCODE_dload_3: type = double_type_node; index = 3; goto load;
+ case OPCODE_aload_0: type = ptr_type_node; index = 0; goto load;
+ case OPCODE_aload_1: type = ptr_type_node; index = 1; goto load;
+ case OPCODE_aload_2: type = ptr_type_node; index = 2; goto load;
+ case OPCODE_aload_3: type = ptr_type_node; index = 3; goto load;
+ load:
+ if (index < 0
+ || (index + TYPE_IS_WIDE (type)
+ >= DECL_MAX_LOCALS (current_function_decl)))
+ VERIFICATION_ERROR ("invalid local variable index in load");
+ tmp = type_map[index];
+ if (tmp == TYPE_UNKNOWN || tmp == TYPE_SECOND
+ || (TYPE_IS_WIDE (type)
+ && type_map[index+1] != void_type_node)
+ || (type == ptr_type_node
+ ? TREE_CODE (tmp) != POINTER_TYPE
+ : type == int_type_node
+ ? (! INTEGRAL_TYPE_P (tmp) || TYPE_PRECISION (tmp) > 32)
+ : type != tmp))
+ VERIFICATION_ERROR("invalid local variable type in load");
+ push_type (tmp);
+ goto note_used;
+ case OPCODE_istore: type = int_type_node; goto general_store;
+ case OPCODE_lstore: type = long_type_node; goto general_store;
+ case OPCODE_fstore: type = float_type_node; goto general_store;
+ case OPCODE_dstore: type = double_type_node; goto general_store;
+ case OPCODE_astore: type = ptr_type_node; goto general_store;
+ general_store:
+ index = wide ? IMMEDIATE_u2 : IMMEDIATE_u1;
+ wide = 0;
+ goto store;
+ case OPCODE_istore_0: type = int_type_node; index = 0; goto store;
+ case OPCODE_istore_1: type = int_type_node; index = 1; goto store;
+ case OPCODE_istore_2: type = int_type_node; index = 2; goto store;
+ case OPCODE_istore_3: type = int_type_node; index = 3; goto store;
+ case OPCODE_lstore_0: type = long_type_node; index=0; goto store;
+ case OPCODE_lstore_1: type = long_type_node; index=1; goto store;
+ case OPCODE_lstore_2: type = long_type_node; index=2; goto store;
+ case OPCODE_lstore_3: type = long_type_node; index=3; goto store;
+ case OPCODE_fstore_0: type=float_type_node; index=0; goto store;
+ case OPCODE_fstore_1: type=float_type_node; index=1; goto store;
+ case OPCODE_fstore_2: type=float_type_node; index=2; goto store;
+ case OPCODE_fstore_3: type=float_type_node; index=3; goto store;
+ case OPCODE_dstore_0: type=double_type_node; index=0; goto store;
+ case OPCODE_dstore_1: type=double_type_node; index=1; goto store;
+ case OPCODE_dstore_2: type=double_type_node; index=2; goto store;
+ case OPCODE_dstore_3: type=double_type_node; index=3; goto store;
+ case OPCODE_astore_0: type = ptr_type_node; index = 0; goto store;
+ case OPCODE_astore_1: type = ptr_type_node; index = 1; goto store;
+ case OPCODE_astore_2: type = ptr_type_node; index = 2; goto store;
+ case OPCODE_astore_3: type = ptr_type_node; index = 3; goto store;
+ store:
+ if (index < 0
+ || (index + TYPE_IS_WIDE (type)
+ >= DECL_MAX_LOCALS (current_function_decl)))
+ {
+ VERIFICATION_ERROR ("invalid local variable index in store");
+ return 0;
+ }
+ type = pop_type (type);
+ type_map[index] = type;
+
+ /* If local variable changed, we need to reconsider eh handlers. */
+ prev_eh_ranges = NULL_EH_RANGE;
+
+ /* Allocate decl and rtx for this variable now, so if we're not
+ optmizing, we get a temporary that survives the whole method. */
+ find_local_variable (index, type, oldpc);
+
+ if (TYPE_IS_WIDE (type))
+ type_map[index+1] = TYPE_SECOND;
+ /* ... fall through to note_used ... */
+ note_used:
+ /* For store or load, note that local variable INDEX is used.
+ This is needed to verify try-finally sub-routines. */
+ if (current_subr)
+ {
+ tree vec = LABEL_RETURN_TYPE_STATE (current_subr);
+ tree subr_vec = LABEL_TYPE_STATE (current_subr);
+ int len = 1 + TYPE_IS_WIDE (type);
+ while (--len >= 0)
+ {
+ if (TREE_VEC_ELT (vec, index) == TYPE_UNUSED)
+ TREE_VEC_ELT (vec, index) = TREE_VEC_ELT (subr_vec, index);
+ }
+ }
+ break;
+ case OPCODE_iadd:
+ case OPCODE_iand:
+ case OPCODE_idiv:
+ case OPCODE_imul:
+ case OPCODE_ior:
+ case OPCODE_irem:
+ case OPCODE_ishl:
+ case OPCODE_ishr:
+ case OPCODE_isub:
+ case OPCODE_iushr:
+ case OPCODE_ixor:
+ type = int_type_node; goto binop;
+ case OPCODE_ineg:
+ case OPCODE_i2c:
+ case OPCODE_i2b:
+ case OPCODE_i2s:
+ type = int_type_node; goto unop;
+ case OPCODE_ladd:
+ case OPCODE_land:
+ case OPCODE_ldiv:
+ case OPCODE_lsub:
+ case OPCODE_lmul:
+ case OPCODE_lrem:
+ case OPCODE_lor:
+ case OPCODE_lxor:
+ type = long_type_node; goto binop;
+ case OPCODE_lneg:
+ type = long_type_node; goto unop;
+ case OPCODE_fadd: case OPCODE_fsub:
+ case OPCODE_fmul: case OPCODE_fdiv: case OPCODE_frem:
+ type = float_type_node; goto binop;
+ case OPCODE_fneg:
+ type = float_type_node; goto unop;
+ case OPCODE_dadd: case OPCODE_dsub:
+ case OPCODE_dmul: case OPCODE_ddiv: case OPCODE_drem:
+ type = double_type_node; goto binop;
+ case OPCODE_dneg:
+ type = double_type_node; goto unop;
+ unop:
+ pop_type (type);
+ push_type (type);
+ break;
+ binop:
+ pop_type (type);
+ pop_type (type);
+ push_type (type);
+ break;
+ case OPCODE_lshl:
+ case OPCODE_lshr:
+ case OPCODE_lushr:
+ pop_type (int_type_node);
+ pop_type (long_type_node);
+ push_type (long_type_node);
+ break;
+ case OPCODE_iinc:
+ index = wide ? IMMEDIATE_u2 : IMMEDIATE_u1;
+ PC += wide + 1;
+ wide = 0;
+ if (index < 0 || index >= DECL_MAX_LOCALS (current_function_decl))
+ VERIFICATION_ERROR ("invalid local variable index in iinc");
+ tmp = type_map[index];
+ if (! INTEGRAL_TYPE_P (tmp) || TYPE_PRECISION (tmp) > 32)
+ VERIFICATION_ERROR ("invalid local variable type in iinc");
+ break;
+ case OPCODE_i2l:
+ pop_type (int_type_node); push_type (long_type_node); break;
+ case OPCODE_i2f:
+ pop_type (int_type_node); push_type (float_type_node); break;
+ case OPCODE_i2d:
+ pop_type (int_type_node); push_type (double_type_node); break;
+ case OPCODE_l2i:
+ pop_type (long_type_node); push_type (int_type_node); break;
+ case OPCODE_l2f:
+ pop_type (long_type_node); push_type (float_type_node); break;
+ case OPCODE_l2d:
+ pop_type (long_type_node); push_type (double_type_node); break;
+ case OPCODE_f2i:
+ pop_type (float_type_node); push_type (int_type_node); break;
+ case OPCODE_f2l:
+ pop_type (float_type_node); push_type (long_type_node); break;
+ case OPCODE_f2d:
+ pop_type (float_type_node); push_type (double_type_node); break;
+ case OPCODE_d2i:
+ pop_type (double_type_node); push_type (int_type_node); break;
+ case OPCODE_d2l:
+ pop_type (double_type_node); push_type (long_type_node); break;
+ case OPCODE_d2f:
+ pop_type (double_type_node); push_type (float_type_node); break;
+ case OPCODE_lcmp:
+ type = long_type_node; goto compare;
+ case OPCODE_fcmpl:
+ case OPCODE_fcmpg:
+ type = float_type_node; goto compare;
+ case OPCODE_dcmpl:
+ case OPCODE_dcmpg:
+ type = double_type_node; goto compare;
+ compare:
+ pop_type (type); pop_type (type);
+ push_type (int_type_node); break;
+ case OPCODE_ifeq:
+ case OPCODE_ifne:
+ case OPCODE_iflt:
+ case OPCODE_ifge:
+ case OPCODE_ifgt:
+ case OPCODE_ifle:
+ pop_type (int_type_node); goto cond;
+ case OPCODE_ifnull:
+ case OPCODE_ifnonnull:
+ pop_type (ptr_type_node ); goto cond;
+ case OPCODE_if_icmpeq:
+ case OPCODE_if_icmpne:
+ case OPCODE_if_icmplt:
+ case OPCODE_if_icmpge:
+ case OPCODE_if_icmpgt:
+ case OPCODE_if_icmple:
+ pop_type (int_type_node); pop_type (int_type_node); goto cond;
+ case OPCODE_if_acmpeq:
+ case OPCODE_if_acmpne:
+ pop_type (object_ptr_type_node); pop_type (object_ptr_type_node);
+ goto cond;
+ cond:
+ PUSH_PENDING (lookup_label (oldpc + IMMEDIATE_s2));
+ break;
+ case OPCODE_goto:
+ PUSH_PENDING (lookup_label (oldpc + IMMEDIATE_s2));
+ INVALIDATE_PC;
+ break;
+ case OPCODE_wide:
+ switch (byte_ops[PC])
+ {
+ case OPCODE_iload: case OPCODE_lload:
+ case OPCODE_fload: case OPCODE_dload: case OPCODE_aload:
+ case OPCODE_istore: case OPCODE_lstore:
+ case OPCODE_fstore: case OPCODE_dstore: case OPCODE_astore:
+ case OPCODE_iinc:
+ case OPCODE_ret:
+ wide = 1;
+ break;
+ default:
+ VERIFICATION_ERROR ("invalid use of wide instruction");
+ }
+ break;
+ case OPCODE_ireturn: type = int_type_node; goto ret;
+ case OPCODE_lreturn: type = long_type_node; goto ret;
+ case OPCODE_freturn: type = float_type_node; goto ret;
+ case OPCODE_dreturn: type = double_type_node; goto ret;
+ case OPCODE_areturn: type = ptr_type_node; goto ret;
+ ret:
+ pop_type (type);
+ /* ... fall through ... */
+ case OPCODE_return:
+ INVALIDATE_PC;
+ break;
+ case OPCODE_getstatic: is_putting = 0; is_static = 1; goto field;
+ case OPCODE_putstatic: is_putting = 1; is_static = 1; goto field;
+ case OPCODE_getfield: is_putting = 0; is_static = 0; goto field;
+ case OPCODE_putfield: is_putting = 1; is_static = 0; goto field;
+ field:
+ {
+ int index = IMMEDIATE_u2;
+ tree self_type = get_class_constant
+ (jcf, COMPONENT_REF_CLASS_INDEX (¤t_jcf->cpool, index));
+ tree field_name = COMPONENT_REF_NAME (¤t_jcf->cpool, index);
+ tree field_signature = COMPONENT_REF_SIGNATURE (¤t_jcf->cpool, index);
+ tree field_type = get_type_from_signature (field_signature);
+ if (is_putting)
+ pop_type (field_type);
+ if (! is_static)
+ {
+ /* Defer actual checking until next pass. */
+ pop_type (ptr_type_node);
+ }
+ if (! is_putting)
+ push_type (field_type);
+ break;
+ }
+ case OPCODE_new:
+ push_type (get_class_constant (jcf, IMMEDIATE_u2));
+ break;
+ case OPCODE_dup: type_stack_dup (1, 0); break;
+ case OPCODE_dup_x1: type_stack_dup (1, 1); break;
+ case OPCODE_dup_x2: type_stack_dup (1, 2); break;
+ case OPCODE_dup2: type_stack_dup (2, 0); break;
+ case OPCODE_dup2_x1: type_stack_dup (2, 1); break;
+ case OPCODE_dup2_x2: type_stack_dup (2, 2); break;
+ case OPCODE_pop: index = 1; goto pop;
+ case OPCODE_pop2: index = 2; goto pop;
+ pop:
+ if (stack_pointer < index)
+ VERIFICATION_ERROR ("stack underflow");
+ stack_pointer -= index;
+ break;
+ case OPCODE_swap:
+ if (stack_pointer < 2)
+ VERIFICATION_ERROR ("stack underflow (in swap)");
+ else
+ {
+ tree type1 = stack_type_map[stack_pointer - 1];
+ tree type2 = stack_type_map[stack_pointer - 2];
+ if (type1 == void_type_node || type2 == void_type_node)
+ VERIFICATION_ERROR ("verifier (swap): double or long value");
+ stack_type_map[stack_pointer - 2] = type1;
+ stack_type_map[stack_pointer - 1] = type2;
+ }
+ break;
+ case OPCODE_ldc: index = IMMEDIATE_u1; goto ldc;
+ case OPCODE_ldc2_w:
+ case OPCODE_ldc_w:
+ index = IMMEDIATE_u2; goto ldc;
+ ldc:
+ if (index <= 0 || index >= JPOOL_SIZE(current_jcf))
+ VERIFICATION_ERROR ("bad constant pool index in ldc");
+ int_value = -1;
+ switch (JPOOL_TAG (current_jcf, index) & ~CONSTANT_ResolvedFlag)
+ {
+ case CONSTANT_Integer: type = int_type_node; goto check_ldc;
+ case CONSTANT_Float: type = float_type_node; goto check_ldc;
+ case CONSTANT_String: type = string_type_node; goto check_ldc;
+ case CONSTANT_Long: type = long_type_node; goto check_ldc;
+ case CONSTANT_Double: type = double_type_node; goto check_ldc;
+ check_ldc:
+ if (TYPE_IS_WIDE (type) == (op_code == OPCODE_ldc2_w))
+ break;
+ /* ... else fall through ... */
+ default:
+ bad_ldc:
+ VERIFICATION_ERROR ("bad constant pool tag in ldc");
+ }
+ if (type == int_type_node)
+ {
+ i = TREE_INT_CST_LOW (get_constant (current_jcf, index));
+ goto push_int;
+ }
+ push_type (type);
+ break;
+
+ case OPCODE_invokevirtual:
+ case OPCODE_invokespecial:
+ case OPCODE_invokestatic:
+ case OPCODE_invokeinterface:
+ {
+ int index = IMMEDIATE_u2;
+ tree sig = COMPONENT_REF_SIGNATURE (¤t_jcf->cpool, index);
+ tree self_type = get_class_constant
+ (current_jcf, COMPONENT_REF_CLASS_INDEX (¤t_jcf->cpool,
+ index));
+ tree method_name = COMPONENT_REF_NAME (¤t_jcf->cpool, index);
+ tree method_type;
+ method_type = parse_signature_string (IDENTIFIER_POINTER (sig),
+ IDENTIFIER_LENGTH (sig));
+ if (TREE_CODE (method_type) != FUNCTION_TYPE)
+ VERIFICATION_ERROR ("bad method signature");
+ pop_argument_types (TYPE_ARG_TYPES (method_type));
+
+ /* Can't invoke <clinit> */
+ if (method_name == clinit_identifier_node)
+ VERIFICATION_ERROR ("invoke opcode can't invoke <clinit>");
+ /* Apart invokespecial, can't invoke <init> */
+ if (op_code != OPCODE_invokespecial
+ && method_name == init_identifier_node)
+ VERIFICATION_ERROR ("invoke opcode can't invoke <init>");
+
+ if (op_code != OPCODE_invokestatic)
+ pop_type (self_type);
+
+ switch (op_code)
+ {
+ case OPCODE_invokeinterface:
+ {
+ int nargs = IMMEDIATE_u1;
+ int notZero = IMMEDIATE_u1;
+
+ if (!nargs || notZero)
+ VERIFICATION_ERROR
+ ("invalid argument number in invokeinterface");
+ break;
+ }
+ }
+
+ if (TREE_TYPE (method_type) != void_type_node)
+ push_type (TREE_TYPE (method_type));
+ break;
+ }
+
+ case OPCODE_arraylength:
+ /* Type checking actually made during code generation */
+ pop_type( ptr_type_node );
+ push_type( int_type_node );
+ break;
+
+ /* Q&D verification *or* more checking done during code generation
+ for byte/boolean/char/short, the value popped is a int coerced
+ into the right type before being stored. */
+ case OPCODE_iastore: type = int_type_node; goto astore;
+ case OPCODE_lastore: type = long_type_node; goto astore;
+ case OPCODE_fastore: type = float_type_node; goto astore;
+ case OPCODE_dastore: type = double_type_node; goto astore;
+ case OPCODE_aastore: type = ptr_type_node; goto astore;
+ case OPCODE_bastore: type = int_type_node; goto astore;
+ case OPCODE_castore: type = int_type_node; goto astore;
+ case OPCODE_sastore: type = int_type_node; goto astore;
+ astore:
+ /* FIXME - need better verification here */
+ pop_type (type); /* new value */
+ pop_type (int_type_node); /* index */
+ pop_type (ptr_type_node); /* array */
+ break;
+
+ /* Q&D verification *or* more checking done during code generation
+ for byte/boolean/char/short, the value pushed is a int. */
+ case OPCODE_iaload: type = int_type_node; goto aload;
+ case OPCODE_laload: type = long_type_node; goto aload;
+ case OPCODE_faload: type = float_type_node; goto aload;
+ case OPCODE_daload: type = double_type_node; goto aload;
+ case OPCODE_aaload: type = ptr_type_node; goto aload;
+ case OPCODE_baload: type = promote_type (byte_type_node); goto aload;
+ case OPCODE_caload: type = promote_type (char_type_node); goto aload;
+ case OPCODE_saload: type = promote_type (short_type_node); goto aload;
+ aload:
+ pop_type (int_type_node);
+ type = pop_type (ptr_type_node);
+ if (! is_array_type_p (type))
+ VERIFICATION_ERROR ("array load from non-array type");
+ push_type (TYPE_ARRAY_ELEMENT (TREE_TYPE (type)));
+ break;
+
+ case OPCODE_anewarray:
+ type = get_class_constant (current_jcf, IMMEDIATE_u2);
+ type = promote_type (type);
+ goto newarray;
+
+ case OPCODE_newarray:
+ index = IMMEDIATE_u1;
+ type = decode_newarray_type (index);
+ if (type == NULL_TREE)
+ VERIFICATION_ERROR ("invalid type code in newarray opcode");
+ goto newarray;
+
+ newarray:
+ if (int_value >= 0 && prevpc >= 0)
+ {
+ /* If previous instruction pushed int constant,
+ we want to use it. */
+ switch (byte_ops[prevpc])
+ {
+ case OPCODE_iconst_0: case OPCODE_iconst_1:
+ case OPCODE_iconst_2: case OPCODE_iconst_3:
+ case OPCODE_iconst_4: case OPCODE_iconst_5:
+ case OPCODE_bipush: case OPCODE_sipush:
+ case OPCODE_ldc: case OPCODE_ldc_w:
+ break;
+ default:
+ int_value = -1;
+ }
+ }
+ else
+ int_value = -1;
+ type = build_java_array_type (type, int_value);
+ pop_type (int_type_node);
+ push_type (type);
+ break;
+
+ case OPCODE_multianewarray:
+ {
+ int ndim, i;
+ index = IMMEDIATE_u2;
+ ndim = IMMEDIATE_u1;
+
+ if( ndim < 1 )
+ VERIFICATION_ERROR ("number of dimension lower that 1 in multianewarray" );
+
+ for( i = 0; i < ndim; i++ )
+ pop_type (int_type_node);
+ push_type (get_class_constant (current_jcf, index));
+ break;
+ }
+
+ case OPCODE_aconst_null:
+ push_type (ptr_type_node);
+ break;
+
+ case OPCODE_athrow:
+ pop_type (throwable_type_node);
+ INVALIDATE_PC;
+ break;
+
+ case OPCODE_checkcast:
+ pop_type (ptr_type_node);
+ type = get_class_constant (current_jcf, IMMEDIATE_u2);
+ push_type (type);
+ break;
+ case OPCODE_instanceof:
+ pop_type (ptr_type_node);
+ get_class_constant (current_jcf, IMMEDIATE_u2);
+ push_type (integer_type_node);
+ break;
+
+ case OPCODE_tableswitch:
+ {
+ jint default_val, low, high;
+
+ pop_type (integer_type_node);
+ while (PC%4)
+ {
+ if (byte_ops[PC++])
+ VERIFICATION_ERROR ("bad alignment in tableswitch pad");
+ }
+ PUSH_PENDING (lookup_label (oldpc+IMMEDIATE_s4));
+ low = IMMEDIATE_s4;
+ high = IMMEDIATE_s4;
+
+ if (low > high)
+ VERIFICATION_ERROR ("unsorted low/high value in tableswitch");
+
+ while (low++ <= high)
+ PUSH_PENDING (lookup_label (oldpc + IMMEDIATE_s4));
+ break;
+ }
+
+ case OPCODE_lookupswitch:
+ {
+ jint npairs, last, not_registered = 1;
+
+ pop_type (integer_type_node);
+ while (PC%4)
+ {
+ if (byte_ops[PC++])
+ VERIFICATION_ERROR ("bad alignment in lookupswitch pad");
+ }
+
+ PUSH_PENDING (lookup_label (oldpc+IMMEDIATE_s4));
+ npairs = IMMEDIATE_s4;
+
+ if (npairs < 0)
+ VERIFICATION_ERROR ("invalid number of targets in lookupswitch");
+
+ while (npairs--)
+ {
+ int match = IMMEDIATE_s4;
+ if (not_registered)
+ not_registered = 0;
+ else if (last >= match)
+ VERIFICATION_ERROR ("unsorted match value in lookupswitch");
+
+ last = match;
+ PUSH_PENDING (lookup_label (oldpc + IMMEDIATE_s4));
+ }
+ break;
+ }
+
+ case OPCODE_monitorenter:
+ /* fall thru */
+ case OPCODE_monitorexit:
+ pop_type (ptr_type_node);
+ break;
+
+ case OPCODE_goto_w:
+ PUSH_PENDING (lookup_label (oldpc + IMMEDIATE_s4));
+ INVALIDATE_PC;
+ break;
+
+ case OPCODE_jsr:
+ {
+ tree target = lookup_label (oldpc + IMMEDIATE_s2);
+ tree return_label = lookup_label (PC);
+ push_type (return_address_type_node);
+ if (! LABEL_VERIFIED (target))
+ {
+ /* first time seen */
+ tree return_type_map;
+ int nlocals = DECL_MAX_LOCALS (current_function_decl);
+ index = nlocals + DECL_MAX_STACK (current_function_decl);
+ return_type_map = make_tree_vec (index);
+ while (--index >= nlocals)
+ TREE_VEC_ELT (return_type_map, index) = TYPE_UNKNOWN;
+ while (--index >= 0)
+ TREE_VEC_ELT (return_type_map, index) = TYPE_UNUSED;
+ LABEL_RETURN_LABEL (target)
+ = build_decl (LABEL_DECL, NULL_TREE, TREE_TYPE (target));
+ LABEL_PC (LABEL_RETURN_LABEL (target)) = -1;
+ LABEL_RETURN_TYPE_STATE (target) = return_type_map;
+ LABEL_IS_SUBR_START (target) = 1;
+ LABEL_IN_SUBR (target) = 1;
+ LABEL_SUBR_START (target) = target;
+ LABEL_SUBR_CONTEXT (target) = current_subr;
+ }
+ else if (! LABEL_IS_SUBR_START (target)
+ || LABEL_SUBR_CONTEXT (target) != current_subr)
+ VERIFICATION_ERROR ("label part of different subroutines");
+
+ i = merge_type_state (target);
+ if (i != 0)
+ {
+ if (i < 0)
+ VERIFICATION_ERROR ("types could not be merged at jsr");
+ push_pending_label (target);
+ }
+ current_subr = target;
+
+ /* Chain return_pc onto LABEL_RETURN_LABELS (target) if needed. */
+ if (! value_member (return_label, LABEL_RETURN_LABELS (target)))
+ {
+ LABEL_RETURN_LABELS (target)
+ = tree_cons (NULL_TREE, return_label,
+ LABEL_RETURN_LABELS (target));
+ }
+
+ if (LABEL_VERIFIED (target))
+ {
+ tree return_map = LABEL_RETURN_TYPE_STATE (target);
+ int len = TREE_VEC_LENGTH (return_map);
+ stack_pointer = len - DECL_MAX_LOCALS (current_function_decl);
+ while (--len >= 0)
+ {
+ if (TREE_VEC_ELT (return_map, len) != TYPE_UNUSED)
+ type_map[len] = TREE_VEC_ELT (return_map, len);
+ }
+ current_subr = LABEL_SUBR_CONTEXT (target);
+ PUSH_PENDING (return_label);
+ }
+
+ INVALIDATE_PC;
+ }
+ break;
+ case OPCODE_ret:
+ if (current_subr == NULL)
+ VERIFICATION_ERROR ("ret instruction not in a jsr subroutine");
+ else
+ {
+ tree ret_map = LABEL_RETURN_TYPE_STATE (current_subr);
+ tree caller = LABEL_SUBR_CONTEXT (current_subr);
+ int size = DECL_MAX_LOCALS(current_function_decl)+stack_pointer;
+ index = wide ? IMMEDIATE_u2 : IMMEDIATE_u1;
+ wide = 0;
+ INVALIDATE_PC;
+ if (index < 0 || index >= DECL_MAX_LOCALS (current_function_decl)
+ || type_map[index] != TYPE_RETURN_ADDR)
+ VERIFICATION_ERROR ("invalid ret index");
+
+ /* The next chunk of code is similar to an inlined version of
+ * merge_type_state (LABEL_RETURN_LABEL (current_subr)).
+ * The main differences are that LABEL_RETURN_LABEL is
+ * pre-allocated by the jsr (but we don't know the size then);
+ * and that we have to handle TYPE_UNUSED. */
+
+ if (! RETURN_MAP_ADJUSTED (ret_map))
+ { /* First return from this subroutine - fix stack pointer. */
+ TREE_VEC_LENGTH (ret_map) = size;
+ for (index = size; --index >= 0; )
+ {
+ if (TREE_VEC_ELT (ret_map, index) != TYPE_UNUSED)
+ TREE_VEC_ELT (ret_map, index) = type_map[index];
+ }
+ RETURN_MAP_ADJUSTED (ret_map) = 1;
+ }
+ else
+ {
+ if (TREE_VEC_LENGTH (ret_map) != size)
+ VERIFICATION_ERROR ("inconsistent stack size on ret");
+ for (index = 0; index < size; index++)
+ {
+ tree type = TREE_VEC_ELT (ret_map, index);
+ if (type != TYPE_UNUSED)
+ {
+ type = merge_types (type, type_map [index]);
+ TREE_VEC_ELT (ret_map, index) = type;
+ if (type == TYPE_UNKNOWN)
+ {
+ if (index >= size - stack_pointer)
+ VERIFICATION_ERROR
+ ("inconsistent types on ret from jsr");
+ }
+ else if (TYPE_IS_WIDE (type))
+ index++;
+ }
+ }
+ }
+
+ /* Check if there are any more pending blocks in this subroutine.
+ Because we push pending blocks in a last-in-first-out order,
+ and because we don't push anything from our caller until we
+ are done with this subroutine or anything nested in it,
+ then we are done if the top of the pending_blocks stack is
+ not in a subroutine, or it is in our caller. */
+ if (pending_blocks == NULL_TREE
+ || ! LABEL_IN_SUBR (pending_blocks)
+ || LABEL_SUBR_START (pending_blocks) == caller)
+ {
+ /* Since we are done with this subroutine (i.e. this is the
+ last ret from it), set up the (so far known) return
+ address as pending - with the merged type state. */
+ tmp = LABEL_RETURN_LABELS (current_subr);
+ current_subr = caller;
+ for ( ; tmp != NULL_TREE; tmp = TREE_CHAIN (tmp))
+ {
+ tree return_label = TREE_VALUE (tmp);
+ tree return_state = LABEL_TYPE_STATE (return_label);
+ if (return_state == NULL_TREE)
+ {
+ /* This means means we had not verified the
+ subroutine earlier, so this is the first jsr to
+ call it. In this case, the type_map of the return
+ address is just the current type_map - and that
+ is handled by the following PUSH_PENDING. */
+ }
+ else
+ {
+ /* In this case we have to do a merge. But first
+ restore the type_map for unused slots to those
+ that were in effect at the jsr. */
+ for (index = size; --index >= 0; )
+ {
+ type_map[index] = TREE_VEC_ELT (ret_map, index);
+ if (type_map[index] == TYPE_UNUSED)
+ type_map[index]
+ = TREE_VEC_ELT (return_state, index);
+ }
+ }
+ PUSH_PENDING (return_label);
+ }
+ }
+ }
+ break;
+ case OPCODE_jsr_w:
+ case OPCODE_ret_w:
+ default:
+ error ("unknown opcode %d@pc=%d during verification", op_code, PC-1);
+ return 0;
+ }
+
+ prevpc = oldpc;
+
+ /* The following test is true if we have entered or exited an exception
+ handler range *or* we have done a store to a local variable.
+ In either case we need to consider any exception handlers that
+ might "follow" this instruction. */
+
+ if (eh_ranges != prev_eh_ranges)
+ {
+ int save_stack_pointer = stack_pointer;
+ int index = DECL_MAX_LOCALS (current_function_decl);
+ tree save_type = type_map[index];
+ tree save_current_subr = current_subr;
+ struct eh_range *ranges = find_handler (oldpc);
+ stack_pointer = 1;
+ for (; ranges != NULL_EH_RANGE; ranges = ranges->outer)
+ {
+ tree chain = ranges->handlers;
+
+ /* We need to determine if the handler is part of current_subr.
+ The are two cases: (1) The exception catch range
+ is entirely within current_subr. In that case the handler
+ is also part of current_subr.
+ (2) Some of the catch range is not in current_subr.
+ In that case, the handler is *not* part of current_subr.
+
+ Figuring out which is the case is not necessarily obvious,
+ in the presence of clever code generators (and obfuscators).
+ We make a simplifying assumption that in case (2) we
+ have that the current_subr is entirely within the catch range.
+ In that case we can assume if that if a caller (the jsr) of
+ a subroutine is within the catch range, then the handler is
+ *not* part of the subroutine, and vice versa. */
+
+ current_subr = save_current_subr;
+ for ( ; current_subr != NULL_TREE;
+ current_subr = LABEL_SUBR_CONTEXT (current_subr))
+ {
+ tree return_labels = LABEL_RETURN_LABELS (current_subr);
+ /* There could be multiple return_labels, but
+ we only need to check one. */
+ int return_pc = LABEL_PC (TREE_VALUE (return_labels));
+ if (return_pc <= ranges->start_pc
+ || return_pc > ranges->end_pc)
+ break;
+ }
+
+ for ( ; chain != NULL_TREE; chain = TREE_CHAIN (chain))
+ {
+ tree handler = TREE_VALUE (chain);
+ tree type = TREE_PURPOSE (chain);
+ if (type == NULL_TREE) /* a finally handler */
+ type = throwable_type_node;
+ type_map[index] = promote_type (type);
+
+ PUSH_PENDING (handler);
+ }
+ }
+ stack_pointer = save_stack_pointer;
+ current_subr = save_current_subr;
+ type_map[index] = save_type;
+ prev_eh_ranges = eh_ranges;
+ }
+ }
+ return 1;
+ bad_pc:
+ message = "program counter out of range";
+ goto verify_error;
+ verify_error:
+ error ("verification error at PC=%d: %s", oldpc, message);
+ return 0;
+}
--- /dev/null
+/* Handle a .class file embedded in a .zip archive.
+ This extracts a member from a .zip file, but does not handle
+ uncompression (since that is not needed for classes.zip).
+
+ Copyright (C) 1996 Free Software Foundation, Inc.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+/* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
+
+#include "zipfile.h"
+
+
+/* This stuff is partly based on the 28 August 1994 public release of the
+Info-ZIP group's portable UnZip zipfile-extraction program (and related
+utilities). */
+
+#include <stdio.h>
+#ifdef __STDC__
+#include <stdlib.h>
+#endif
+#include <errno.h> /* used in mapname() */
+
+/*************/
+/* Defines */
+/*************/
+
+#define UNZIP
+#define UNZIP_VERSION 20 /* compatible with PKUNZIP 2.0 */
+#define VMS_UNZIP_VERSION 42 /* if OS-needed-to-extract is VMS: can do */
+
+
+#define ZSUFX ".zip"
+#define CENTRAL_HDR_SIG "\113\001\002" /* the infamous "PK" signature */
+#define LOCAL_HDR_SIG "\113\003\004" /* bytes, sans "P" (so unzip */
+#define END_CENTRAL_SIG "\113\005\006" /* executable not mistaken for */
+#define EXTD_LOCAL_SIG "\113\007\010" /* zipfile itself) */
+
+#define STORED 0 /* compression methods */
+#define SHRUNK 1
+#define REDUCED1 2
+#define REDUCED2 3
+#define REDUCED3 4
+#define REDUCED4 5
+#define IMPLODED 6
+#define TOKENIZED 7
+#define DEFLATED 8
+#define NUM_METHODS 9 /* index of last method + 1 */
+/* don't forget to update list_files() appropriately if NUM_METHODS changes */
+
+#define PK_OK 0 /* no error */
+#define PK_COOL 0 /* no error */
+#define PK_GNARLY 0 /* no error */
+#define PK_WARN 1 /* warning error */
+#define PK_ERR 2 /* error in zipfile */
+#define PK_BADERR 3 /* severe error in zipfile */
+#define PK_MEM 4 /* insufficient memory */
+#define PK_MEM2 5 /* insufficient memory */
+#define PK_MEM3 6 /* insufficient memory */
+#define PK_MEM4 7 /* insufficient memory */
+#define PK_MEM5 8 /* insufficient memory */
+#define PK_NOZIP 9 /* zipfile not found */
+#define PK_PARAM 10 /* bad or illegal parameters specified */
+#define PK_FIND 11 /* no files found */
+#define PK_DISK 50 /* disk full */
+#define PK_EOF 51 /* unexpected EOF */
+
+/*---------------------------------------------------------------------------
+ True sizes of the various headers, as defined by PKWARE--so it is not
+ likely that these will ever change. But if they do, make sure both these
+ defines AND the typedefs below get updated accordingly.
+ ---------------------------------------------------------------------------*/
+#define LREC_SIZE 26 /* lengths of local file headers, central */
+#define CREC_SIZE 42 /* directory headers, and the end-of- */
+#define ECREC_SIZE 18 /* central-dir record, respectively */
+
+
+#ifndef SEEK_SET
+# define SEEK_SET 0
+# define SEEK_CUR 1
+# define SEEK_END 2
+#endif
+
+/**************/
+/* Typedefs */
+/**************/
+
+typedef char boolean;
+typedef unsigned char uch; /* code assumes unsigned bytes; these type- */
+typedef unsigned short ush; /* defs replace byte/UWORD/ULONG (which are */
+typedef unsigned long ulg; /* predefined on some systems) & match zip */
+
+/*---------------------------------------------------------------------------
+ Zipfile layout declarations. If these headers ever change, make sure the
+ xxREC_SIZE defines (above) change with them!
+ ---------------------------------------------------------------------------*/
+
+ typedef uch local_byte_hdr[ LREC_SIZE ];
+# define L_VERSION_NEEDED_TO_EXTRACT_0 0
+# define L_VERSION_NEEDED_TO_EXTRACT_1 1
+# define L_GENERAL_PURPOSE_BIT_FLAG 2
+# define L_COMPRESSION_METHOD 4
+# define L_LAST_MOD_FILE_TIME 6
+# define L_LAST_MOD_FILE_DATE 8
+# define L_CRC32 10
+# define L_COMPRESSED_SIZE 14
+# define L_UNCOMPRESSED_SIZE 18
+# define L_FILENAME_LENGTH 22
+# define L_EXTRA_FIELD_LENGTH 24
+
+ typedef uch cdir_byte_hdr[ CREC_SIZE ];
+# define C_VERSION_MADE_BY_0 0
+# define C_VERSION_MADE_BY_1 1
+# define C_VERSION_NEEDED_TO_EXTRACT_0 2
+# define C_VERSION_NEEDED_TO_EXTRACT_1 3
+# define C_GENERAL_PURPOSE_BIT_FLAG 4
+# define C_COMPRESSION_METHOD 6
+# define C_LAST_MOD_FILE_TIME 8
+# define C_LAST_MOD_FILE_DATE 10
+# define C_CRC32 12
+# define C_COMPRESSED_SIZE 16
+# define C_UNCOMPRESSED_SIZE 20
+# define C_FILENAME_LENGTH 24
+# define C_EXTRA_FIELD_LENGTH 26
+# define C_FILE_COMMENT_LENGTH 28
+# define C_DISK_NUMBER_START 30
+# define C_INTERNAL_FILE_ATTRIBUTES 32
+# define C_EXTERNAL_FILE_ATTRIBUTES 34
+# define C_RELATIVE_OFFSET_LOCAL_HEADER 38
+
+ typedef uch ec_byte_rec[ ECREC_SIZE+4 ];
+/* define SIGNATURE 0 space-holder only */
+# define NUMBER_THIS_DISK 4
+# define NUM_DISK_WITH_START_CENTRAL_DIR 6
+# define NUM_ENTRIES_CENTRL_DIR_THS_DISK 8
+# define TOTAL_ENTRIES_CENTRAL_DIR 10
+# define SIZE_CENTRAL_DIRECTORY 12
+# define OFFSET_START_CENTRAL_DIRECTORY 16
+# define ZIPFILE_COMMENT_LENGTH 20
+
+
+ typedef struct local_file_header { /* LOCAL */
+ uch version_needed_to_extract[2];
+ ush general_purpose_bit_flag;
+ ush compression_method;
+ ush last_mod_file_time;
+ ush last_mod_file_date;
+ ulg crc32;
+ ulg csize;
+ ulg ucsize;
+ ush filename_length;
+ ush extra_field_length;
+ } local_file_hdr;
+
+ typedef struct central_directory_file_header { /* CENTRAL */
+ uch version_made_by[2];
+ uch version_needed_to_extract[2];
+ ush general_purpose_bit_flag;
+ ush compression_method;
+ ush last_mod_file_time;
+ ush last_mod_file_date;
+ ulg crc32;
+ ulg csize;
+ ulg ucsize;
+ ush filename_length;
+ ush extra_field_length;
+ ush file_comment_length;
+ ush disk_number_start;
+ ush internal_file_attributes;
+ ulg external_file_attributes;
+ ulg relative_offset_local_header;
+ } cdir_file_hdr;
+
+ typedef struct end_central_dir_record { /* END CENTRAL */
+ ush number_this_disk;
+ ush num_disk_with_start_central_dir;
+ ush num_entries_centrl_dir_ths_disk;
+ ush total_entries_central_dir;
+ ulg size_central_directory;
+ ulg offset_start_central_directory;
+ ush zipfile_comment_length;
+ } ecdir_rec;
+
+
+/************/
+/* Macros */
+/************/
+
+#ifndef MAX
+# define MAX(a,b) ((a) > (b) ? (a) : (b))
+#endif
+#ifndef MIN
+# define MIN(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+
+/***********************/
+/* Function makeword() */
+/***********************/
+
+static ush makeword(b)
+ uch *b;
+{
+ /*
+ * Convert Intel style 'short' integer to non-Intel non-16-bit
+ * host format. This routine also takes care of byte-ordering.
+ */
+ return (ush)((b[1] << 8) | b[0]);
+}
+
+
+/***********************/
+/* Function makelong() */
+/***********************/
+
+static ulg makelong(sig)
+ uch *sig;
+{
+ /*
+ * Convert intel style 'long' variable to non-Intel non-16-bit
+ * host format. This routine also takes care of byte-ordering.
+ */
+ return (((ulg)sig[3]) << 24)
+ + (((ulg)sig[2]) << 16)
+ + (((ulg)sig[1]) << 8)
+ + ((ulg)sig[0]);
+}
+
+int
+read_zip_archive (zipf)
+ register ZipFile *zipf;
+{
+ int i;
+ int dir_last_pad;
+ char *dir_ptr;
+ char buffer[100];
+
+ zipf->size = lseek (zipf->fd, 0L, SEEK_END);
+
+ if (zipf->size < (ECREC_SIZE+4) || lseek (zipf->fd, (long)(-(ECREC_SIZE+4)), SEEK_CUR) <= 0)
+ return -1;
+ if (read (zipf->fd, buffer, ECREC_SIZE+4) != ECREC_SIZE+4)
+ return -2;
+ zipf->count = makeword(&buffer[TOTAL_ENTRIES_CENTRAL_DIR]);
+ zipf->dir_size = makelong(&buffer[SIZE_CENTRAL_DIRECTORY]);
+#define ALLOC malloc
+ /* Allocate 1 more to allow appending '\0' to last filename. */
+ zipf->central_directory = ALLOC (zipf->dir_size+1);
+ if (lseek (zipf->fd, -(zipf->dir_size+ECREC_SIZE+4), SEEK_CUR) < 0)
+ return -2;
+ if (read (zipf->fd, zipf->central_directory, zipf->dir_size) < 0)
+ return -2;
+
+#ifdef TEST
+ printf ("number_this_disk = %d\n", makeword(&buffer[NUMBER_THIS_DISK]));
+ printf ("num_disk_with_start_central_dir = %d\n", makeword(&buffer[NUM_DISK_WITH_START_CENTRAL_DIR]));
+
+ printf ("num_entries_centrl_dir_ths_disk = %d\n",
+ makeword(&buffer[NUM_ENTRIES_CENTRL_DIR_THS_DISK]));
+ printf ("total_entries_central_dir = %d\n",
+ makeword(&buffer[TOTAL_ENTRIES_CENTRAL_DIR]));
+ printf ("size_central_directory = %d\n",
+ makelong(&buffer[SIZE_CENTRAL_DIRECTORY]));
+ printf ("offset_start_central_directory = %d\n",
+ makelong(&buffer[OFFSET_START_CENTRAL_DIRECTORY]));
+ printf ("zipfile_comment_length = %d\n",
+ makeword(&buffer[ZIPFILE_COMMENT_LENGTH]));
+#endif
+
+ dir_last_pad = 0;
+ dir_ptr = zipf->central_directory;
+ for (i = 0; i < zipf->count; i++)
+ {
+ ZipDirectory *zipd = (ZipDirectory*)(dir_ptr + dir_last_pad);
+ long uncompressed_size = makelong (&dir_ptr[4+C_UNCOMPRESSED_SIZE]);
+ long filename_length = makeword (&dir_ptr[4+C_FILENAME_LENGTH]);
+ long extra_field_length = makeword (&dir_ptr[4+C_EXTRA_FIELD_LENGTH]);
+ long file_comment_length = makeword (&dir_ptr[4+C_FILE_COMMENT_LENGTH]);
+ int unpadded_direntry_length;
+ if ((dir_ptr-zipf->central_directory)+filename_length+CREC_SIZE+4>zipf->dir_size)
+ return -1;
+
+ zipd->filename_length = filename_length;
+ zipd->size = uncompressed_size;
+#ifdef __GNUC__
+#define DIR_ALIGN __alignof__(ZipDirectory)
+#else
+#define DIR_ALIGN sizeof(long)
+#endif
+ zipd->filestart = makelong (&dir_ptr[4+C_RELATIVE_OFFSET_LOCAL_HEADER])
+ + (LREC_SIZE+4) + filename_length + file_comment_length +
+ + (extra_field_length ? extra_field_length+4 : 0);
+ /* About the last term of the expression above. Should the same
+ apply if file_comment_length is not zero ? I've never seen
+ the comment field uses so far. FIXME. */
+ zipd->filename_offset = CREC_SIZE+4 - dir_last_pad;
+ unpadded_direntry_length
+ = zipd->filename_offset + zipd->filename_length + extra_field_length;
+ zipd->direntry_size =
+ ((unpadded_direntry_length + DIR_ALIGN) / DIR_ALIGN) * DIR_ALIGN;
+ dir_last_pad = zipd->direntry_size - unpadded_direntry_length;
+ dir_ptr = (char*)zipd + unpadded_direntry_length;
+ *dir_ptr = '\0';
+ }
+ return 0;
+}
+
+#ifdef TEST
+main ()
+{
+ ZipFile zipf[1];
+ ZipDirectory *zipd;
+ int i;
+
+ zipf->fd = 0;
+
+ i = read_zip_archive (zipf);
+ if (i)
+ {
+ fprintf (stderr, "Bad zip file.\n");
+ exit (i);
+ }
+
+ zipd = (ZipDirectory*) zipf->central_directory;
+ for (i = 0; i < zipf->count; i++, zipd = ZIPDIR_NEXT (zipd))
+ {
+ printf ("%d: size:%d, name(#%d)%s, offset:%d\n",
+ i, zipd->size, zipd->filename_length,
+ ZIPDIR_FILENAME (zipd),
+ zipd->filestart);
+ }
+}
+#endif
--- /dev/null
+/* Definitions for using a zipped' archive.
+
+ Copyright (C) 1996 Free Software Foundation, Inc.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+Java and all Java-based marks are trademarks or registered trademarks
+of Sun Microsystems, Inc. in the United States and other countries.
+The Free Software Foundation is independent of Sun Microsystems, Inc. */
+
+struct ZipFile {
+ int fd;
+ long size;
+ long count;
+ long dir_size;
+ char *central_directory;
+};
+
+typedef struct ZipFile ZipFile;
+
+struct ZipDirectory {
+ int direntry_size;
+ int filename_offset;
+ long size; /* length of file */
+ long filestart; /* start of file in archive */
+ long filename_length;
+ /* char mid_padding[...]; */
+ /* char filename[filename_length]; */
+ /* char end_padding[...]; */
+};
+
+typedef struct ZipDirectory ZipDirectory;
+
+struct ZipFileCache {
+ struct ZipFile z;
+ struct ZipFileCache *next;
+ char *name;
+};
+
+extern struct ZipFileCache *SeenZipFiles;
+
+#define ZIPDIR_FILENAME(ZIPD) ((char*)(ZIPD)+(ZIPD)->filename_offset)
+#define ZIPDIR_NEXT(ZIPD) \
+ ((ZipDirectory*)((char*)(ZIPD)+(ZIPD)->direntry_size))
+#define ZIPMAGIC 0x504b0304
projects / gcc.git / commitdiff