From: Gregor Kaufmann Date: Mon, 22 Oct 2007 19:44:46 +0000 (+0200) Subject: * configure.ac (AC_CHECK_ENABLE_ASSERTION): Added X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=commitdiff_plain;ds=sidebyside;h=6d4b5cf05e122660304fb4f10e185290c645794c;p=cacao.git * configure.ac (AC_CHECK_ENABLE_ASSERTION): Added * src/lib/gnu/java/lang/VMClassLoader.java (packageAssertionStatus0): New function (classAssertionStatus0): Likewise (defaultUserAssertionStatus): Likewise (defaultAssertionStatus): Implemented (packageAssertionStatus): Likewise (classAssertionStatus): Likewise * src/native/include/Makefile.am (COMMON_HEADER_FILES): Added java_util_HashMap.h, java_util_Map.h * /src/native/jni.h (_Jv_JavaVM->Java_java_lang_VMClassLoader_defaultAssertionStatus): Removed * src/native/vm/gnu/java_lang_VMClassLoader.c (native/include/java_util_HashMap.h): Added (native/include/java_util_Map.h): Likewise (native/include/java_lang_Boolean.h): Likewise (toolbox/list.h): Likewise (vm/assertion.h): Likewise (methods): Added information for defaultUserAssertionStatus, packageAssertionStatus0, classAssertionStatus0 (Java_java_lang_VMClassLoader_defaultAssertionStatus): Implemented (Java_java_lang_VMClassLoader_defaultUserAssertionStatus): New function (Java_java_lang_VMClassLoader_packageAssertionStatus0): Likewise (Java_java_lang_VMClassLoader_classAssertionStatus0): Likewise * src/native/vm/sun/jvm.c (toolbox/list.h): Added (vm/assertion.h): Likewise (JVM_DesiredAssertionStatus): Implemented (JVM_AssertionStatusDirectives): Now returns a usable java.lang.AssertionStatusDirectives object * src/vm/Makefile.am (libvm_la_SOURCES): Added assertion.c, assertion.h * src/vm/vm.c (vm/assertion.h): Added (OPT_EA, OPT_DA, OPT_ESA, OPT_DSA): Now handled by assertion module * src/vmcore/class.c (class_java_util_HashMap): Added * src/vmcore/class.h (class_java_util_HashMap): Added * src/vmcore/linker.c (linker_init): Added linking of class_java_util_HashMap * src/vmcore/loader.c (loader_init): Added loading of class_java_util_HashMap * m4/assertion.m4: New file * src/vm/assertion.c: New file * src/vm/assertion.h: New file --- diff --git a/configure.ac b/configure.ac index e5ae39a2d..e3d14074a 100644 --- a/configure.ac +++ b/configure.ac @@ -747,6 +747,7 @@ AC_PROG_LIBTOOL AC_CHECK_ENABLE_STATICVM AC_CHECK_ENABLE_ANNOTATIONS +AC_CHECK_ENABLE_ASSERTION dnl where is CACAO's vm.zip diff --git a/m4/assertion.m4 b/m4/assertion.m4 new file mode 100644 index 000000000..e83ea1925 --- /dev/null +++ b/m4/assertion.m4 @@ -0,0 +1,45 @@ +dnl m4/assertion.m4 +dnl +dnl Copyright (C) 2007 +dnl CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO +dnl +dnl This file is part of CACAO. +dnl +dnl This program is free software; you can redistribute it and/or +dnl modify it under the terms of the GNU General Public License as +dnl published by the Free Software Foundation; either version 2, or (at +dnl your option) any later version. +dnl +dnl This program is distributed in the hope that it will be useful, but +dnl WITHOUT ANY WARRANTY; without even the implied warranty of +dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +dnl General Public License for more details. +dnl +dnl You should have received a copy of the GNU General Public License +dnl along with this program; if not, write to the Free Software +dnl Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +dnl 02110-1301, USA. + + +dnl check if java assertion support should be enabled + +AC_DEFUN([AC_CHECK_ENABLE_ASSERTION],[ +AC_MSG_CHECKING(wether to enable java assertion support) +AC_ARG_ENABLE([assertion], + [AS_HELP_STRING(--enable-assertion,enable java assertion support [[default=yes]])], + [case "${enableval}" in + yes) + ENABLE_ASSERTION=yes + ;; + *) + ENABLE_ASSERTION=no + ;; + esac], + [ENABLE_ASSERTION=yes]) +AC_MSG_RESULT(${ENABLE_ASSERTION}) +AM_CONDITIONAL([ENABLE_ASSERTION], test x"${ENABLE_ASSERTION}" = "xyes") + +if test x"${ENABLE_ASSERTION}" = "xyes"; then + AC_DEFINE([ENABLE_ASSERTION], 1, [enable assertion]) +fi +]) diff --git a/src/lib/gnu/java/lang/VMClassLoader.java b/src/lib/gnu/java/lang/VMClassLoader.java index 46e741e06..f09838bd0 100644 --- a/src/lib/gnu/java/lang/VMClassLoader.java +++ b/src/lib/gnu/java/lang/VMClassLoader.java @@ -59,6 +59,8 @@ import java.util.Set; import java.util.StringTokenizer; import java.util.Vector; import java.util.zip.ZipFile; +import java.util.Collections; +import java.lang.Boolean; /** * java.lang.VMClassLoader is a package-private helper for VMs to implement @@ -360,45 +362,46 @@ final class VMClassLoader * classes (those with a null ClassLoader), as well as the initial value for * every ClassLoader's default assertion status. * - * XXX - Not implemented yet; this requires native help. - * * @return the system-wide default assertion status */ -// static final boolean defaultAssertionStatus() -// { -// return true; -// } static native final boolean defaultAssertionStatus(); + static native final boolean defaultUserAssertionStatus(); + + + static final Map packageAssertionMap = + Collections.unmodifiableMap(packageAssertionStatus0(Boolean.TRUE, Boolean.FALSE)); + + static native final Map packageAssertionStatus0(Boolean jtrue, Boolean jfalse); /** * The system default for package assertion status. This is used for all * ClassLoader's packageAssertionStatus defaults. It must be a map of * package names to Boolean.TRUE or Boolean.FALSE, with the unnamed package * represented as a null key. * - * XXX - Not implemented yet; this requires native help. - * * @return a (read-only) map for the default packageAssertionStatus */ - static final Map packageAssertionStatus() - { - return new HashMap(); + + static final Map packageAssertionStatus() { + return packageAssertionMap; } + static final Map classAssertionMap = + Collections.unmodifiableMap(classAssertionStatus0(Boolean.TRUE, Boolean.FALSE)); + + static native final Map classAssertionStatus0(Boolean jtrue, Boolean jfalse); + /** * The system default for class assertion status. This is used for all * ClassLoader's classAssertionStatus defaults. It must be a map of * class names to Boolean.TRUE or Boolean.FALSE * - * XXX - Not implemented yet; this requires native help. - * * @return a (read-only) map for the default classAssertionStatus */ - static final Map classAssertionStatus() - { - return new HashMap(); + static final Map classAssertionStatus() { + return classAssertionMap; } - + static ClassLoader getSystemClassLoader() { return ClassLoader.defaultGetSystemClassLoader(); diff --git a/src/native/include/Makefile.am b/src/native/include/Makefile.am index 83462b109..5ca4387aa 100644 --- a/src/native/include/Makefile.am +++ b/src/native/include/Makefile.am @@ -41,7 +41,9 @@ COMMON_HEADER_FILES = \ java_lang_Integer.h \ java_lang_Long.h \ java_lang_Short.h \ - java_util_Vector.h + java_util_Vector.h \ + java_util_HashMap.h \ + java_util_Map.h JAVASE_HEADER_FILES = \ java_lang_ClassLoader.h \ diff --git a/src/native/jni.h b/src/native/jni.h index e8ce97efe..05a013659 100644 --- a/src/native/jni.h +++ b/src/native/jni.h @@ -83,7 +83,6 @@ struct _Jv_JavaVM { s4 java_lang_management_ThreadMXBean_PeakThreadCount; s4 java_lang_management_ThreadMXBean_ThreadCount; s8 java_lang_management_ThreadMXBean_TotalStartedThreadCount; - s4 Java_java_lang_VMClassLoader_defaultAssertionStatus; }; diff --git a/src/native/vm/gnu/java_lang_VMClassLoader.c b/src/native/vm/gnu/java_lang_VMClassLoader.c index d1ea2546c..e9a8b9977 100644 --- a/src/native/vm/gnu/java_lang_VMClassLoader.c +++ b/src/native/vm/gnu/java_lang_VMClassLoader.c @@ -42,12 +42,20 @@ #include "native/include/java_security_ProtectionDomain.h" /* required by... */ #include "native/include/java_lang_ClassLoader.h" #include "native/include/java_util_Vector.h" +#include "native/include/java_util_HashMap.h" +#include "native/include/java_util_Map.h" +#include "native/include/java_lang_Boolean.h" #include "native/include/java_lang_VMClassLoader.h" #include "native/vm/java_lang_ClassLoader.h" #include "toolbox/logging.h" +#include "toolbox/list.h" + +#if defined(ENABLE_ASSERTION) +#include "vm/assertion.h" +#endif #include "vm/builtin.h" #include "vm/exceptions.h" @@ -71,17 +79,19 @@ #include "native/jvmti/cacaodbg.h" #endif - /* native methods implemented by this file ************************************/ static JNINativeMethod methods[] = { - { "defineClass", "(Ljava/lang/ClassLoader;Ljava/lang/String;[BIILjava/security/ProtectionDomain;)Ljava/lang/Class;", (void *) (ptrint) &Java_java_lang_VMClassLoader_defineClass }, - { "getPrimitiveClass", "(C)Ljava/lang/Class;", (void *) (ptrint) &Java_java_lang_VMClassLoader_getPrimitiveClass }, - { "resolveClass", "(Ljava/lang/Class;)V", (void *) (ptrint) &Java_java_lang_VMClassLoader_resolveClass }, - { "loadClass", "(Ljava/lang/String;Z)Ljava/lang/Class;", (void *) (ptrint) &Java_java_lang_VMClassLoader_loadClass }, - { "nativeGetResources", "(Ljava/lang/String;)Ljava/util/Vector;", (void *) (ptrint) &Java_java_lang_VMClassLoader_nativeGetResources }, - { "defaultAssertionStatus", "()Z", (void *) (ptrint) &Java_java_lang_VMClassLoader_defaultAssertionStatus }, - { "findLoadedClass", "(Ljava/lang/ClassLoader;Ljava/lang/String;)Ljava/lang/Class;", (void *) (ptrint) &Java_java_lang_VMClassLoader_findLoadedClass }, + { "defineClass", "(Ljava/lang/ClassLoader;Ljava/lang/String;[BIILjava/security/ProtectionDomain;)Ljava/lang/Class;", (void *) (ptrint) &Java_java_lang_VMClassLoader_defineClass }, + { "getPrimitiveClass", "(C)Ljava/lang/Class;", (void *) (ptrint) &Java_java_lang_VMClassLoader_getPrimitiveClass }, + { "resolveClass", "(Ljava/lang/Class;)V", (void *) (ptrint) &Java_java_lang_VMClassLoader_resolveClass }, + { "loadClass", "(Ljava/lang/String;Z)Ljava/lang/Class;", (void *) (ptrint) &Java_java_lang_VMClassLoader_loadClass }, + { "nativeGetResources", "(Ljava/lang/String;)Ljava/util/Vector;", (void *) (ptrint) &Java_java_lang_VMClassLoader_nativeGetResources }, + { "defaultAssertionStatus", "()Z", (void *) (ptrint) &Java_java_lang_VMClassLoader_defaultAssertionStatus }, + { "defaultUserAssertionStatus", "()Z", (void *) (ptrint) &Java_java_lang_VMClassLoader_defaultUserAssertionStatus }, + { "packageAssertionStatus0", "(Ljava/lang/Boolean;Ljava/lang/Boolean;)Ljava/util/Map;", (void *) (ptrint) &Java_java_lang_VMClassLoader_packageAssertionStatus0 }, + { "classAssertionStatus0", "(Ljava/lang/Boolean;Ljava/lang/Boolean;)Ljava/util/Map;", (void *) (ptrint) &Java_java_lang_VMClassLoader_classAssertionStatus0 }, + { "findLoadedClass", "(Ljava/lang/ClassLoader;Ljava/lang/String;)Ljava/lang/Class;", (void *) (ptrint) &Java_java_lang_VMClassLoader_findLoadedClass }, }; @@ -344,7 +354,165 @@ return_NULL: */ JNIEXPORT s4 JNICALL Java_java_lang_VMClassLoader_defaultAssertionStatus(JNIEnv *env, jclass clazz) { - return _Jv_jvm->Java_java_lang_VMClassLoader_defaultAssertionStatus; +#if defined(ENABLE_ASSERTION) + return assertion_system_enabled; +#else + return false; +#endif +} + +/* + * Class: java/lang/VMClassLoader + * Method: userAssertionStatus + * Signature: ()Z + */ +JNIEXPORT s4 JNICALL Java_java_lang_VMClassLoader_defaultUserAssertionStatus(JNIEnv *env, jclass clazz) +{ +#if defined(ENABLE_ASSERTION) + return assertion_user_enabled; +#else + return false; +#endif +} + +/* + * Class: java/lang/VMClassLoader + * Method: packageAssertionStatus + * Signature: ()Ljava_util_Map; + */ +JNIEXPORT java_util_Map* JNICALL Java_java_lang_VMClassLoader_packageAssertionStatus0(JNIEnv *env, jclass clazz, java_lang_Boolean *jtrue, java_lang_Boolean *jfalse) +{ + java_handle_t *hm; +#if defined(ENABLE_ASSERTION) + java_handle_t *js; + methodinfo *m; + assertion_name_t *item; +#endif + + /* new HashMap() */ + + hm = native_new_and_init(class_java_util_HashMap); + if (hm == NULL) { + return NULL; + } + +#if defined(ENABLE_ASSERTION) + /* if nothing todo, return now */ + + if (assertion_package_count == 0) { + return (java_util_Map *) hm; + } + + /* get HashMap.put method */ + + m = class_resolveclassmethod(class_java_util_HashMap, + utf_put, + utf_new_char("(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"), + NULL, + true); + + if (m == NULL) { + return NULL; + } + + item = (assertion_name_t *)list_first(list_assertion_names); + + while (item != NULL) { + if (item->package == false) { + item = (assertion_name_t *)list_next(list_assertion_names, item); + continue; + } + + if (strcmp(item->name, "") == 0) { + /* unnamed package wanted */ + js = NULL; + } + else { + js = javastring_new_from_ascii(item->name); + if (js == NULL) { + return NULL; + } + } + + if (item->enabled == true) { + vm_call_method(m, hm, js, jtrue); + } + else { + vm_call_method(m, hm, js, jfalse); + } + + item = (assertion_name_t *)list_next(list_assertion_names, item); + } +#endif + + return (java_util_Map *) hm; +} + +/* + * Class: java/lang/VMClassLoader + * Method: classAssertionStatus + * Signature: ()Ljava_util_Map; + */ +JNIEXPORT java_util_Map* JNICALL Java_java_lang_VMClassLoader_classAssertionStatus0(JNIEnv *env, jclass clazz, java_lang_Boolean *jtrue, java_lang_Boolean *jfalse) +{ + java_handle_t *hm; +#if defined(ENABLE_ASSERTION) + java_handle_t *js; + methodinfo *m; + assertion_name_t *item; +#endif + + /* new HashMap() */ + + hm = native_new_and_init(class_java_util_HashMap); + if (hm == NULL) { + return NULL; + } + +#if defined(ENABLE_ASSERTION) + /* if nothing todo, return now */ + + if (assertion_class_count == 0) { + return (java_util_Map *) hm; + } + + /* get HashMap.put method */ + + m = class_resolveclassmethod(class_java_util_HashMap, + utf_put, + utf_new_char("(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"), + NULL, + true); + + if (m == NULL) { + return NULL; + } + + item = (assertion_name_t *)list_first(list_assertion_names); + + while (item != NULL) { + if (item->package == true) { + item = (assertion_name_t *)list_next(list_assertion_names, item); + continue; + } + + js = javastring_new_from_ascii(item->name); + if (js == NULL) { + return NULL; + } + + if (item->enabled == true) { + vm_call_method(m, hm, js, jtrue); + } + else { + vm_call_method(m, hm, js, jfalse); + } + + item = (assertion_name_t *)list_next(list_assertion_names, item); + } +#endif + + return (java_util_Map *) hm; } diff --git a/src/native/vm/sun/jvm.c b/src/native/vm/sun/jvm.c index d2d9d3352..a8fa90f5e 100644 --- a/src/native/vm/sun/jvm.c +++ b/src/native/vm/sun/jvm.c @@ -87,8 +87,14 @@ #include "threads/threads-common.h" #include "toolbox/logging.h" +#include "toolbox/list.h" #include "vm/array.h" + +#if defined(ENABLE_ASSERTION) +#include "vm/assertion.h" +#endif + #include "vm/builtin.h" #include "vm/exceptions.h" #include "vm/global.h" @@ -1643,11 +1649,42 @@ jstring JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, j jboolean JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls) { +#if defined(ENABLE_ASSERTION) + assertion_name_t *item; + classinfo *c; + jboolean status; + utf *name; + TRACEJVMCALLS("JVM_DesiredAssertionStatus(env=%p, unused=%p, cls=%p)", env, unused, cls); - /* TODO: Implement this one, but false should be OK. */ + c = LLNI_classinfo_unwrap(cls); - return false; + if (c->classloader == NULL) { + status = (jboolean)assertion_system_enabled; + } + else { + status = (jboolean)assertion_user_enabled; + } + + if (list_assertion_names != NULL) { + item = (assertion_name_t *)list_first(list_assertion_names); + while (item != NULL) { + name = utf_new_char(item->name); + if (name == c->packagename) { + status = (jboolean)item->enabled; + } + else if (name == c->name) { + status = (jboolean)item->enabled; + } + + item = (assertion_name_t *)list_next(list_assertion_names, item); + } + } + + return status; +#else + return (jboolean)false; +#endif } @@ -1655,14 +1692,19 @@ jboolean JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls) jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused) { - classinfo *c; - java_lang_AssertionStatusDirectives *o; - java_handle_objectarray_t *classes; - java_handle_objectarray_t *packages; - - TRACEJVMCALLS("JVM_AssertionStatusDirectives(env=%p, unused=%p): COMPLETE ME!", env, unused); + classinfo *c; + java_lang_AssertionStatusDirectives *o; + java_handle_objectarray_t *classes; + java_handle_objectarray_t *packages; + java_booleanarray_t *classEnabled; + java_booleanarray_t *packageEnabled; +#if defined(ENABLE_ASSERTION) + assertion_name_t *item; + java_handle_t *js; + s4 i, j; +#endif - /* XXX this is not completely implemented */ + TRACEJVMCALLS("JVM_AssertionStatusDirectives(env=%p, unused=%p)", env, unused); c = load_class_bootstrap(utf_new_char("java/lang/AssertionStatusDirectives")); @@ -1674,20 +1716,74 @@ jobject JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused) if (o == NULL) return NULL; +#if defined(ENABLE_ASSERTION) + classes = builtin_anewarray(assertion_class_count, class_java_lang_Object); +#else classes = builtin_anewarray(0, class_java_lang_Object); - +#endif if (classes == NULL) return NULL; +#if defined(ENABLE_ASSERTION) + packages = builtin_anewarray(assertion_package_count, class_java_lang_Object); +#else packages = builtin_anewarray(0, class_java_lang_Object); - +#endif if (packages == NULL) return NULL; + +#if defined(ENABLE_ASSERTION) + classEnabled = builtin_newarray_boolean(assertion_class_count); +#else + classEnabled = builtin_newarray_boolean(0); +#endif + if (classEnabled == NULL) + return NULL; + +#if defined(ENABLE_ASSERTION) + packageEnabled = builtin_newarray_boolean(assertion_package_count); +#else + packageEnabled = builtin_newarray_boolean(0); +#endif + if (packageEnabled == NULL) + return NULL; + +#if defined(ENABLE_ASSERTION) + /* initialize arrays */ + + if (list_assertion_names != NULL) { + i = 0; + j = 0; + + item = (assertion_name_t *)list_first(list_assertion_names); + while (item != NULL) { + js = javastring_new_from_ascii(item->name); + if (js == NULL) { + return NULL; + } + + if (item->package == false) { + classes->data[i] = js; + classEnabled->data[i] = (jboolean) item->enabled; + i += 1; + } + else { + packages->data[j] = js; + packageEnabled->data[j] = (jboolean) item->enabled; + j += 1; + } + + item = (assertion_name_t *)list_next(list_assertion_names, item); + } + } +#endif /* set instance fields */ o->classes = classes; o->packages = packages; + o->classEnabled = classEnabled; + o->packageEnabled = packageEnabled; return (jobject) o; } diff --git a/src/vm/Makefile.am b/src/vm/Makefile.am index bdc79e4f8..fb3c8ba88 100644 --- a/src/vm/Makefile.am +++ b/src/vm/Makefile.am @@ -30,6 +30,12 @@ LIBS = SUBDIRS = jit +if ENABLE_ASSERTION +ASSERTION_SOURCES = \ + assertion.c \ + assertion.h +endif + if ENABLE_CYCLES_STATS CYCLES_STATS_SOURCES = \ cycles-stats.c \ @@ -44,6 +50,7 @@ noinst_LTLIBRARIES = \ libvm.la libvm_la_SOURCES = \ + $(ASSERTION_SOURCES) \ access.c \ access.h \ array.c \ diff --git a/src/vm/assertion.c b/src/vm/assertion.c new file mode 100644 index 000000000..0140b0ac9 --- /dev/null +++ b/src/vm/assertion.c @@ -0,0 +1,130 @@ +/* src/vm/assertion.c - assertion options + + Copyright (C) 2007 + CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO + + This file is part of CACAO. + + 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., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. + +*/ + +#include "config.h" +#include +#include + +#if defined(HAVE_STRING_H) +# include +#endif + +#include "mm/memory.h" + +#include "vm/global.h" +#include "vm/vm.h" + +#include "toolbox/list.h" + +#include "vm/assertion.h" + +/* -ea/-da options ************************************************************/ + +list_t *list_assertion_names = (list_t *)NULL; +int32_t assertion_class_count = 0; +int32_t assertion_package_count = 0; +bool assertion_user_enabled = false; +bool assertion_system_enabled = false; + +/* assertion_ea_da ************************************************************* + + Handle -ea:/-enableassertions: and -da:/-disableassertions: options. + +*******************************************************************************/ + +void assertion_ea_da(const char *name, bool enabled) { + bool package; + size_t len; + char *buf; + assertion_name_t *item; + int32_t i; + + if (name == NULL) { + assertion_user_enabled = enabled; + return; + } + + package = false; + len = strlen(name); + + if (name[len - 1] == '/') { + return; + } + + buf = strdup(name); + if (buf == NULL) { + vm_abort("assertion_ea_da: strdup failed: %s", strerror(errno)); + } + + if ((len > 2) && (strcmp(name + (len - 3), "...") == 0)) { + package = true; + assertion_package_count += 1; +#if defined(WITH_CLASSPATH_SUN) + buf[len - 2] = '\0'; + buf[len - 3] = '/'; +#else + buf[len - 3] = '\0'; +#endif + } + else { + assertion_class_count += 1; + } + + len = strlen(buf); + for (i = 0; i < len; i++) { +#if defined(WITH_CLASSPATH_SUN) + if (buf[i] == '.') { + buf[i] = '/'; + } +#else + if (buf[i] == '/') { + buf[i] = '.'; + } +#endif + } + + item = NEW(assertion_name_t); + item->name = buf; + item->enabled = enabled; + item->package = package; + + if (list_assertion_names == NULL) { + list_assertion_names = list_create(OFFSET(assertion_name_t, linkage)); + } + list_add_last(list_assertion_names, item); +} + +/* + * These are local overrides for various environment variables in Emacs. + * Please do not remove this and leave it at the end of the file, where + * Emacs will automagically detect them. + * --------------------------------------------------------------------- + * Local variables: + * mode: c + * indent-tabs-mode: t + * c-basic-offset: 4 + * tab-width: 4 + * End: + * vim:noexpandtab:sw=4:ts=4: + */ diff --git a/src/vm/assertion.h b/src/vm/assertion.h new file mode 100644 index 000000000..a2c4484bb --- /dev/null +++ b/src/vm/assertion.h @@ -0,0 +1,71 @@ +/* src/vm/assertion.h - assertion options + + Copyright (C) 2007 + CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO + + This file is part of CACAO. + + 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., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. + +*/ + + +#ifndef _ASSERTION_H +#define _ASSERTION_H + +#include "config.h" +#include "vm/global.h" +#include "toolbox/list.h" + +#include + +typedef struct assertion_name_t assertion_name_t; + +struct assertion_name_t { + char *name; + bool enabled; + bool package; + listnode_t linkage; +}; + +/* -ea/-esa/-da/-dsa options **************************************************/ + +extern list_t *list_assertion_names; +extern int32_t assertion_class_count; +extern int32_t assertion_package_count; +extern bool assertion_user_enabled; +extern bool assertion_system_enabled; + +/* function prototypes ********************************************************/ + +void assertion_ea_da(const char *name, bool enabled); + +#endif /* _ASSERTION_H */ + + +/* + * These are local overrides for various environment variables in Emacs. + * Please do not remove this and leave it at the end of the file, where + * Emacs will automagically detect them. + * --------------------------------------------------------------------- + * Local variables: + * mode: c + * indent-tabs-mode: t + * c-basic-offset: 4 + * tab-width: 4 + * End: + * vim:noexpandtab:sw=4:ts=4: + */ diff --git a/src/vm/vm.c b/src/vm/vm.c index 2a9b9cbc8..32215d9b9 100644 --- a/src/vm/vm.c +++ b/src/vm/vm.c @@ -64,6 +64,11 @@ #include "toolbox/logging.h" #include "vm/array.h" + +#if defined(ENABLE_ASSERTION) +#include "vm/assertion.h" +#endif + #include "vm/builtin.h" #include "vm/exceptions.h" #include "vm/finalizer.h" @@ -1260,19 +1265,27 @@ bool vm_create(JavaVMInitArgs *vm_args) break; case OPT_EA: - /* currently ignored */ +#if defined(ENABLE_ASSERTION) + assertion_ea_da(opt_arg, true); +#endif break; case OPT_DA: - /* currently ignored */ +#if defined(ENABLE_ASSERTION) + assertion_ea_da(opt_arg, false); +#endif break; case OPT_ESA: - _Jv_jvm->Java_java_lang_VMClassLoader_defaultAssertionStatus = true; +#if defined(ENABLE_ASSERTION) + assertion_system_enabled = true; +#endif break; case OPT_DSA: - _Jv_jvm->Java_java_lang_VMClassLoader_defaultAssertionStatus = false; +#if defined(ENABLE_ASSERTION) + assertion_system_enabled = false; +#endif break; #if defined(ENABLE_PROFILING) diff --git a/src/vmcore/class.c b/src/vmcore/class.c index 1af511f85..1e5d2f304 100644 --- a/src/vmcore/class.c +++ b/src/vmcore/class.c @@ -115,6 +115,7 @@ classinfo *class_java_lang_reflect_Field; classinfo *class_java_lang_reflect_Method; classinfo *class_java_security_PrivilegedAction; classinfo *class_java_util_Vector; +classinfo *class_java_util_HashMap; classinfo *arrayclass_java_lang_Object; diff --git a/src/vmcore/class.h b/src/vmcore/class.h index 0db5617d8..6d4ab0627 100644 --- a/src/vmcore/class.h +++ b/src/vmcore/class.h @@ -251,6 +251,7 @@ extern classinfo *class_java_lang_reflect_Field; extern classinfo *class_java_lang_reflect_Method; extern classinfo *class_java_security_PrivilegedAction; extern classinfo *class_java_util_Vector; +extern classinfo *class_java_util_HashMap; extern classinfo *arrayclass_java_lang_Object; diff --git a/src/vmcore/linker.c b/src/vmcore/linker.c index 2eed5d4f7..ad3d160c9 100644 --- a/src/vmcore/linker.c +++ b/src/vmcore/linker.c @@ -291,6 +291,9 @@ void linker_init(void) if (!link_class(class_java_util_Vector)) vm_abort("linker_init: linking failed"); + if (!link_class(class_java_util_HashMap)) + vm_abort("linker_init: linking failed"); + # if defined(WITH_CLASSPATH_SUN) if (!link_class(class_sun_reflect_MagicAccessorImpl)) vm_abort("linker_init: linking failed"); diff --git a/src/vmcore/loader.c b/src/vmcore/loader.c index e9faacc5e..24d2d8fb8 100644 --- a/src/vmcore/loader.c +++ b/src/vmcore/loader.c @@ -211,6 +211,9 @@ void loader_init(void) class_java_security_PrivilegedAction = load_class_bootstrap(utf_new_char("java/security/PrivilegedAction")); + class_java_util_HashMap = + load_class_bootstrap(utf_new_char("java/util/HashMap")); + class_java_util_Vector = load_class_bootstrap(utf_java_util_Vector); # if defined(WITH_CLASSPATH_SUN)