Merged revisions 7501-7598 via svnmerge from

[cacao.git] / src / cacaoh / dummy.c

diff --git a/src/cacaoh/dummy.c b/src/cacaoh/dummy.c
index 774e4dbf44a5c3e09acd9ec22ff28cb2f4839cee..03e9afb885245b357f9ce5ce61bb9408eae1921c 100644 (file)
--- a/src/cacaoh/dummy.c
+++ b/src/cacaoh/dummy.c
@@ -32,6 +32,7 @@
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <assert.h>
 
 #if defined(ENABLE_THREADS)
 # include <pthread.h>
@@ -44,11 +45,11 @@
 #include "vm/global.h"
 #include "vm/vm.h"
 
-#include "vm/jit/code.h"
-
 #include "vmcore/class.h"
 #include "vmcore/method.h"
 #include "vmcore/utf8.h"
+#include "vmcore/classcache.h"
+#include "vmcore/loader.h"
 
 
 /* global variables ***********************************************************/
@@ -100,6 +101,16 @@ void intrp_asm_abstractmethoderror(void)
        abort();
 }
 
+void asm_getclassvalues_atomic(vftbl_t *super, vftbl_t *sub, castinfo *out)
+{
+       abort();
+}
+
+void intrp_asm_getclassvalues_atomic(vftbl_t *super, vftbl_t *sub, castinfo *out)
+{
+       abort();
+}
+
 
 /* builtin ********************************************************************/
 
@@ -124,6 +135,13 @@ java_objectheader *builtin_new(classinfo *c)
        return NULL;
 }
 
+java_objectarray *builtin_anewarray(s4 size, classinfo *componentclass)
+{
+       abort();
+
+       return NULL;
+}
+
 
 /* code ***********************************************************************/
 
@@ -132,6 +150,12 @@ void code_free_code_of_method(methodinfo *m)
 }
 
 
+methodinfo *code_get_methodinfo_for_pv(u1 *pv)
+{
+       return NULL;
+}
+
+
 /* codegen ********************************************************************/
 
 codeinfo *codegen_createnativestub(functionptr f, methodinfo *m)
@@ -251,6 +275,17 @@ void exceptions_throw_noclassdeffounderror(utf *name)
        abort();
 }
 
+void exceptions_throw_noclassdeffounderror_wrong_name(classinfo *c, utf *name)
+{
+       fprintf(stderr, "java.lang.NoClassDefFoundError: ");
+       utf_fprint_printable_ascii(stderr, c->name);
+       fprintf(stderr, " (wrong name: ");
+       utf_fprint_printable_ascii(stderr, name);
+       fprintf(stderr, ")\n");
+
+       abort();
+}
+
 void exceptions_throw_outofmemoryerror(void)
 {
        fprintf(stderr, "java.lang.OutOfMemoryError\n");
@@ -459,38 +494,120 @@ char *properties_get(char *key)
 }
 
 
-/* stacktrace *****************************************************************/
+/* resolve ********************************************************************/
 
-java_objectarray *stacktrace_getClassContext()
+bool resolve_class_from_typedesc(typedesc *d, bool checkaccess, bool link, classinfo **result)
 {
-       return NULL;
+       abort();
+
+       return false;
 }
 
+/* stupid resolving implementation used by resolve_classref_or_classinfo_eager */
+/* This function does eager resolving without any access checks.               */
 
-/* threads ********************************************************************/
+static classinfo * dummy_resolve_class_from_name(classinfo *referer,
+                                                 utf *classname,
+                                                 bool checkaccess)
+{
+       classinfo *cls = NULL;
+       char *utf_ptr;
+       int len;
+       
+       assert(referer);
+       assert(classname);
+       
+       /* lookup if this class has already been loaded */
 
-pthread_key_t threads_current_threadobject_key;
+       cls = classcache_lookup(referer->classloader, classname);
 
-ptrint threads_get_current_tid(void)
-{
-       return 0;
-}
+       if (!cls) {
+               /* resolve array types */
 
+               if (classname->text[0] == '[') {
+                       utf_ptr = classname->text + 1;
+                       len = classname->blength - 1;
 
-/* typeinfo *******************************************************************/
+                       /* classname is an array type name */
 
-bool typeinfo_init_class(typeinfo *info, classref_or_classinfo c)
+                       switch (*utf_ptr) {
+                               case 'L':
+                                       utf_ptr++;
+                                       len -= 2;
+                                       /* FALLTHROUGH */
+                               case '[':
+                                       /* the component type is a reference type */
+                                       /* resolve the component type */
+                                       if ((cls = dummy_resolve_class_from_name(referer,
+                                                                          utf_new(utf_ptr,len),
+                                                                          checkaccess)) == NULL)
+                                               return NULL; /* exception */
+
+                                       /* create the array class */
+                                       cls = class_array_of(cls,false);
+                                       if (!cls)
+                                               return NULL; /* exception */
+                       }
+               }
+
+               /* load the class */
+               if (!cls) {
+                       if (!(cls = load_class_from_classloader(classname,
+                                                                                                       referer->classloader)))
+                               return false; /* exception */
+               }
+       }
+
+       /* the class is now loaded */
+       assert(cls);
+       assert(cls->state & CLASS_LOADED);
+
+       return cls;
+}
+
+
+classinfo * resolve_classref_or_classinfo_eager(classref_or_classinfo cls,
+                                                                                               bool checkaccess)
 {
-       return true;
+       classinfo         *c;
+       
+       assert(cls.any);
+
+       if (IS_CLASSREF(cls)) {
+               /* we must resolve this reference */
+
+               if ((c = dummy_resolve_class_from_name(cls.ref->referer, cls.ref->name,
+                                                                                  checkaccess)) == NULL)
+                       return NULL;
+       }
+       else {
+               /* cls has already been resolved */
+               c = cls.cls;
+       }
+
+       assert(c);
+       assert(c->state & CLASS_LOADED);
+
+       /* succeeded */
+       return c;
 }
 
-void typeinfo_init_classinfo(typeinfo *info, classinfo *c)
+
+/* stacktrace *****************************************************************/
+
+java_objectarray *stacktrace_getClassContext()
 {
+       return NULL;
 }
 
-typecheck_result typeinfo_is_assignable_to_class(typeinfo *value, classref_or_classinfo dest)
+
+/* threads ********************************************************************/
+
+pthread_key_t threads_current_threadobject_key;
+
+ptrint threads_get_current_tid(void)
 {
-       return typecheck_TRUE;
+       return 0;
 }