From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libjava/gcj/Makefile.am | 16 + libjava/gcj/Makefile.in | 618 +++++++++++++++++++++++++ libjava/gcj/array.h | 140 ++++++ libjava/gcj/cni.h | 149 +++++++ libjava/gcj/field.h | 192 ++++++++ libjava/gcj/javaprims.h | 989 +++++++++++++++++++++++++++++++++++++++++ libjava/gcj/libgcj-config.h.in | 13 + libjava/gcj/method.h | 44 ++ 8 files changed, 2161 insertions(+) create mode 100644 libjava/gcj/Makefile.am create mode 100644 libjava/gcj/Makefile.in create mode 100644 libjava/gcj/array.h create mode 100644 libjava/gcj/cni.h create mode 100644 libjava/gcj/field.h create mode 100644 libjava/gcj/javaprims.h create mode 100644 libjava/gcj/libgcj-config.h.in create mode 100644 libjava/gcj/method.h (limited to 'libjava/gcj') diff --git a/libjava/gcj/Makefile.am b/libjava/gcj/Makefile.am new file mode 100644 index 000000000..6fd187dfa --- /dev/null +++ b/libjava/gcj/Makefile.am @@ -0,0 +1,16 @@ +## Process this file with automake to produce Makefile.in. + +AUTOMAKE_OPTIONS = foreign + +# May be used by various substitution variables. +gcc_version := $(shell cat $(top_srcdir)/../gcc/BASE-VER) + +# autoconf2.13's target_alias +target_noncanonical = @target_noncanonical@ + +gcjdir = $(gxx_include_dir)/gcj +gcj_HEADERS = array.h cni.h field.h javaprims.h method.h + +tool_include_dir := $(libdir)/gcc/$(target_noncanonical)/$(gcc_version)/include +toolgcjdir := $(tool_include_dir)/gcj +toolgcj_HEADERS = libgcj-config.h diff --git a/libjava/gcj/Makefile.in b/libjava/gcj/Makefile.in new file mode 100644 index 000000000..626bfb3af --- /dev/null +++ b/libjava/gcj/Makefile.in @@ -0,0 +1,618 @@ +# Makefile.in generated by automake 1.11.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +target_triplet = @target@ +subdir = gcj +DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ + $(srcdir)/libgcj-config.h.in $(gcj_HEADERS) $(toolgcj_HEADERS) +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/libltdl/acinclude.m4 \ + $(top_srcdir)/../config/acx.m4 \ + $(top_srcdir)/../config/depstand.m4 \ + $(top_srcdir)/../config/enable.m4 \ + $(top_srcdir)/../config/gxx-include-dir.m4 \ + $(top_srcdir)/../config/iconv.m4 \ + $(top_srcdir)/../config/lcmessage.m4 \ + $(top_srcdir)/../config/ld-symbolic.m4 \ + $(top_srcdir)/../config/lead-dot.m4 \ + $(top_srcdir)/../config/lib-ld.m4 \ + $(top_srcdir)/../config/lib-link.m4 \ + $(top_srcdir)/../config/lib-prefix.m4 \ + $(top_srcdir)/../config/lthostflags.m4 \ + $(top_srcdir)/../config/multi.m4 \ + $(top_srcdir)/../config/no-executables.m4 \ + $(top_srcdir)/../config/override.m4 \ + $(top_srcdir)/../config/tls.m4 \ + $(top_srcdir)/../config/unwind_ipinfo.m4 \ + $(top_srcdir)/../libtool.m4 $(top_srcdir)/../ltgcc.m4 \ + $(top_srcdir)/../ltoptions.m4 $(top_srcdir)/../ltsugar.m4 \ + $(top_srcdir)/../ltversion.m4 $(top_srcdir)/../lt~obsolete.m4 \ + $(top_srcdir)/mingwld.m4 $(top_srcdir)/pkg.m4 \ + $(top_srcdir)/shlibpath.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +CONFIG_HEADER = $(top_builddir)/include/config.h libgcj-config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +SOURCES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__installdirs = "$(DESTDIR)$(gcjdir)" "$(DESTDIR)$(toolgcjdir)" +HEADERS = $(gcj_HEADERS) $(toolgcj_HEADERS) +ETAGS = etags +CTAGS = ctags +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +ANTLR_JAR = @ANTLR_JAR@ +AR = @AR@ +AS = @AS@ +ATOMICSPEC = @ATOMICSPEC@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +BACKTRACESPEC = @BACKTRACESPEC@ +BUILD_VERSION = @BUILD_VERSION@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CHECKREFSPEC = @CHECKREFSPEC@ +CLASSPATH_SEPARATOR = @CLASSPATH_SEPARATOR@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CPU = @CPU@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DIRLTDL = @DIRLTDL@ +DIVIDESPEC = @DIVIDESPEC@ +DLLTOOL = @DLLTOOL@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +ECJ_BUILD_JAR = @ECJ_BUILD_JAR@ +ECJ_JAR = @ECJ_JAR@ +EGREP = @EGREP@ +EXCEPTIONSPEC = @EXCEPTIONSPEC@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GCC_FOR_ECJX = @GCC_FOR_ECJX@ +GCC_UNWIND_INCLUDE = @GCC_UNWIND_INCLUDE@ +GCDEPS = @GCDEPS@ +GCINCS = @GCINCS@ +GCJ = @GCJ@ +GCJDEPMODE = @GCJDEPMODE@ +GCJFLAGS = @GCJFLAGS@ +GCJH = @GCJH@ +GCJVERSION = @GCJVERSION@ +GCJ_BIN_DIR = @GCJ_BIN_DIR@ +GCJ_FOR_ECJX = @GCJ_FOR_ECJX@ +GCLIBS = @GCLIBS@ +GCSPEC = @GCSPEC@ +GCTESTSPEC = @GCTESTSPEC@ +GLIB_CFLAGS = @GLIB_CFLAGS@ +GLIB_LIBS = @GLIB_LIBS@ +GREP = @GREP@ +GTK_CFLAGS = @GTK_CFLAGS@ +GTK_LIBS = @GTK_LIBS@ +HASH_SYNC_SPEC = @HASH_SYNC_SPEC@ +IEEESPEC = @IEEESPEC@ +INCLTDL = @INCLTDL@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +INTERPRETER = @INTERPRETER@ +JAR = @JAR@ +JAVA_HOME = @JAVA_HOME@ +JAVA_VERSION = @JAVA_VERSION@ +JC1GCSPEC = @JC1GCSPEC@ +JRE_BIN_DIR = @JRE_BIN_DIR@ +JRE_DIR = @JRE_DIR@ +JRE_LIB_DIR = @JRE_LIB_DIR@ +JRE_LNK = @JRE_LNK@ +JVM_JAR_DIR = @JVM_JAR_DIR@ +JVM_JAR_ROOT_DIR = @JVM_JAR_ROOT_DIR@ +JVM_ROOT_DIR = @JVM_ROOT_DIR@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LDLIBICONV = @LDLIBICONV@ +LD_FINISH_STATIC_SPEC = @LD_FINISH_STATIC_SPEC@ +LD_START_STATIC_SPEC = @LD_START_STATIC_SPEC@ +LIBART_CFLAGS = @LIBART_CFLAGS@ +LIBART_LIBS = @LIBART_LIBS@ +LIBDIR = @LIBDIR@ +LIBFFI = @LIBFFI@ +LIBFFIINCS = @LIBFFIINCS@ +LIBGCJDEBUG = @LIBGCJDEBUG@ +LIBGCJTESTSPEC = @LIBGCJTESTSPEC@ +LIBGCJ_BC_SPEC = @LIBGCJ_BC_SPEC@ +LIBGCJ_CFLAGS = @LIBGCJ_CFLAGS@ +LIBGCJ_CXXFLAGS = @LIBGCJ_CXXFLAGS@ +LIBGCJ_JAVAFLAGS = @LIBGCJ_JAVAFLAGS@ +LIBGCJ_LD_SYMBOLIC = @LIBGCJ_LD_SYMBOLIC@ +LIBGCJ_LD_SYMBOLIC_FUNCTIONS = @LIBGCJ_LD_SYMBOLIC_FUNCTIONS@ +LIBGCJ_SPEC = @LIBGCJ_SPEC@ +LIBGCJ_SUBLIB_CORE_EXTRA_DEPS = @LIBGCJ_SUBLIB_CORE_EXTRA_DEPS@ +LIBGCJ_SUBLIB_LTFLAGS = @LIBGCJ_SUBLIB_LTFLAGS@ +LIBICONV = @LIBICONV@ +LIBLTDL = @LIBLTDL@ +LIBMATHSPEC = @LIBMATHSPEC@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBSTDCXXSPEC = @LIBSTDCXXSPEC@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBICONV = @LTLIBICONV@ +LTLIBOBJS = @LTLIBOBJS@ +MAINT = @MAINT@ +MAKE = @MAKE@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OS = @OS@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +PKG_CONFIG = @PKG_CONFIG@ +PLATFORM = @PLATFORM@ +RANLIB = @RANLIB@ +SDK_BIN_DIR = @SDK_BIN_DIR@ +SDK_INCLUDE_DIR = @SDK_INCLUDE_DIR@ +SDK_LIB_DIR = @SDK_LIB_DIR@ +SDK_LNK = @SDK_LNK@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +SYSDEP_SOURCES = @SYSDEP_SOURCES@ +SYSTEMSPEC = @SYSTEMSPEC@ +SYS_ZLIBS = @SYS_ZLIBS@ +THREADCXXFLAGS = @THREADCXXFLAGS@ +THREADDEPS = @THREADDEPS@ +THREADINCS = @THREADINCS@ +THREADLDFLAGS = @THREADLDFLAGS@ +THREADLIBS = @THREADLIBS@ +THREADSPEC = @THREADSPEC@ +THREADSTARTFILESPEC = @THREADSTARTFILESPEC@ +TOOLKIT = @TOOLKIT@ +UNZIP = @UNZIP@ +VERSION = @VERSION@ +XMKMF = @XMKMF@ +X_CFLAGS = @X_CFLAGS@ +X_EXTRA_LIBS = @X_EXTRA_LIBS@ +X_LIBS = @X_LIBS@ +X_PRE_LIBS = @X_PRE_LIBS@ +ZINCS = @ZINCS@ +ZIP = @ZIP@ +ZLIBS = @ZLIBS@ +ZLIBSPEC = @ZLIBSPEC@ +ZLIBTESTSPEC = @ZLIBTESTSPEC@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +ac_ct_GCJ = @ac_ct_GCJ@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_libsubdir = @build_libsubdir@ +build_os = @build_os@ +build_subdir = @build_subdir@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +dbexecdir = @dbexecdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +extra_ldflags = @extra_ldflags@ +extra_ldflags_libjava = @extra_ldflags_libjava@ +gcc_suffix = @gcc_suffix@ +gcjsubdir = @gcjsubdir@ +gxx_include_dir = @gxx_include_dir@ +here = @here@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_exeext = @host_exeext@ +host_os = @host_os@ +host_subdir = @host_subdir@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +libstdcxx_incdir = @libstdcxx_incdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +lt_host_flags = @lt_host_flags@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +mkinstalldirs = @mkinstalldirs@ +multi_basedir = @multi_basedir@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +python_mod_dir = @python_mod_dir@ +python_mod_dir_expanded = @python_mod_dir_expanded@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +subdirs = @subdirs@ +sysconfdir = @sysconfdir@ +target = @target@ +target_alias = @target_alias@ +target_cpu = @target_cpu@ + +# autoconf2.13's target_alias +target_noncanonical = @target_noncanonical@ +target_os = @target_os@ +target_subdir = @target_subdir@ +target_vendor = @target_vendor@ +toolexecdir = @toolexecdir@ +toolexeclibdir = @toolexeclibdir@ +toolexecmainlibdir = @toolexecmainlibdir@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AUTOMAKE_OPTIONS = foreign + +# May be used by various substitution variables. +gcc_version := $(shell cat $(top_srcdir)/../gcc/BASE-VER) +gcjdir = $(gxx_include_dir)/gcj +gcj_HEADERS = array.h cni.h field.h javaprims.h method.h +tool_include_dir := $(libdir)/gcc/$(target_noncanonical)/$(gcc_version)/include +toolgcjdir := $(tool_include_dir)/gcj +toolgcj_HEADERS = libgcj-config.h +all: libgcj-config.h + $(MAKE) $(AM_MAKEFLAGS) all-am + +.SUFFIXES: +$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign gcj/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign gcj/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +libgcj-config.h: stamp-h2 + @if test ! -f $@; then \ + rm -f stamp-h2; \ + $(MAKE) $(AM_MAKEFLAGS) stamp-h2; \ + else :; fi + +stamp-h2: $(srcdir)/libgcj-config.h.in $(top_builddir)/config.status + @rm -f stamp-h2 + cd $(top_builddir) && $(SHELL) ./config.status gcj/libgcj-config.h +$(srcdir)/libgcj-config.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) + ($(am__cd) $(top_srcdir) && $(AUTOHEADER)) + rm -f stamp-h2 + touch $@ + +distclean-hdr: + -rm -f libgcj-config.h stamp-h2 + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs +install-gcjHEADERS: $(gcj_HEADERS) + @$(NORMAL_INSTALL) + test -z "$(gcjdir)" || $(MKDIR_P) "$(DESTDIR)$(gcjdir)" + @list='$(gcj_HEADERS)'; test -n "$(gcjdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(gcjdir)'"; \ + $(INSTALL_HEADER) $$files "$(DESTDIR)$(gcjdir)" || exit $$?; \ + done + +uninstall-gcjHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(gcj_HEADERS)'; test -n "$(gcjdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(gcjdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(gcjdir)" && rm -f $$files +install-toolgcjHEADERS: $(toolgcj_HEADERS) + @$(NORMAL_INSTALL) + test -z "$(toolgcjdir)" || $(MKDIR_P) "$(DESTDIR)$(toolgcjdir)" + @list='$(toolgcj_HEADERS)'; test -n "$(toolgcjdir)" || list=; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(toolgcjdir)'"; \ + $(INSTALL_HEADER) $$files "$(DESTDIR)$(toolgcjdir)" || exit $$?; \ + done + +uninstall-toolgcjHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(toolgcj_HEADERS)'; test -n "$(toolgcjdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + test -n "$$files" || exit 0; \ + echo " ( cd '$(DESTDIR)$(toolgcjdir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(toolgcjdir)" && rm -f $$files + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) libgcj-config.h.in $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) libgcj-config.h.in $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) libgcj-config.h.in $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) libgcj-config.h.in $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags +check-am: all-am +check: check-am +all-am: Makefile $(HEADERS) libgcj-config.h +installdirs: + for dir in "$(DESTDIR)$(gcjdir)" "$(DESTDIR)$(toolgcjdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-hdr distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-gcjHEADERS install-toolgcjHEADERS + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-gcjHEADERS uninstall-toolgcjHEADERS + +.MAKE: all install-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ + clean-libtool ctags distclean distclean-generic distclean-hdr \ + distclean-libtool distclean-tags dvi dvi-am html html-am info \ + info-am install install-am install-data install-data-am \ + install-dvi install-dvi-am install-exec install-exec-am \ + install-gcjHEADERS install-html install-html-am install-info \ + install-info-am install-man install-pdf install-pdf-am \ + install-ps install-ps-am install-strip install-toolgcjHEADERS \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic \ + mostlyclean-libtool pdf pdf-am ps ps-am tags uninstall \ + uninstall-am uninstall-gcjHEADERS uninstall-toolgcjHEADERS + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/libjava/gcj/array.h b/libjava/gcj/array.h new file mode 100644 index 000000000..4f134f33c --- /dev/null +++ b/libjava/gcj/array.h @@ -0,0 +1,140 @@ +// array.h - Header file for CNI arrays. -*- c++ -*- + +/* Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __GCJ_ARRAY_H__ +#define __GCJ_ARRAY_H__ + +#include + +extern "Java" { + +class __JArray : public java::lang::Object +{ +protected: + // This is just a hack to work around a warning emitted by the C++ + // compiler. We initialize `length' evilly, but it doesn't know + // that. + __JArray () : length (0) + { + } +public: + const jsize length; + friend jsize JvGetArrayLength (__JArray*); +}; + +template +class JArray; + +template +inline T* elements(JArray& x); +template +inline T* elements(JArray* x); + +template +class JArray : public __JArray +{ + T data[0]; +public: + friend T* elements<>(JArray& x); + friend T* elements<>(JArray* x); + // T* getData() { return data; } + // T& operator[](jint i) { return data[i]; } +}; + +template +inline T* elements(JArray& x) { return x.data; } +template +inline T* elements(JArray* x) { return x->data; } + +} // end extern "Java" + +/* These typesdefs match those in JNI. */ +typedef __JArray *jarray; +typedef JArray *jobjectArray; +typedef JArray *jbooleanArray; +typedef JArray *jbyteArray; +typedef JArray *jcharArray; +typedef JArray *jshortArray; +typedef JArray *jintArray; +typedef JArray *jlongArray; +typedef JArray *jfloatArray; +typedef JArray *jdoubleArray; +typedef JArray *jstringArray; + +extern java::lang::Class _Jv_byteClass, _Jv_shortClass, _Jv_intClass, + _Jv_longClass, _Jv_booleanClass, _Jv_charClass, _Jv_floatClass, + _Jv_doubleClass, _Jv_voidClass; +/* The definition of this macro cannot be enclosed in parentheses + because "JvPrimClass(x)" is used as a template argument. */ +#define JvPrimClass(TYPE) & _Jv_##TYPE##Class + +extern "C" jobjectArray _Jv_NewObjectArray(jsize length, jclass, jobject init); +extern "C" jobject _Jv_NewPrimArray (jclass eltype, jint count); + +extern inline jobjectArray +JvNewObjectArray (jsize length, jclass cls, jobject init) +{ + return _Jv_NewObjectArray (length, cls, init); +} + +extern inline jcharArray +JvNewCharArray (jint length) +{ + return (jcharArray) _Jv_NewPrimArray (JvPrimClass (char), length); +} + +extern inline jbooleanArray +JvNewBooleanArray (jint length) +{ + return (jbooleanArray) _Jv_NewPrimArray (JvPrimClass (boolean), length); +} + +extern inline jbyteArray +JvNewByteArray (jint length) +{ + return (jbyteArray) _Jv_NewPrimArray (JvPrimClass (byte), length); +} + +extern inline jshortArray +JvNewShortArray (jint length) +{ + return (jshortArray) _Jv_NewPrimArray (JvPrimClass (short), length); +} + +extern inline jintArray +JvNewIntArray (jint length) +{ + return (jintArray) _Jv_NewPrimArray (JvPrimClass (int), length); +} + +extern inline jlongArray +JvNewLongArray (jint length) +{ + return (jlongArray) _Jv_NewPrimArray (JvPrimClass (long), length); +} + +extern inline jfloatArray +JvNewFloatArray (jint length) +{ + return (jfloatArray) _Jv_NewPrimArray (JvPrimClass (float), length); +} + +extern inline jdoubleArray +JvNewDoubleArray (jint length) +{ + return (jdoubleArray) _Jv_NewPrimArray (JvPrimClass (double), length); +} + + +extern "C" jstringArray JvConvertArgv(int argc, const char **argv); + +inline jsize JvGetArrayLength (jarray array) { return array->length; } + +#endif /* __GCJ_ARRAY_H__ */ diff --git a/libjava/gcj/cni.h b/libjava/gcj/cni.h new file mode 100644 index 000000000..b94260b84 --- /dev/null +++ b/libjava/gcj/cni.h @@ -0,0 +1,149 @@ +// gcj/cni.h -*- c++ -*- +// This file describes the Compiled Native Interface, CNI. +// It provides a nicer interface to many of the things in gcj/javaprims.h. + +/* Copyright (C) 1998, 1999, 2002 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __GCJ_CNI_H__ +#define __GCJ_CNI_H__ + +#include +#include + +#include +#include + +#include + +extern "C" void _Jv_InitClass (jclass); +extern "C" void *_Jv_AllocBytes (jsize size) __attribute__((__malloc__)); + +extern inline void +JvInitClass (jclass cls) +{ + return _Jv_InitClass (cls); +} + +extern inline void * +JvAllocBytes (jsize sz) +{ + return _Jv_AllocBytes (sz); +} + +extern inline jstring +JvAllocString (jsize sz) +{ + return _Jv_AllocString (sz); +} + +extern inline jstring +JvNewString (const jchar *chars, jsize len) +{ + return _Jv_NewString (chars, len); +} + +extern inline jstring +JvNewStringLatin1 (const char *bytes, jsize len) +{ + return _Jv_NewStringLatin1 (bytes, len); +} + +extern inline jstring +JvNewStringLatin1 (const char *bytes) +{ + return _Jv_NewStringLatin1 (bytes, strlen (bytes)); +} + +extern inline jchar * +_Jv_GetStringChars (jstring str) +{ + return (jchar*)((char*) str->data + str->boffset); +} + +extern inline jchar* +JvGetStringChars (jstring str) +{ + return _Jv_GetStringChars (str); +} + +extern inline jsize +JvGetStringUTFLength (jstring string) +{ + return _Jv_GetStringUTFLength (string); +} + +extern inline jsize +JvGetStringUTFRegion (jstring str, jsize start, jsize len, char *buf) +{ + return _Jv_GetStringUTFRegion (str, start, len, buf); +} + +extern inline jstring +JvNewStringUTF (const char *bytes) +{ + return _Jv_NewStringUTF (bytes); +} + +class JvSynchronize +{ +private: + jobject obj; +public: + JvSynchronize (const jobject &o) : obj (o) + { _Jv_MonitorEnter (obj); } + ~JvSynchronize () + { _Jv_MonitorExit (obj); } +}; + +/* Call malloc, but throw exception if insufficient memory. */ +extern inline void * +JvMalloc (jsize size) +{ + return _Jv_Malloc (size); +} + +extern inline void * +JvRealloc (void *ptr, jsize size) +{ + return _Jv_Realloc (ptr, size); +} + +extern inline void +JvFree (void *ptr) +{ + return _Jv_Free (ptr); +} + +typedef struct _Jv_VMOption JvVMOption; +typedef struct _Jv_VMInitArgs JvVMInitArgs; + +extern inline jint +JvCreateJavaVM (JvVMInitArgs* vm_args) +{ + return _Jv_CreateJavaVM (vm_args); +} + +extern inline java::lang::Thread* +JvAttachCurrentThread (jstring name, java::lang::ThreadGroup* group) +{ + return _Jv_AttachCurrentThread (name, group); +} + +extern inline java::lang::Thread* +JvAttachCurrentThreadAsDaemon (jstring name, java::lang::ThreadGroup* group) +{ + return _Jv_AttachCurrentThreadAsDaemon (name, group); +} + +extern inline jint +JvDetachCurrentThread (void) +{ + return _Jv_DetachCurrentThread (); +} +#endif /* __GCJ_CNI_H__ */ diff --git a/libjava/gcj/field.h b/libjava/gcj/field.h new file mode 100644 index 000000000..2f483eb38 --- /dev/null +++ b/libjava/gcj/field.h @@ -0,0 +1,192 @@ +// field.h - Header file for fieldID instances. -*- c++ -*- + +/* Copyright (C) 1998, 1999, 2000, 2004, 2006 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __GCJ_FIELD_H__ +#define __GCJ_FIELD_H__ + +#include +#include +#include +#include + +#define _Jv_FIELD_UNRESOLVED_FLAG 0x8000 + +struct _Jv_Field +{ + struct _Jv_Utf8Const* name; + + /* The type of the field, if isResolved(). + If !isResolved(): The fields's signature as a (Utf8Const*). */ + jclass type; + + _Jv_ushort flags; + + _Jv_ushort bsize; /* not really needed ... */ + + union { + jint boffset; /* offset in bytes for instance field */ + char* addr; /* address of static field */ + + jobject* object_addr; /* address of static object field... etc */ + jbyte* byte_addr; + jshort* short_addr; + jchar* char_addr; + jint* int_addr; + jlong* long_addr; + jfloat* float_addr; + jdouble* double_addr; + } u; + +#ifdef __cplusplus + jboolean isResolved () + { return ! (flags & _Jv_FIELD_UNRESOLVED_FLAG); } + + public: + + int getOffset () { return u.boffset; } + + jobject getObjectField (jobject obj) + { return *(jobject *)((char *)obj + getOffset ()); } + + jfieldID getNextField () { return this + 1; } + + jboolean isRef () + { + if (!isResolved ()) + { + char first = ((_Jv_Utf8Const*)type)->first(); + return first == '[' || first == 'L'; + } + else + { + return ! type->isPrimitive (); + } + } + + jclass getClass () + { + // We can't use JvAssert here because it is not in a public + // header. + // JvAssert (isResolved ()); + return type; + } + + // Need to mask off all unknown/internal flags before returning. + int getModifiers() + { + return flags & java::lang::reflect::Modifier::ALL_FLAGS; + } + + _Jv_Utf8Const * getNameUtf8Const (jclass) { return name; } +#endif +}; + +#ifdef __cplusplus + +inline jbyte +_Jv_GetStaticByteField (jclass, _Jv_Field* field) +{ + return * (jbyte *) field->u.addr; +} + +inline jshort +_Jv_GetStaticShortField (jclass, _Jv_Field* field) +{ + return * (jshort *) field->u.addr; +} + +inline jint +_Jv_GetStaticIntField (jclass, _Jv_Field* field) +{ + return * (jint *) field->u.addr; +} + +inline jlong +_Jv_GetStaticLongField (jclass, _Jv_Field* field) +{ + return * (jlong *) field->u.addr; +} + +inline jobject +_Jv_GetObjectField (jobject obj, _Jv_Field* field) +{ + return field->getObjectField (obj); +} + +inline jbyte +_Jv_GetByteField (jobject obj, _Jv_Field* field) +{ + return * (jbyte *) ((char*) obj + field->getOffset ()); +} + +inline jshort +_Jv_GetShortField (jobject obj, _Jv_Field* field) +{ + return * (jshort *) ((char*) obj + field->getOffset ()); +} +inline jint +_Jv_GetIntField (jobject obj, _Jv_Field* field) +{ + return * (jint *) ((char*) obj + field->getOffset ()); +} +inline jlong +_Jv_GetLongField (jobject obj, _Jv_Field* field) +{ + return * (jlong *) ((char*) obj + field->getOffset ()); +} + +extern inline jfieldID +_Jv_FromReflectedField (java::lang::reflect::Field *field) +{ + return (jfieldID) ((char *) field->declaringClass->fields + field->offset); +} + + +#ifdef __GCJ_CNI_H__ +extern inline jfieldID +JvGetFirstInstanceField (jclass klass) +{ + return &(klass->fields[klass->static_field_count]); +} + +extern inline jint +JvNumInstanceFields (jclass klass) +{ + return klass->field_count - klass->static_field_count; +} + +extern inline jfieldID +JvGetFirstStaticField (jclass klass) +{ + return &(klass->fields[0]); +} + +extern inline jint +JvNumStaticFields (jclass klass) +{ + return klass->static_field_count; +} + +extern inline jboolean +JvFieldIsRef (jfieldID field) +{ + return field->isRef () && field->type != &gnu::gcj::RawData::class$; +} + +extern inline jobject +JvGetObjectField (jobject obj, _Jv_Field* field) +{ + return _Jv_GetObjectField (obj, field); +} +#endif /* defined (__GCJ_CNI_H__) */ + +#endif /* __cplusplus */ + +#endif /* __GCJ_FIELD_H */ diff --git a/libjava/gcj/javaprims.h b/libjava/gcj/javaprims.h new file mode 100644 index 000000000..3a0c964a4 --- /dev/null +++ b/libjava/gcj/javaprims.h @@ -0,0 +1,989 @@ +// javaprims.h - Main external header file for libgcj. -*- c++ -*- + + +/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, + 2008, 2009 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JAVAPRIMS_H__ +#define __JAVAPRIMS_H__ + +// Force C++ compiler to use Java-style exceptions. +#pragma GCC java_exceptions + +#include + +// FIXME: this is a hack until we get a proper gcjh. +// It is needed to work around system header files that define TRUE +// and FALSE. +#undef TRUE +#define TRUE TRUE +#undef FALSE +#define FALSE FALSE + +// To force selection of correct types that will mangle consistently +// across platforms. +extern "Java" +{ + typedef __java_byte jbyte; + typedef __java_short jshort; + typedef __java_int jint; + typedef __java_long jlong; + typedef __java_float jfloat; + typedef __java_double jdouble; + typedef __java_char jchar; + typedef __java_boolean jboolean; + typedef jint jsize; + + // The following class declarations are automatically generated by + // the `classes.pl' script. + namespace java + { + namespace io + { + class BufferedInputStream; + class BufferedOutputStream; + class BufferedReader; + class BufferedWriter; + class ByteArrayInputStream; + class ByteArrayOutputStream; + class CharArrayReader; + class CharArrayWriter; + class CharConversionException; + class Closeable; + class DataInput; + class DataInputStream; + class DataOutput; + class DataOutputStream; + class DeleteFileHelper; + class DeleteFileHelper$1; + class EOFException; + class Externalizable; + class File; + class FileDescriptor; + class FileFilter; + class FileInputStream; + class FileNotFoundException; + class FileOutputStream; + class FilePermission; + class FileReader; + class FileWriter; + class FilenameFilter; + class FilterInputStream; + class FilterOutputStream; + class FilterReader; + class FilterWriter; + class Flushable; + class IOException; + class InputStream; + class InputStreamReader; + class InterruptedIOException; + class InvalidClassException; + class InvalidObjectException; + class LineNumberInputStream; + class LineNumberReader; + class NotActiveException; + class NotSerializableException; + class ObjectInput; + class ObjectInputStream; + class ObjectInputStream$1; + class ObjectInputStream$2; + class ObjectInputStream$GetField; + class ObjectInputStream$ValidatorAndPriority; + class ObjectInputValidation; + class ObjectOutput; + class ObjectOutputStream; + class ObjectOutputStream$1; + class ObjectOutputStream$PutField; + class ObjectStreamClass; + class ObjectStreamClass$1; + class ObjectStreamClass$2; + class ObjectStreamClass$InterfaceComparator; + class ObjectStreamClass$MemberComparator; + class ObjectStreamConstants; + class ObjectStreamException; + class ObjectStreamField; + class ObjectStreamField$1; + class OptionalDataException; + class OutputStream; + class OutputStreamWriter; + class PipedInputStream; + class PipedOutputStream; + class PipedReader; + class PipedWriter; + class PrintStream; + class PrintWriter; + class PushbackInputStream; + class PushbackReader; + class RandomAccessFile; + class Reader; + class SequenceInputStream; + class Serializable; + class SerializablePermission; + class StreamCorruptedException; + class StreamTokenizer; + class StringBufferInputStream; + class StringReader; + class StringWriter; + class SyncFailedException; + class UTFDataFormatException; + class UnsupportedEncodingException; + class VMObjectInputStream; + class VMObjectStreamClass; + class WriteAbortedException; + class Writer; + } + + namespace lang + { + class AbstractMethodError; + class AbstractStringBuffer; + class Appendable; + class ArithmeticException; + class ArrayIndexOutOfBoundsException; + class ArrayStoreException; + class AssertionError; + class Boolean; + class Byte; + class CharSequence; + class Character; + class Character$Subset; + class Character$UnicodeBlock; + class Character$UnicodeBlock$NameType; + class Class; + class Class$1; + class ClassCastException; + class ClassCircularityError; + class ClassFormatError; + class ClassLoader; + class ClassLoader$AnnotationsKey; + class ClassNotFoundException; + class CloneNotSupportedException; + class Cloneable; + class Comparable; + class Compiler; + class Deprecated; + class Double; + class EcosProcess; + class Enum; + class EnumConstantNotPresentException; + class Error; + class Exception; + class ExceptionInInitializerError; + class Float; + class IllegalAccessError; + class IllegalAccessException; + class IllegalArgumentException; + class IllegalMonitorStateException; + class IllegalStateException; + class IllegalThreadStateException; + class IncompatibleClassChangeError; + class IndexOutOfBoundsException; + class InheritableThreadLocal; + class InstantiationError; + class InstantiationException; + class Integer; + class InternalError; + class InterruptedException; + class Iterable; + class LinkageError; + class Long; + class Math; + class NegativeArraySizeException; + class NoClassDefFoundError; + class NoSuchFieldError; + class NoSuchFieldException; + class NoSuchMethodError; + class NoSuchMethodException; + class NullPointerException; + class Number; + class NumberFormatException; + class Object; + class OutOfMemoryError; + class Override; + class Package; + class PosixProcess; + class PosixProcess$EOFInputStream; + class PosixProcess$ProcessManager; + class Process; + class ProcessBuilder; + class Readable; + class Runnable; + class Runtime; + class RuntimeException; + class RuntimePermission; + class SecurityException; + class SecurityManager; + class SecurityManager$1; + class Short; + class StackOverflowError; + class StackTraceElement; + class StrictMath; + class String; + class String$CaseInsensitiveComparator; + class StringBuffer; + class StringBuilder; + class StringIndexOutOfBoundsException; + class SuppressWarnings; + class System; + class System$EnvironmentCollection; + class System$EnvironmentMap; + class System$EnvironmentSet; + class Thread; + class Thread$State; + class Thread$UncaughtExceptionHandler; + class ThreadDeath; + class ThreadGroup; + class ThreadLocal; + class ThreadLocalMap; + class ThreadLocalMap$Entry; + class Throwable; + class Throwable$StaticData; + class TypeNotPresentException; + class UnknownError; + class UnsatisfiedLinkError; + class UnsupportedClassVersionError; + class UnsupportedOperationException; + class VMClassLoader; + class VMCompiler; + class VMDouble; + class VMFloat; + class VMProcess; + class VMThrowable; + class VerifyError; + class VirtualMachineError; + class Void; + class Win32Process; + class Win32Process$EOFInputStream; + namespace annotation + { + class Annotation; + class AnnotationFormatError; + class AnnotationTypeMismatchException; + class Documented; + class ElementType; + class IncompleteAnnotationException; + class Inherited; + class Retention; + class RetentionPolicy; + class Target; + } + + namespace instrument + { + class ClassDefinition; + class ClassFileTransformer; + class IllegalClassFormatException; + class Instrumentation; + class UnmodifiableClassException; + } + + namespace management + { + class ClassLoadingMXBean; + class CompilationMXBean; + class GarbageCollectorMXBean; + class LockInfo; + class ManagementFactory; + class ManagementFactory$ManagementInvocationHandler; + class ManagementPermission; + class MemoryMXBean; + class MemoryManagerMXBean; + class MemoryNotificationInfo; + class MemoryPoolMXBean; + class MemoryType; + class MemoryUsage; + class MonitorInfo; + class OperatingSystemMXBean; + class RuntimeMXBean; + class ThreadInfo; + class ThreadMXBean; + class VMManagementFactory; + } + + namespace ref + { + class PhantomReference; + class Reference; + class ReferenceQueue; + class SoftReference; + class WeakReference; + } + + namespace reflect + { + class AccessibleObject; + class AnnotatedElement; + class Array; + class Constructor; + class Field; + class GenericArrayType; + class GenericDeclaration; + class GenericSignatureFormatError; + class InvocationHandler; + class InvocationTargetException; + class MalformedParameterizedTypeException; + class Member; + class Method; + class Modifier; + class ParameterizedType; + class Proxy; + class Proxy$ClassFactory; + class Proxy$ProxyData; + class Proxy$ProxySignature; + class Proxy$ProxyType; + class ReflectPermission; + class Type; + class TypeVariable; + class UndeclaredThrowableException; + class VMProxy; + class WildcardType; + } + } + + namespace util + { + class AbstractCollection; + class AbstractList; + class AbstractList$1; + class AbstractList$2; + class AbstractList$3; + class AbstractList$RandomAccessSubList; + class AbstractList$SubList; + class AbstractMap; + class AbstractMap$1; + class AbstractMap$2; + class AbstractMap$3; + class AbstractMap$4; + class AbstractMap$SimpleEntry; + class AbstractMap$SimpleImmutableEntry; + class AbstractQueue; + class AbstractSequentialList; + class AbstractSet; + class ArrayDeque; + class ArrayDeque$DeqIterator; + class ArrayDeque$DescendingIterator; + class ArrayList; + class Arrays; + class Arrays$ArrayList; + class BitSet; + class Calendar; + class Collection; + class Collections; + class Collections$1; + class Collections$1$SynchronizedMapEntry; + class Collections$2; + class Collections$3; + class Collections$4; + class Collections$5; + class Collections$6; + class Collections$7; + class Collections$8; + class Collections$9; + class Collections$CheckedCollection; + class Collections$CheckedIterator; + class Collections$CheckedList; + class Collections$CheckedListIterator; + class Collections$CheckedMap; + class Collections$CheckedMap$CheckedEntrySet; + class Collections$CheckedRandomAccessList; + class Collections$CheckedSet; + class Collections$CheckedSortedMap; + class Collections$CheckedSortedSet; + class Collections$CopiesList; + class Collections$EmptyList; + class Collections$EmptyMap; + class Collections$EmptySet; + class Collections$LIFOQueue; + class Collections$MapSet; + class Collections$ReverseComparator; + class Collections$SingletonList; + class Collections$SingletonMap; + class Collections$SingletonSet; + class Collections$SynchronizedCollection; + class Collections$SynchronizedIterator; + class Collections$SynchronizedList; + class Collections$SynchronizedListIterator; + class Collections$SynchronizedMap; + class Collections$SynchronizedRandomAccessList; + class Collections$SynchronizedSet; + class Collections$SynchronizedSortedMap; + class Collections$SynchronizedSortedSet; + class Collections$UnmodifiableCollection; + class Collections$UnmodifiableIterator; + class Collections$UnmodifiableList; + class Collections$UnmodifiableListIterator; + class Collections$UnmodifiableMap; + class Collections$UnmodifiableMap$UnmodifiableEntrySet; + class Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableMapEntry; + class Collections$UnmodifiableRandomAccessList; + class Collections$UnmodifiableSet; + class Collections$UnmodifiableSortedMap; + class Collections$UnmodifiableSortedSet; + class Comparator; + class ConcurrentModificationException; + class Currency; + class Date; + class Deque; + class Dictionary; + class DuplicateFormatFlagsException; + class EmptyStackException; + class EnumMap; + class EnumMap$1; + class EnumMap$2; + class EnumMap$3; + class EnumMap$4; + class EnumMap$5; + class EnumMap$6; + class EnumMap$7; + class EnumSet; + class EnumSet$1; + class EnumSet$2; + class Enumeration; + class EventListener; + class EventListenerProxy; + class EventObject; + class FormatFlagsConversionMismatchException; + class Formattable; + class FormattableFlags; + class Formatter; + class Formatter$BigDecimalLayoutForm; + class FormatterClosedException; + class GregorianCalendar; + class HashMap; + class HashMap$1; + class HashMap$2; + class HashMap$3; + class HashMap$HashEntry; + class HashMap$HashIterator; + class HashSet; + class Hashtable; + class Hashtable$1; + class Hashtable$2; + class Hashtable$3; + class Hashtable$EntryEnumerator; + class Hashtable$EntryIterator; + class Hashtable$HashEntry; + class Hashtable$KeyEnumerator; + class Hashtable$KeyIterator; + class Hashtable$ValueEnumerator; + class Hashtable$ValueIterator; + class IdentityHashMap; + class IdentityHashMap$1; + class IdentityHashMap$2; + class IdentityHashMap$3; + class IdentityHashMap$IdentityEntry; + class IdentityHashMap$IdentityIterator; + class IllegalFormatCodePointException; + class IllegalFormatConversionException; + class IllegalFormatException; + class IllegalFormatFlagsException; + class IllegalFormatPrecisionException; + class IllegalFormatWidthException; + class InputMismatchException; + class InvalidPropertiesFormatException; + class Iterator; + class LinkedHashMap; + class LinkedHashMap$1; + class LinkedHashMap$LinkedHashEntry; + class LinkedHashSet; + class LinkedList; + class LinkedList$1; + class LinkedList$Entry; + class LinkedList$LinkedListItr; + class List; + class ListIterator; + class ListResourceBundle; + class Locale; + class Map; + class Map$Entry; + class MissingFormatArgumentException; + class MissingFormatWidthException; + class MissingResourceException; + class NavigableMap; + class NavigableSet; + class NoSuchElementException; + class Observable; + class Observer; + class PriorityQueue; + class PriorityQueue$1; + class Properties; + class PropertyPermission; + class PropertyPermissionCollection; + class PropertyResourceBundle; + class Queue; + class Random; + class RandomAccess; + class ResourceBundle; + class ResourceBundle$1; + class ResourceBundle$BundleKey; + class Scanner; + class ServiceConfigurationError; + class ServiceLoader; + class ServiceLoader$1; + class Set; + class SimpleTimeZone; + class SortedMap; + class SortedSet; + class Stack; + class StringTokenizer; + class TimeZone; + class TimeZone$1; + class Timer; + class Timer$Scheduler; + class Timer$TaskQueue; + class TimerTask; + class TooManyListenersException; + class TreeMap; + class TreeMap$1; + class TreeMap$2; + class TreeMap$3; + class TreeMap$4; + class TreeMap$5; + class TreeMap$6; + class TreeMap$7; + class TreeMap$DescendingMap; + class TreeMap$DescendingSet; + class TreeMap$EntrySet; + class TreeMap$KeySet; + class TreeMap$NavigableEntrySet; + class TreeMap$NavigableKeySet; + class TreeMap$Node; + class TreeMap$SubMap; + class TreeMap$SubMap$EntrySet; + class TreeMap$SubMap$KeySet; + class TreeMap$SubMap$NavigableEntrySet; + class TreeMap$SubMap$NavigableKeySet; + class TreeMap$TreeIterator; + class TreeSet; + class UUID; + class UnknownFormatConversionException; + class UnknownFormatFlagsException; + class VMTimeZone; + class Vector; + class Vector$1; + class WeakHashMap; + class WeakHashMap$1; + class WeakHashMap$2; + class WeakHashMap$WeakBucket; + class WeakHashMap$WeakBucket$WeakEntry; + class WeakHashMap$WeakEntrySet; + namespace concurrent + { + class AbstractExecutorService; + class ArrayBlockingQueue; + class ArrayBlockingQueue$Itr; + class BlockingDeque; + class BlockingQueue; + class BrokenBarrierException; + class Callable; + class CancellationException; + class CompletionService; + class ConcurrentHashMap; + class ConcurrentHashMap$EntryIterator; + class ConcurrentHashMap$EntrySet; + class ConcurrentHashMap$HashEntry; + class ConcurrentHashMap$HashIterator; + class ConcurrentHashMap$KeyIterator; + class ConcurrentHashMap$KeySet; + class ConcurrentHashMap$Segment; + class ConcurrentHashMap$ValueIterator; + class ConcurrentHashMap$Values; + class ConcurrentHashMap$WriteThroughEntry; + class ConcurrentLinkedQueue; + class ConcurrentLinkedQueue$Itr; + class ConcurrentLinkedQueue$Node; + class ConcurrentMap; + class ConcurrentNavigableMap; + class ConcurrentSkipListMap; + class ConcurrentSkipListMap$ComparableUsingComparator; + class ConcurrentSkipListMap$EntryIterator; + class ConcurrentSkipListMap$EntrySet; + class ConcurrentSkipListMap$HeadIndex; + class ConcurrentSkipListMap$Index; + class ConcurrentSkipListMap$Iter; + class ConcurrentSkipListMap$KeyIterator; + class ConcurrentSkipListMap$KeySet; + class ConcurrentSkipListMap$Node; + class ConcurrentSkipListMap$SubMap; + class ConcurrentSkipListMap$SubMap$SubMapEntryIterator; + class ConcurrentSkipListMap$SubMap$SubMapIter; + class ConcurrentSkipListMap$SubMap$SubMapKeyIterator; + class ConcurrentSkipListMap$SubMap$SubMapValueIterator; + class ConcurrentSkipListMap$ValueIterator; + class ConcurrentSkipListMap$Values; + class ConcurrentSkipListSet; + class CopyOnWriteArrayList; + class CopyOnWriteArrayList$1; + class CopyOnWriteArrayList$2; + class CopyOnWriteArrayList$3; + class CopyOnWriteArrayList$RandomAccessSubList; + class CopyOnWriteArrayList$SubList; + class CopyOnWriteArraySet; + class CountDownLatch; + class CountDownLatch$Sync; + class CyclicBarrier; + class CyclicBarrier$Generation; + class DelayQueue; + class DelayQueue$Itr; + class Delayed; + class Exchanger; + class Exchanger$Node; + class Exchanger$Slot; + class ExecutionException; + class Executor; + class ExecutorCompletionService; + class ExecutorCompletionService$QueueingFuture; + class ExecutorService; + class Executors; + class Executors$1; + class Executors$2; + class Executors$3; + class Executors$4; + class Executors$5; + class Executors$6; + class Executors$DefaultThreadFactory; + class Executors$DelegatedExecutorService; + class Executors$DelegatedScheduledExecutorService; + class Executors$FinalizableDelegatedExecutorService; + class Executors$PrivilegedCallable; + class Executors$PrivilegedCallableUsingCurrentClassLoader; + class Executors$PrivilegedThreadFactory; + class Executors$RunnableAdapter; + class Future; + class FutureTask; + class FutureTask$Sync; + class LinkedBlockingDeque; + class LinkedBlockingDeque$AbstractItr; + class LinkedBlockingDeque$DescendingItr; + class LinkedBlockingDeque$Itr; + class LinkedBlockingDeque$Node; + class LinkedBlockingQueue; + class LinkedBlockingQueue$Itr; + class LinkedBlockingQueue$Node; + class PriorityBlockingQueue; + class PriorityBlockingQueue$Itr; + class RejectedExecutionException; + class RejectedExecutionHandler; + class RunnableFuture; + class RunnableScheduledFuture; + class ScheduledExecutorService; + class ScheduledFuture; + class ScheduledThreadPoolExecutor; + class ScheduledThreadPoolExecutor$1; + class ScheduledThreadPoolExecutor$DelayedWorkQueue; + class ScheduledThreadPoolExecutor$ScheduledFutureTask; + class Semaphore; + class Semaphore$FairSync; + class Semaphore$NonfairSync; + class Semaphore$Sync; + class SynchronousQueue; + class SynchronousQueue$EmptyIterator; + class SynchronousQueue$FifoWaitQueue; + class SynchronousQueue$LifoWaitQueue; + class SynchronousQueue$TransferQueue; + class SynchronousQueue$TransferQueue$QNode; + class SynchronousQueue$TransferStack; + class SynchronousQueue$TransferStack$SNode; + class SynchronousQueue$Transferer; + class SynchronousQueue$WaitQueue; + class ThreadFactory; + class ThreadPoolExecutor; + class ThreadPoolExecutor$AbortPolicy; + class ThreadPoolExecutor$CallerRunsPolicy; + class ThreadPoolExecutor$DiscardOldestPolicy; + class ThreadPoolExecutor$DiscardPolicy; + class ThreadPoolExecutor$Worker; + class TimeUnit; + class TimeUnit$1; + class TimeUnit$2; + class TimeUnit$3; + class TimeUnit$4; + class TimeUnit$5; + class TimeUnit$6; + class TimeUnit$7; + class TimeoutException; + namespace atomic + { + class AtomicBoolean; + class AtomicInteger; + class AtomicIntegerArray; + class AtomicIntegerFieldUpdater; + class AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl; + class AtomicLong; + class AtomicLongArray; + class AtomicLongFieldUpdater; + class AtomicLongFieldUpdater$CASUpdater; + class AtomicLongFieldUpdater$LockedUpdater; + class AtomicMarkableReference; + class AtomicMarkableReference$ReferenceBooleanPair; + class AtomicReference; + class AtomicReferenceArray; + class AtomicReferenceFieldUpdater; + class AtomicReferenceFieldUpdater$AtomicReferenceFieldUpdaterImpl; + class AtomicStampedReference; + class AtomicStampedReference$ReferenceIntegerPair; + } + + namespace locks + { + class AbstractOwnableSynchronizer; + class AbstractQueuedLongSynchronizer; + class AbstractQueuedLongSynchronizer$ConditionObject; + class AbstractQueuedLongSynchronizer$Node; + class AbstractQueuedSynchronizer; + class AbstractQueuedSynchronizer$ConditionObject; + class AbstractQueuedSynchronizer$Node; + class Condition; + class Lock; + class LockSupport; + class ReadWriteLock; + class ReentrantLock; + class ReentrantLock$FairSync; + class ReentrantLock$NonfairSync; + class ReentrantLock$Sync; + class ReentrantReadWriteLock; + class ReentrantReadWriteLock$FairSync; + class ReentrantReadWriteLock$NonfairSync; + class ReentrantReadWriteLock$ReadLock; + class ReentrantReadWriteLock$Sync; + class ReentrantReadWriteLock$Sync$HoldCounter; + class ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter; + class ReentrantReadWriteLock$WriteLock; + } + } + + namespace jar + { + class Attributes; + class Attributes$Name; + class JarEntry; + class JarException; + class JarFile; + class JarFile$EntryInputStream; + class JarFile$JarEnumeration; + class JarInputStream; + class JarOutputStream; + class Manifest; + } + + namespace logging + { + class ConsoleHandler; + class ErrorManager; + class FileHandler; + class FileHandler$ostr; + class Filter; + class Formatter; + class Handler; + class Level; + class LogManager; + class LogManager$1; + class LogRecord; + class Logger; + class Logger$1; + class LoggingMXBean; + class LoggingPermission; + class MemoryHandler; + class SimpleFormatter; + class SocketHandler; + class StreamHandler; + class XMLFormatter; + } + + namespace prefs + { + class AbstractPreferences; + class AbstractPreferences$1; + class AbstractPreferences$2; + class BackingStoreException; + class InvalidPreferencesFormatException; + class NodeChangeEvent; + class NodeChangeListener; + class PreferenceChangeEvent; + class PreferenceChangeListener; + class Preferences; + class Preferences$1; + class PreferencesFactory; + } + + namespace regex + { + class MatchResult; + class Matcher; + class Pattern; + class PatternSyntaxException; + } + + namespace spi + { + class CurrencyNameProvider; + class LocaleNameProvider; + class LocaleServiceProvider; + class TimeZoneNameProvider; + } + + namespace zip + { + class Adler32; + class CRC32; + class CheckedInputStream; + class CheckedOutputStream; + class Checksum; + class DataFormatException; + class Deflater; + class DeflaterOutputStream; + class GZIPInputStream; + class GZIPOutputStream; + class Inflater; + class InflaterInputStream; + class ZipConstants; + class ZipEntry; + class ZipException; + class ZipFile; + class ZipFile$1; + class ZipFile$PartialInputStream; + class ZipFile$ZipEntryEnumeration; + class ZipInputStream; + class ZipOutputStream; + } + } + } + // end of output of the `classes.pl' script. +} + +typedef struct java::lang::Object* jobject; +typedef class java::lang::Class* jclass; +typedef class java::lang::Throwable* jthrowable; +typedef class java::lang::String* jstring; +struct _Jv_JNIEnv; + +typedef struct _Jv_Field *jfieldID; +typedef struct _Jv_Method *jmethodID; + +extern "C" jobject _Jv_AllocObject (jclass) __attribute__((__malloc__)); +extern "C" jobject _Jv_AllocObjectNoFinalizer (jclass) __attribute__((__malloc__)); +extern "C" jobject _Jv_AllocObjectNoInitNoFinalizer (jclass) __attribute__((__malloc__)); +#ifdef JV_HASH_SYNCHRONIZATION + extern "C" jobject _Jv_AllocPtrFreeObject (jclass) + __attribute__((__malloc__)); +#else + // Collector still needs to scan sync_info + static inline jobject _Jv_AllocPtrFreeObject (jclass klass) + { + return _Jv_AllocObject(klass); + } +#endif +extern "C" jboolean _Jv_IsInstanceOf(jobject, jclass); +extern "C" jstring _Jv_AllocString(jsize) __attribute__((__malloc__)); +extern "C" jstring _Jv_NewString (const jchar*, jsize) + __attribute__((__malloc__)); +extern jint _Jv_FormatInt (jchar* bufend, jint num); +extern "C" jchar* _Jv_GetStringChars (jstring str); +extern "C" void _Jv_MonitorEnter (jobject); +extern "C" void _Jv_MonitorExit (jobject); +extern "C" jstring _Jv_NewStringUTF (const char *bytes) + __attribute__((__malloc__)); +extern "C" jstring _Jv_NewStringLatin1(const char*, jsize) + __attribute__((__malloc__)); +extern "C" jsize _Jv_GetStringUTFLength (jstring); +extern "C" jsize _Jv_GetStringUTFRegion (jstring, jsize, jsize, char *); +extern "C" jint _Jv_hashUtf8String (const char*, int); +extern bool _Jv_is_proxy (void *pc); + +struct _Jv_VMOption +{ + // a VM initialization option + char* optionString; + // extra information associated with this option + void* extraInfo; +}; + +struct _Jv_VMInitArgs +{ + // for compatibility with JavaVMInitArgs + jint version; + + // number of VM initialization options + jint nOptions; + + // an array of VM initialization options + struct _Jv_VMOption* options; + + // true if the option parser should ignore unrecognized options + jboolean ignoreUnrecognized; +}; + +extern "C" jint _Jv_CreateJavaVM (struct _Jv_VMInitArgs*); + +void +_Jv_ThreadRun (java::lang::Thread* thread); +jint +_Jv_AttachCurrentThread(java::lang::Thread* thread); +extern "C" java::lang::Thread* +_Jv_AttachCurrentThread(jstring name, java::lang::ThreadGroup* group); +extern "C" java::lang::Thread* +_Jv_AttachCurrentThreadAsDaemon(jstring name, java::lang::ThreadGroup* group); +extern "C" jint _Jv_DetachCurrentThread (void); + +extern "C" void _Jv_Throw (jthrowable) __attribute__ ((__noreturn__)); +extern "C" void* _Jv_Malloc (jsize) __attribute__((__malloc__)); +extern "C" void* _Jv_Realloc (void *, jsize); +extern "C" void _Jv_Free (void*); +extern void (*_Jv_RegisterClassHook) (jclass cl); +extern "C" void _Jv_RegisterClassHookDefault (jclass); + +typedef unsigned short _Jv_ushort __attribute__((__mode__(__HI__))); +typedef unsigned int _Jv_uint __attribute__((__mode__(__SI__))); +typedef unsigned int _Jv_ulong __attribute__((__mode__(__DI__))); + +// The type to use when treating a pointer as an integer. Similar to +// uintptr_t in C99. +typedef unsigned int _Jv_uintptr_t __attribute__((__mode__(__pointer__))); + +class _Jv_Utf8Const +{ + _Jv_ushort hash; + _Jv_ushort length; /* In bytes, of data portion, without final '\0'. */ + char data[1]; /* In Utf8 format, with final '\0'. */ + public: + /** Return same value of java.lang.String's hashCode. */ + jint hash32() { return _Jv_hashUtf8String(data, length); } + /** Return a hash code that has at least 16 bits of information. */ + _Jv_ushort hash16 () { return hash; } + /** Return a hash code that has at least 8 bits of information. */ + _Jv_ushort hash8 () { return hash; } + /** Length in bytes of the UTF8-encoding. */ + _Jv_ushort len () const { return length; } + /** Pointer to the first byte in the NUL-terminated UTF8-encoding. */ + char* chars() { return data; } + /** Pointer to the NUL byte that terminated the UTF8-encoding. */ + char* limit() { return data+length; } + /** Return the first byte in the UTF8-encoding. */ + char first() const { return data[0]; } + /** Create a (non-interned) java.lang.String from this UTF8Const. */ + jstring toString() { return _Jv_NewStringUTF(data); } + /** Given an UTF8 string, how many bytes needed for a UTF8Const, + including struct header, and final NUL. I.e. what to pas to malloc. */ + static int space_needed (const char *, int len) + { return sizeof (_Jv_Utf8Const) + len + 1; } + /** Given an allocated _Jv_Utf8Const, copy / fill it in. */ + void init (const char *s, int len); + friend jboolean _Jv_equalUtf8Consts (const _Jv_Utf8Const*, const _Jv_Utf8Const *); + friend jboolean _Jv_equal (_Jv_Utf8Const*, jstring, jint); + friend jboolean _Jv_equaln (_Jv_Utf8Const*, jstring, jint); + friend jboolean _Jv_equalUtf8Classnames (const _Jv_Utf8Const*, + const _Jv_Utf8Const*); + friend jboolean _Jv_isPrimitiveOrDerived (const _Jv_Utf8Const*); + friend _Jv_Utf8Const *_Jv_makeUtf8Const (const char*, int); + friend _Jv_Utf8Const *_Jv_makeUtf8Const (jstring); + friend jstring _Jv_NewStringUtf8Const (_Jv_Utf8Const*); +}; + + +#endif /* __JAVAPRIMS_H__ */ diff --git a/libjava/gcj/libgcj-config.h.in b/libjava/gcj/libgcj-config.h.in new file mode 100644 index 000000000..715c3bc37 --- /dev/null +++ b/libjava/gcj/libgcj-config.h.in @@ -0,0 +1,13 @@ +/* The header file derived from this file is installed in a target and + compiler version specific directory. Do not add definitions which + are intended to be different for different multilibs, as we do not + currently have a mechanism to support this. + + Also be sure to use safely named macros, as this file will be + included in user code. */ + +/* Define if hash synchronization is in use. */ +#undef JV_HASH_SYNCHRONIZATION + +/* Define if is available. */ +#undef JV_HAVE_INTTYPES_H diff --git a/libjava/gcj/method.h b/libjava/gcj/method.h new file mode 100644 index 000000000..f97f865f9 --- /dev/null +++ b/libjava/gcj/method.h @@ -0,0 +1,44 @@ +// method.h - Header file for methodID instances. -*- c++ -*- + +/* Copyright (C) 1999, 2000 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __GCJ_METHOD_H__ +#define __GCJ_METHOD_H__ + +#include +#include +#include + +extern inline jmethodID +_Jv_FromReflectedMethod (java::lang::reflect::Method *method) +{ + return (jmethodID) + ((char *) method->declaringClass->methods + method->offset); +} + +extern inline jmethodID +_Jv_FromReflectedConstructor (java::lang::reflect::Constructor *constructor) +{ + return (jmethodID) + ((char *) constructor->declaringClass->methods + constructor->offset); +} + +extern inline jint +JvNumMethods (jclass klass) +{ + return klass->method_count; +} + +extern inline jmethodID +JvGetFirstMethod (jclass klass) +{ + return &klass->methods[0]; +} + +#endif /* __GCJ_METHOD_H__ */ -- cgit v1.2.3