Signed-off-by: Tomek Grabiec <tgrab...@gmail.com> --- include/vm/preload.h | 17 +++++++ include/vm/reflection.h | 1 + test/vm/preload-stub.c | 6 ++ vm/jato.c | 1 + vm/preload.c | 75 ++++++++++++++++++++++++++++++ vm/reflection.c | 117 +++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 217 insertions(+), 0 deletions(-)
diff --git a/include/vm/preload.h b/include/vm/preload.h index 4fd134d..6382678 100644 --- a/include/vm/preload.h +++ b/include/vm/preload.h @@ -34,6 +34,15 @@ extern struct vm_class *vm_java_lang_VMThread; extern struct vm_class *vm_java_lang_IllegalMonitorStateException; extern struct vm_class *vm_java_lang_reflect_Constructor; extern struct vm_class *vm_java_lang_reflect_Field; +extern struct vm_class *vm_java_lang_Byte; +extern struct vm_class *vm_java_lang_Boolean; +extern struct vm_class *vm_java_lang_Character; +extern struct vm_class *vm_java_lang_Double; +extern struct vm_class *vm_java_lang_Float; +extern struct vm_class *vm_java_lang_Integer; +extern struct vm_class *vm_java_lang_Long; +extern struct vm_class *vm_java_lang_Short; +extern struct vm_class *vm_java_lang_IllegalArgumentException; extern struct vm_class *vm_boolean_class; extern struct vm_class *vm_char_class; extern struct vm_class *vm_float_class; @@ -79,6 +88,14 @@ extern struct vm_method *vm_java_lang_ThreadGroup_addThread; extern struct vm_method *vm_java_lang_VMThread_init; extern struct vm_method *vm_java_lang_VMThread_run; extern struct vm_method *vm_java_lang_System_exit; +extern struct vm_method *vm_java_lang_Boolean_init; +extern struct vm_method *vm_java_lang_Byte_init; +extern struct vm_method *vm_java_lang_Character_init; +extern struct vm_method *vm_java_lang_Double_init; +extern struct vm_method *vm_java_lang_Float_init; +extern struct vm_method *vm_java_lang_Integer_init; +extern struct vm_method *vm_java_lang_Long_init; +extern struct vm_method *vm_java_lang_Short_init; int preload_vm_classes(void); diff --git a/include/vm/reflection.h b/include/vm/reflection.h index 97ba29b..538f7d1 100644 --- a/include/vm/reflection.h +++ b/include/vm/reflection.h @@ -21,5 +21,6 @@ native_constructor_construct_native(struct vm_object *this, int slot); struct vm_object *native_vmclass_get_interfaces(struct vm_object *clazz); struct vm_object *native_vmclass_get_superclass(struct vm_object *clazz); +struct vm_object *native_field_get(struct vm_object *this, struct vm_object *o); #endif /* __JATO_VM_REFLECTION_H */ diff --git a/test/vm/preload-stub.c b/test/vm/preload-stub.c index f6c25a1..4e82da8 100644 --- a/test/vm/preload-stub.c +++ b/test/vm/preload-stub.c @@ -6,8 +6,14 @@ struct vm_class *vm_java_lang_Class; struct vm_field *vm_java_lang_Class_vmdata; struct vm_class *vm_java_lang_Cloneable; struct vm_class *vm_java_lang_String; +struct vm_class *vm_boolean_class; struct vm_class *vm_byte_class; +struct vm_class *vm_char_class; struct vm_class *vm_double_class; +struct vm_class *vm_float_class; +struct vm_class *vm_int_class; +struct vm_class *vm_long_class; +struct vm_class *vm_short_class; struct vm_field *vm_java_lang_String_offset; struct vm_field *vm_java_lang_String_count; diff --git a/vm/jato.c b/vm/jato.c index d15a816..ad9eae9 100644 --- a/vm/jato.c +++ b/vm/jato.c @@ -686,6 +686,7 @@ static struct vm_native natives[] = { DEFINE_NATIVE("java/lang/reflect/Constructor", "getParameterTypes", &native_constructor_get_parameter_types), DEFINE_NATIVE("java/lang/reflect/Constructor", "getModifiersInternal", &native_constructor_get_modifiers_internal), DEFINE_NATIVE("java/lang/reflect/Constructor", "constructNative", &native_constructor_construct_native), + DEFINE_NATIVE("java/lang/reflect/Field", "get", &native_field_get), DEFINE_NATIVE("jato/internal/VM", "enableFault", &native_vm_enable_fault), DEFINE_NATIVE("jato/internal/VM", "disableFault", &native_vm_disable_fault), }; diff --git a/vm/preload.c b/vm/preload.c index d4a1705..7b5d023 100644 --- a/vm/preload.c +++ b/vm/preload.c @@ -71,6 +71,15 @@ struct vm_class *vm_java_lang_reflect_Field; struct vm_class *vm_array_of_java_lang_reflect_Constructor; struct vm_class *vm_array_of_java_lang_reflect_Field; struct vm_class *vm_array_of_java_lang_Class; +struct vm_class *vm_java_lang_IllegalArgumentException; +struct vm_class *vm_java_lang_Byte; +struct vm_class *vm_java_lang_Boolean; +struct vm_class *vm_java_lang_Character; +struct vm_class *vm_java_lang_Double; +struct vm_class *vm_java_lang_Float; +struct vm_class *vm_java_lang_Integer; +struct vm_class *vm_java_lang_Long; +struct vm_class *vm_java_lang_Short; struct vm_class *vm_boolean_class; struct vm_class *vm_char_class; struct vm_class *vm_float_class; @@ -115,6 +124,15 @@ static const struct preload_entry preload_entries[] = { { "[java/lang/Class", &vm_array_of_java_lang_Class }, { "[java/lang/reflect/Constructor", &vm_array_of_java_lang_reflect_Constructor }, { "[java/lang/reflect/Field", &vm_array_of_java_lang_reflect_Field }, + { "java/lang/IllegalArgumentException", &vm_java_lang_IllegalArgumentException }, + { "java/lang/Boolean", &vm_java_lang_Boolean }, + { "java/lang/Byte", &vm_java_lang_Byte }, + { "java/lang/Character", &vm_java_lang_Character }, + { "java/lang/Short", &vm_java_lang_Short }, + { "java/lang/Float", &vm_java_lang_Float }, + { "java/lang/Integer", &vm_java_lang_Integer }, + { "java/lang/Double", &vm_java_lang_Double }, + { "java/lang/Long", &vm_java_lang_Long }, }; static const struct preload_entry primitive_preload_entries[] = { @@ -201,6 +219,14 @@ struct vm_method *vm_java_lang_ThreadGroup_addThread; struct vm_method *vm_java_lang_VMThread_init; struct vm_method *vm_java_lang_VMThread_run; struct vm_method *vm_java_lang_System_exit; +struct vm_method *vm_java_lang_Boolean_init; +struct vm_method *vm_java_lang_Byte_init; +struct vm_method *vm_java_lang_Character_init; +struct vm_method *vm_java_lang_Double_init; +struct vm_method *vm_java_lang_Float_init; +struct vm_method *vm_java_lang_Integer_init; +struct vm_method *vm_java_lang_Long_init; +struct vm_method *vm_java_lang_Short_init; static const struct method_preload_entry method_preload_entries[] = { { @@ -293,6 +319,54 @@ static const struct method_preload_entry method_preload_entries[] = { "(I)V", &vm_java_lang_System_exit, }, + { + &vm_java_lang_Boolean, + "<init>", + "(Z)V", + &vm_java_lang_Boolean_init, + }, + { + &vm_java_lang_Byte, + "<init>", + "(B)V", + &vm_java_lang_Byte_init, + }, + { + &vm_java_lang_Character, + "<init>", + "(C)V", + &vm_java_lang_Character_init, + }, + { + &vm_java_lang_Double, + "<init>", + "(D)V", + &vm_java_lang_Double_init, + }, + { + &vm_java_lang_Long, + "<init>", + "(J)V", + &vm_java_lang_Long_init, + }, + { + &vm_java_lang_Short, + "<init>", + "(S)V", + &vm_java_lang_Short_init, + }, + { + &vm_java_lang_Float, + "<init>", + "(F)V", + &vm_java_lang_Float_init, + }, + { + &vm_java_lang_Integer, + "<init>", + "(I)V", + &vm_java_lang_Integer_init, + }, }; int preload_vm_classes(void) @@ -304,6 +378,7 @@ int preload_vm_classes(void) struct vm_class *class = classloader_load(pe->name); if (!class) { + printf("%s\n", pe->name); NOT_IMPLEMENTED; return 1; } diff --git a/vm/reflection.c b/vm/reflection.c index b319dc6..c5361ef 100644 --- a/vm/reflection.c +++ b/vm/reflection.c @@ -249,3 +249,120 @@ struct vm_object *native_vmclass_get_superclass(struct vm_object *clazz) return vmc->super->object; } + +static struct vm_object *encapsulate_value(void *value_p, enum vm_type type) +{ + struct vm_object *obj; + + switch (type) { + case J_REFERENCE: + return *(struct vm_object **) value_p; + case J_BOOLEAN: + obj = vm_object_alloc(vm_java_lang_Boolean); + if (!obj) + goto failed_obj; + vm_call_method(vm_java_lang_Boolean_init, obj, *(jboolean *) value_p); + return obj; + case J_BYTE: + obj = vm_object_alloc(vm_java_lang_Byte); + if (!obj) + goto failed_obj; + vm_call_method(vm_java_lang_Byte_init, obj, *(jbyte *) value_p); + return obj; + case J_CHAR: + obj = vm_object_alloc(vm_java_lang_Character); + if (!obj) + goto failed_obj; + vm_call_method(vm_java_lang_Character_init, obj, *(jchar *) value_p); + return obj; + case J_SHORT: + obj = vm_object_alloc(vm_java_lang_Short); + if (!obj) + goto failed_obj; + vm_call_method(vm_java_lang_Short_init, obj, *(jshort *) value_p); + return obj; + case J_FLOAT: + obj = vm_object_alloc(vm_java_lang_Float); + if (!obj) + goto failed_obj; + vm_call_method(vm_java_lang_Float_init, obj, *(jfloat *) value_p); + return obj; + case J_INT: + obj = vm_object_alloc(vm_java_lang_Integer); + if (!obj) + goto failed_obj; + vm_call_method(vm_java_lang_Integer_init, obj, *(jint *) value_p); + return obj; + case J_DOUBLE: + obj = vm_object_alloc(vm_java_lang_Double); + if (!obj) + goto failed_obj; + vm_call_method(vm_java_lang_Double_init, obj, *(jdouble *) value_p); + return obj; + case J_LONG: + obj = vm_object_alloc(vm_java_lang_Long); + if (!obj) + goto failed_obj; + vm_call_method(vm_java_lang_Long_init, obj, *(jlong *) value_p); + return obj; + default: + error("invalid type"); + } + + failed_obj: + NOT_IMPLEMENTED; + return NULL; +} + +struct vm_object *native_field_get(struct vm_object *this, struct vm_object *o) +{ + struct vm_field *vmf; + struct vm_class *vmc; + struct vm_object *clazz; + unsigned int slot; + void *value_p; + + clazz = field_get_object(this, vm_java_lang_reflect_Field_declaringClass); + slot = field_get_int32(this, vm_java_lang_reflect_Field_slot); + + vmc = vm_class_get_class_from_class_object(clazz); + + vm_class_ensure_init(vmc); + if (exception_occurred()) + return NULL; + + vmf = &vmc->fields[slot]; + + /* + * TODO: "If this Field enforces access control, your runtime + * context is evaluated, and you may have an + * IllegalAccessException if you could not access this field + * in similar compiled code". (java/lang/reflect/Field.java) + */ + + enum vm_type type = vm_field_type(vmf); + + if (vm_field_is_static(vmf)) + value_p = vmc->static_values + vmf->offset; + else { + /* + * If o is null, you get a NullPointerException, and + * if it is incompatible with the declaring class of + * the field, you get an IllegalArgumentException. + */ + if (!o) { + signal_new_exception(vm_java_lang_NullPointerException, + NULL); + return NULL; + } + + if (o->class != vmc) { + signal_new_exception(vm_java_lang_IllegalArgumentException, NULL); + return NULL; + } + + value_p = &o->fields[vmf->offset]; + } + + return encapsulate_value(value_p, type); +} -- 1.6.0.6 ------------------------------------------------------------------------------ Let Crystal Reports handle the reporting - Free Crystal Reports 2008 30-Day trial. Simplify your report design, integration and deployment - and focus on what you do best, core application coding. Discover what's new with Crystal Reports now. http://p.sf.net/sfu/bobj-july _______________________________________________ Jatovm-devel mailing list Jatovm-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/jatovm-devel