2009/7/1 Tomek Grabiec <[email protected]>:
> ---intro private vmtype
>
> Signed-off-by: Tomek Grabiec <[email protected]>
> ---
> include/vm/class.h | 5 +++
> include/vm/classloader.h | 1 +
> include/vm/java_lang.h | 8 ++++++
> vm/classloader.c | 63 ++++++++++++++++++++++++++++++++++++++-------
> vm/jato.c | 17 ++++++++++++
> 5 files changed, 84 insertions(+), 10 deletions(-)
>
> diff --git a/include/vm/class.h b/include/vm/class.h
> index 8c27366..d70cc83 100644
> --- a/include/vm/class.h
> +++ b/include/vm/class.h
> @@ -43,6 +43,10 @@ struct vm_class {
> uint8_t *static_values;
>
> struct list_head static_fixup_site_list;
> +
> + /* For primitve type classes this holds a vm type
Typo
> + represented by this class. */
> + enum vm_type primitive_vm_type;
> };
>
> int vm_class_link(struct vm_class *vmc, const struct cafebabe_class *class);
> @@ -89,5 +93,6 @@ struct vm_method *vm_class_resolve_method_recursive(const
> struct vm_class *vmc,
> uint16_t i);
>
> bool vm_class_is_assignable_from(const struct vm_class *vmc, const struct
> vm_class *from);
> +bool vm_class_is_primitive_type_name(const char *class_name);
>
> #endif /* __CLASS_H */
> diff --git a/include/vm/classloader.h b/include/vm/classloader.h
> index 885e588..44c66c4 100644
> --- a/include/vm/classloader.h
> +++ b/include/vm/classloader.h
> @@ -8,5 +8,6 @@ struct vm_class;
> int classloader_add_to_classpath(const char *classpath);
>
> struct vm_class *classloader_load(const char *class_name);
> +struct vm_class *classloader_load_primitive(const char *class_name);
>
> #endif
> diff --git a/include/vm/java_lang.h b/include/vm/java_lang.h
> index 7a10325..218a358 100644
> --- a/include/vm/java_lang.h
> +++ b/include/vm/java_lang.h
> @@ -5,6 +5,14 @@ extern struct vm_class *vm_java_lang_Object;
> extern struct vm_class *vm_java_lang_Class;
> extern struct vm_class *vm_java_lang_String;
> extern struct vm_class *vm_java_lang_Throwable;
> +extern struct vm_class *vm_boolean_class;
> +extern struct vm_class *vm_char_class;
> +extern struct vm_class *vm_float_class;
> +extern struct vm_class *vm_double_class;
> +extern struct vm_class *vm_byte_class;
> +extern struct vm_class *vm_short_class;
> +extern struct vm_class *vm_int_class;
> +extern struct vm_class *vm_long_class;
>
> extern struct vm_field *vm_java_lang_Class_vmdata;
> extern struct vm_field *vm_java_lang_String_offset;
> diff --git a/vm/classloader.c b/vm/classloader.c
> index 917d7c2..3096d7e 100644
> --- a/vm/classloader.c
> +++ b/vm/classloader.c
> @@ -283,6 +283,34 @@ struct vm_class *load_class_from_classpath_file(const
> char *classpath,
> return result;
> }
>
> +static enum vm_type class_name_to_vm_type(const char *class_name)
> +{
> + if (class_name[0] == 0 || class_name[1] != 0)
> + return J_VOID;
> +
> + switch (class_name[0]) {
> + case 'Z':
> + return J_BOOLEAN;
> + case 'C':
> + return J_CHAR;
> + case 'F':
> + return J_FLOAT;
> + case 'D':
> + return J_DOUBLE;
> + case 'B':
> + return J_BYTE;
> + case 'S':
> + return J_SHORT;
> + case 'I':
> + return J_INT;
> + case 'J':
> + return J_LONG;
> + }
> +
> + return J_VOID;
> +}
> +
> +
> struct vm_class *load_primitive_array_class(const char *class_name,
> unsigned int dimensions, char type)
> {
> @@ -302,6 +330,7 @@ struct vm_class *load_primitive_array_class(const char
> *class_name,
> array_class->methods = NULL;
> array_class->object_size = 0;
> array_class->vtable_size = 0;
> + array_class->primitive_vm_type = class_name_to_vm_type(class_name);
>
> return array_class;
> }
> @@ -329,6 +358,28 @@ struct vm_class *load_class_array_class(const char
> *array_class_name,
> return array_class;
> }
>
> +struct vm_class *classloader_load_primitive(const char *class_name)
> +{
> + struct vm_class *class;
> +
> + class = malloc(sizeof *class);
> + if (!class) {
> + NOT_IMPLEMENTED;
> + return NULL;
> + }
> +
> + class->class = NULL;
> + class->state = VM_CLASS_LINKED;
> + class->name = strdup(class_name);
> + class->super = vm_java_lang_Object;
> + class->fields = NULL;
> + class->methods = NULL;
> + class->object_size = 0;
> + class->vtable_size = 0;
This probably needs to set ->static_size too, but I think that's my
fault from the past :-)
> +
> + return class;
> +}
> +
> struct vm_class *load_array_class(const char *class_name)
> {
> const char *ptr;
> @@ -370,15 +421,7 @@ struct vm_class *load_array_class(const char *class_name)
> return ret;
> }
>
> - switch (*ptr) {
> - case 'B':
> - case 'C':
> - case 'D':
> - case 'F':
> - case 'I':
> - case 'J':
> - case 'S':
> - case 'Z':
> + if (class_name_to_vm_type(ptr)) {
> if (strlen(ptr) != 1) {
> NOT_IMPLEMENTED;
> return NULL;
> @@ -444,7 +487,7 @@ struct vm_class *classloader_load(const char *class_name)
> goto out;
> }
>
> - if (nr_classes == max_classes) {
> + if (nr_classes == max_classes) {
What's this change? I can't tell the difference. Maybe gmail screwed
up the indentation.
> new_max_classes = 1 + max_classes * 2;
> new_array = realloc(classes,
> new_max_classes * sizeof(struct classloader_class));
> diff --git a/vm/jato.c b/vm/jato.c
> index cc94265..1968be5 100644
> --- a/vm/jato.c
> +++ b/vm/jato.c
> @@ -162,6 +162,14 @@ struct vm_class *vm_java_lang_Object;
> struct vm_class *vm_java_lang_Class;
> struct vm_class *vm_java_lang_String;
> struct vm_class *vm_java_lang_Throwable;
> +struct vm_class *vm_boolean_class;
> +struct vm_class *vm_char_class;
> +struct vm_class *vm_float_class;
> +struct vm_class *vm_double_class;
> +struct vm_class *vm_byte_class;
> +struct vm_class *vm_short_class;
> +struct vm_class *vm_int_class;
> +struct vm_class *vm_long_class;
>
> static const struct preload_entry preload_entries[] = {
> { "java/lang/Object", &vm_java_lang_Object },
> @@ -219,6 +227,15 @@ static int preload_vm_classes(void)
> *pe->field = field;
> }
>
> + vm_boolean_class = classloader_load_primitive("Z");
> + vm_char_class = classloader_load_primitive("C");
> + vm_float_class = classloader_load_primitive("F");
> + vm_double_class = classloader_load_primitive("D");
> + vm_byte_class = classloader_load_primitive("B");
> + vm_short_class = classloader_load_primitive("S");
> + vm_int_class = classloader_load_primitive("I");
> + vm_long_class = classloader_load_primitive("J");
> +
> return 0;
> }
Hm. There _could_ fail, but (currently) only as the result of malloc()
failure. The benefit of a table is that we only need to write the
error check once. On the other hand, we're not going to have more than
these 8 primitive classes anyway, so it might make more sense to check
them directly. What do you think? (I think we _should_ check for
errors here, regardless, for the sake of principle.)
Apart from that:
Acked-by: Vegard Nossum <[email protected]>
Vegard
------------------------------------------------------------------------------
_______________________________________________
Jatovm-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/jatovm-devel
