PR156: Preparation

[cacao.git] / src / vm / javaobjects.cpp

diff --git a/src/vm/javaobjects.cpp b/src/vm/javaobjects.cpp
index cc82bdc6e9a79f7659f784438b60bc216f64b8e1..4f63d89a5117b0828c9e7599acf699a83458eb50 100644 (file)
--- a/src/vm/javaobjects.cpp
+++ b/src/vm/javaobjects.cpp
@@ -1,6 +1,8 @@
 /* src/vm/javaobjects.cpp - functions to create and access Java objects
 
-   Copyright (C) 2008 Theobroma Systems Ltd.
+   Copyright (C) 2010, 2011
+   CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
+   Copyright (C) 2008, 2009 Theobroma Systems Ltd.
 
    This file is part of CACAO.
 
@@ -28,16 +30,85 @@
 
 #include "native/vm/reflection.hpp"
 
-#include "vm/access.h"
+#include "vm/access.hpp"
 #include "vm/jit/builtin.hpp"
 #include "vm/global.h"
 #include "vm/globals.hpp"
-#include "vm/initialize.h"
+#include "vm/initialize.hpp"
 #include "vm/javaobjects.hpp"
 
+#include <map>
 
 #if defined(ENABLE_JAVASE)
 
+/**
+ * Invokes the static Java method getSystemClassLoader().
+ *
+ * @return Return value of the invocation or NULL in
+ * case of an exception.
+ */
+java_handle_t* java_lang_ClassLoader::invoke_getSystemClassLoader()
+{
+       methodinfo    *m;
+       java_handle_t *clo;
+       classloader_t *cl;
+
+       assert(class_java_lang_Object);
+       assert(class_java_lang_ClassLoader);
+       assert(class_java_lang_ClassLoader->state & CLASS_LINKED);
+
+       m = class_resolveclassmethod(class_java_lang_ClassLoader,
+                                                                utf_getSystemClassLoader,
+                                                                utf_void__java_lang_ClassLoader,
+                                                                class_java_lang_Object,
+                                                                false);
+
+       if (m == NULL)
+               return NULL;
+
+       clo = vm_call_method(m, NULL);
+
+       if (clo == NULL)
+               return NULL;
+
+       cl = loader_hashtable_classloader_add(clo);
+
+       return cl;
+}
+
+
+/**
+ * Constructs a new instance of the class by calling the
+ * appropriate Java initializer.
+ */
+java_lang_management_MemoryUsage::java_lang_management_MemoryUsage(int64_t init, int64_t used, int64_t commited, int64_t maximum)
+{
+       // Load the class.
+       // XXX Maybe this should be made global at some points.
+       classinfo* class_java_lang_management_MemoryUsage;
+       if (!(class_java_lang_management_MemoryUsage = load_class_bootstrap(utf_new_char("java/lang/management/MemoryUsage"))))
+               return;
+
+       // Find the appropriate initializer.
+       // XXX Maybe this should be made global at some points.
+       methodinfo* m = class_findmethod(class_java_lang_management_MemoryUsage,
+                                                                        utf_init,
+                                                                        utf_new_char("(JJJJ)V"));
+
+       if (m == NULL)
+               return;
+
+       // Instantiate a new object.
+       _handle = builtin_new(class_java_lang_management_MemoryUsage);
+
+       if (is_null())
+               return;
+
+       // Call initializer.
+       (void) vm_call_method(m, _handle, init, used, commited, maximum);
+}
+
+
 /**
  * Constructs a Java object with the given
  * java.lang.reflect.Constructor.
@@ -67,7 +138,7 @@ java_handle_t* java_lang_reflect_Constructor::new_instance(java_handle_objectarr
 
        if (h == NULL)
                return NULL;
-        
+
        // Call initializer.
        (void) Reflection::invoke(m, h, args);
 
@@ -120,13 +191,45 @@ java_handle_t* java_lang_reflect_Method::invoke(java_handle_t* o, java_handle_ob
        return result;
 }
 
+struct DynOffsetEntry {
+       void (*setter)(int32_t);
+       const char *name;
+};
+
+typedef std::map<classinfo *, DynOffsetEntry *> RegisteredDynMap;
+static RegisteredDynMap dynEntryMap;
 
-// Legacy C interface.
+static void register_dyn_entry_table(classinfo *c, DynOffsetEntry *entries)
+{
+       dynEntryMap.insert(std::make_pair(c, entries));
+}
 
-extern "C" {
-       java_handle_t* java_lang_reflect_Constructor_create(methodinfo* m) { return java_lang_reflect_Constructor(m).get_handle(); }
-       java_handle_t* java_lang_reflect_Field_create(fieldinfo* f) { return java_lang_reflect_Field(f).get_handle(); }
-       java_handle_t* java_lang_reflect_Method_create(methodinfo* m) { return java_lang_reflect_Method(m).get_handle(); }
+static bool runAllSetters(classinfo *c, DynOffsetEntry entries[])
+{
+       do {
+               fieldinfo *fi = class_findfield_by_name(c, utf_new_char(entries->name));
+               if (!fi)
+                       return false;
+               entries->setter(fi->offset);
+       } while ((++entries)->setter);
+       return true;
+}
+
+bool jobjects_run_dynoffsets_hook(classinfo *c)
+{
+       RegisteredDynMap::const_iterator it = dynEntryMap.find(c);
+       if (it == dynEntryMap.end())
+               return true;
+
+       if (!runAllSetters(c, it->second))
+               return false;
+
+       return true;
+}
+
+
+void jobjects_register_dyn_offsets()
+{
 }
 
 #endif // ENABLE_JAVASE
@@ -143,4 +246,5 @@ extern "C" {
  * c-basic-offset: 4
  * tab-width: 4
  * End:
+ * vim:noexpandtab:sw=4:ts=4:
  */