X-Git-Url: http://deadsoftware.ru/gitweb?p=dsw-obn.git;a=blobdiff_plain;f=src%2Fbackends%2Fjvm%2Fgenerator-jvm.c;h=f26c9513e000ca18cc3203fc0e67155b3111398c;hp=c063e2fc7fcc03ddd8c2150e03cca24c2220a96a;hb=HEAD;hpb=789adb9354da345b13aa284f3f4f8f1046cadbc4 diff --git a/src/backends/jvm/generator-jvm.c b/src/backends/jvm/generator-jvm.c index c063e2f..f26c951 100644 --- a/src/backends/jvm/generator-jvm.c +++ b/src/backends/jvm/generator-jvm.c @@ -8,8 +8,9 @@ #include -#include "../../../include/oberon.h" #include "../../oberon-internals.h" +#include "../../oberon-type-compat.h" +#include "../../generator.h" #include "generator-jvm.h" #include "generator-jvm-abi.h" #include "generator-jvm-asm.h" @@ -21,6 +22,96 @@ push_item(gen_proc_t * p, oberon_item_t * item); static void jvm_generate_new(gen_proc_t * p, oberon_type_t * type, int num); +static void +jvm_generate_cast_prefix(gen_proc_t * p, char prefix, char postfix) +{ + if((prefix == 'b' || prefix == 's') && (postfix = 'l' || postfix == 'd')) + { + prefix = 'i'; + } + + if(prefix == postfix) + { + return; + } + + if((prefix == 'l' || prefix == 'd') && (postfix == 'b' || postfix == 's')) + { + jvm_generate(p, 2, 1, "%c2i", prefix); + prefix = 'i'; + } + + int from_cell_size = jvm_cell_size_for_postfix(prefix); + int to_cell_size = jvm_cell_size_for_postfix(postfix); + jvm_generate(p, from_cell_size, to_cell_size, "%c2%c", prefix, postfix); +} + +static void +jvm_generate_cast_type(gen_proc_t * p, oberon_type_t * from, oberon_type_t * to) +{ + if(to -> class == OBERON_TYPE_RECORD || to -> class == OBERON_TYPE_POINTER) + { + if(to -> class == OBERON_TYPE_POINTER && to -> base -> class == OBERON_TYPE_RECORD) + { + char * full_name = jvm_get_class_full_name(to); + jvm_generate(p, 1, 1, "checkcast %s", full_name); + } + } + else + { + char prefix = jvm_get_prefix(from); + char postfix = jvm_get_postfix(to); + jvm_generate_cast_prefix(p, prefix, postfix); + } +} + +static void +jvm_generate_hard_cast_type(gen_proc_t * p, oberon_type_t * from, oberon_type_t * to) +{ + if(from -> class == OBERON_TYPE_REAL + && (to -> class == OBERON_TYPE_INTEGER || to -> class == OBERON_TYPE_SYSTEM_BYTE)) + { + char postfix = jvm_get_postfix(to); + if(from -> size <= 4) + { + jvm_generate(p, 1, 1, "invokestatic java/lang/Float/floatToRawIntBits(F)I"); + jvm_generate_cast_prefix(p, 'i', postfix); + } + else + { + jvm_generate(p, 2, 2, "invokestatic java/lang/Double/doubleToRawLongBits(D)J"); + jvm_generate_cast_prefix(p, 'l', postfix); + } + } + else if((from -> class == OBERON_TYPE_INTEGER || from -> class == OBERON_TYPE_SYSTEM_BYTE) + && to -> class == OBERON_TYPE_REAL) + { + char prefix = jvm_get_prefix(from); + if(to -> size <= 4) + { + jvm_generate_cast_prefix(p, prefix, 'i'); + jvm_generate(p, 1, 1, "invokestatic java/lang/Float/intBitsToFloat(I)F"); + } + else + { + jvm_generate_cast_prefix(p, prefix, 'l'); + jvm_generate(p, 2, 2, "invokestatic java/lang/Double/longBitsToDouble(J)D"); + } + } + else + { + jvm_generate_cast_type(p, from, to); + } +} + +static void +check_index(gen_proc_t * p, oberon_type_t * index_type) +{ + // TODO проверка валидности границ + char prefix = jvm_get_prefix(index_type); + jvm_generate_cast_prefix(p, prefix, 'i'); +} + /* * Генерирует код для инициализации массива со статическим базовым типом * ( aref -- ) @@ -497,6 +588,7 @@ oberon_generator_init_type(oberon_context_t * ctx, oberon_type_t * type) break; case OBERON_TYPE_RECORD: m = type -> module -> gen_mod; + t -> full_name = jvm_get_class_full_name(type); oberon_generate_record_class(c -> dir, m, type); break; case OBERON_TYPE_PROCEDURE: @@ -514,6 +606,14 @@ oberon_generator_init_type(oberon_context_t * ctx, oberon_type_t * type) t -> postfix = jvm_get_postfix(type); } + if((type -> class == OBERON_TYPE_POINTER && type -> base -> class == OBERON_TYPE_RECORD) || + type -> class == OBERON_TYPE_PROCEDURE || + type -> class == OBERON_TYPE_RECORD || + type -> class == OBERON_TYPE_SYSTEM_PTR) + { + t -> full_name = jvm_get_class_full_name(type); + } + t -> cell_size = jvm_cell_size_for_type(type); if(type -> class != OBERON_TYPE_NIL) @@ -583,6 +683,13 @@ oberon_generator_init_record(oberon_context_t * ctx, oberon_type_t * rec) jvm_generate_var_initialization(p, copy_dst); jvm_generate_var_initialization(p, copy_src); + if(rec -> base) + { + jvm_generate_load(p, copy_dst); + jvm_generate_load(p, copy_src); + jvm_generate_copy_record(p, rec -> base); + } + num = rec -> num_decl; field = rec -> decl; for(int i = 0; i < num; i++) @@ -632,6 +739,13 @@ oberon_generator_init_var(oberon_context_t * ctx, oberon_object_t * var) struct gen_class * c; char * name = var -> name; gen_type_t * t = var -> type -> gen_type; + + assert(name); + if(t == NULL) + { + gen_error("uninitialized type class %i", var -> type -> class); + } + switch(var -> class) { case OBERON_CLASS_VAR_PARAM: @@ -664,6 +778,18 @@ oberon_generator_init_var(oberon_context_t * ctx, oberon_object_t * var) } } +static void +oberon_generate_static_initialization(gen_proc_t * p, oberon_object_t * x) +{ + if(x -> type -> class == OBERON_TYPE_ARRAY + || x -> type -> class == OBERON_TYPE_RECORD) + { + jvm_generate_ldst_prepare(p, x -> gen_var); + jvm_generate_new(p, x -> type, 0); + jvm_generate_store(p, x -> gen_var); + } +} + void oberon_generator_init_temp_var(oberon_context_t * ctx, oberon_object_t * var) { @@ -681,6 +807,7 @@ oberon_generator_init_temp_var(oberon_context_t * ctx, oberon_object_t * var) var -> gen_var = jvm_create_function_temp_var(p, t); jvm_generate_var(var -> gen_var); jvm_generate_var_initialization(p, var -> gen_var); + oberon_generate_static_initialization(p, var); } void @@ -760,13 +887,7 @@ oberon_generate_begin_module(oberon_context_t * ctx) else if(x -> class == OBERON_CLASS_VAR) { jvm_generate_var_initialization(p, x -> gen_var); - if(x -> type -> class == OBERON_TYPE_ARRAY - || x -> type -> class == OBERON_TYPE_RECORD) - { - jvm_generate_ldst_prepare(p, x -> gen_var); - jvm_generate_new(p, x -> type, 0); - jvm_generate_store(p, x -> gen_var); - } + oberon_generate_static_initialization(p, x); } x = x -> next; @@ -865,10 +986,12 @@ jvm_generate_local_object(gen_proc_t * p, oberon_object_t * x) case OBERON_CLASS_VAR: jvm_generate_var(v); break; + case OBERON_CLASS_CONST: + case OBERON_CLASS_TYPE: case OBERON_CLASS_PROC: break; default: - gen_error("jvm_generate_local_initialization: wat"); + gen_error("jvm_generate_local_initialization: wat class %i", x -> class); break; } } @@ -889,28 +1012,31 @@ jvm_generate_local_initialization(gen_proc_t * p, oberon_object_t * x) switch(x -> class) { case OBERON_CLASS_VAR_PARAM: + jvm_generate_var_initialization(p, v); + break; case OBERON_CLASS_PARAM: + jvm_generate_var_initialization(p, v); + if(x -> type -> class == OBERON_TYPE_ARRAY) + { + jvm_generate_array_duplicate_and_replace(p, v, x -> type); + } + else if(x -> type -> class == OBERON_TYPE_RECORD) + { + jvm_generate_record_duplicate_and_replace(p, v, x -> type); + } + break; case OBERON_CLASS_VAR: jvm_generate_var_initialization(p, v); + oberon_generate_static_initialization(p, x); break; + case OBERON_CLASS_CONST: + case OBERON_CLASS_TYPE: case OBERON_CLASS_PROC: break; default: - gen_error("jvm_generate_local_initialization: wat"); + gen_error("jvm_generate_local_initialization: wat class %i", x -> class); break; } - - if(x -> class == OBERON_CLASS_PARAM) - { - if(x -> type -> class == OBERON_TYPE_ARRAY) - { - jvm_generate_array_duplicate_and_replace(p, v, x -> type); - } - else if(x -> type -> class == OBERON_TYPE_RECORD) - { - jvm_generate_record_duplicate_and_replace(p, v, x -> type); - } - } } void @@ -934,6 +1060,7 @@ oberon_generate_begin_proc(oberon_context_t * ctx, oberon_object_t * proc) } name = jvm_get_name(proc); + p -> ret_prefix = jvm_get_prefix(proc -> type -> base); jvm_generate_function_header(p, "public static", name, signature); if(proc -> local) @@ -971,6 +1098,36 @@ oberon_generate_end_proc(oberon_context_t * ctx) m = ctx -> mod -> gen_mod; p = m -> class -> p; + oberon_generate_trap(ctx, -4); + + if(p -> ret_prefix == ' ') + { + jvm_generate(p, 0, 0, "return"); + } + else + { + int sz = jvm_cell_size_for_postfix(p -> ret_prefix); + switch(p -> ret_prefix) + { + case 'a': + jvm_generate(p, 0, 1, "aconst_null"); + break; + case 'l': + jvm_generate_push_int_size(p, 0, 8); + break; + case 'f': + jvm_generate_push_float(p, 0, 4); + break; + case 'd': + jvm_generate_push_float(p, 0, 8); + break; + default: + jvm_generate_push_int(p, 0); + break; + } + jvm_generate(p, sz, 0, "%creturn", p -> ret_prefix); + } + jvm_generate_function_end(p); } @@ -1051,6 +1208,7 @@ push_varptr(gen_proc_t * p, oberon_expr_t * expr) case MODE_INDEX: push_item(p, expr -> item.parent); push_expr(p, expr -> item.args); + check_index(p, expr -> item.args -> result); break; case MODE_FIELD: push_item(p, expr -> item.parent); @@ -1169,44 +1327,13 @@ jvm_generate_expr_new_pointer(gen_proc_t * p, oberon_type_t * type, int num, obe for(int i = 0; i < num; i++) { push_expr(p, arg); + check_index(p, arg -> result); arg = arg -> next; } jvm_generate_new(p, type -> base, num); } -static void -jvm_generate_cast_prefix(gen_proc_t * p, char prefix, char postfix) -{ - if(prefix == postfix) - { - return; - } - - int from_cell_size = jvm_cell_size_for_postfix(prefix); - int to_cell_size = jvm_cell_size_for_postfix(postfix); - jvm_generate(p, from_cell_size, to_cell_size, "%c2%c", prefix, postfix); -} - -static void -jvm_generate_cast_type(gen_proc_t * p, oberon_type_t * from, oberon_type_t * to) -{ - if(to -> class == OBERON_TYPE_RECORD || to -> class == OBERON_TYPE_POINTER) - { - if(to -> class == OBERON_TYPE_POINTER && to -> base -> class == OBERON_TYPE_RECORD) - { - char * full_name = jvm_get_class_full_name(to); - jvm_generate(p, 1, 1, "checkcast %s", full_name); - } - } - else - { - char prefix = jvm_get_prefix(from); - char postfix = jvm_get_postfix(to); - jvm_generate_cast_prefix(p, prefix, postfix); - } -} - static void push_item(gen_proc_t * p, oberon_item_t * item) { @@ -1237,6 +1364,7 @@ push_item(gen_proc_t * p, oberon_item_t * item) int cell_size = jvm_cell_size_for_postfix(postfix); push_item(p, item -> parent); push_expr(p, item -> args); + check_index(p, item -> args -> result); jvm_generate(p, 1 + 1, cell_size, "%caload", postfix); break; case MODE_FIELD: @@ -1264,6 +1392,10 @@ push_item(gen_proc_t * p, oberon_item_t * item) jvm_generate_array_len(p, item -> integer); jvm_generate_cast_prefix(p, 'i', jvm_get_postfix(item -> result)); break; + case MODE_AS: + push_item(p, item -> parent); + jvm_generate_cast_type(p, item -> parent -> result, item -> result); + break; default: gen_error("push_item: unk mode %i", item -> mode); break; @@ -1353,8 +1485,7 @@ jvm_generate_compare_op(gen_proc_t * p, oberon_type_t * t, int op) } else if(prefix == 'a') { - if(t -> class == OBERON_TYPE_STRING - || (t -> class == OBERON_TYPE_POINTER && t -> base -> class == OBERON_TYPE_CHAR)) + if(oberon_is_array_of_char_type(t) || oberon_is_string_type(t)) { jvm_generate(p, 2, 1, "invokestatic SYSTEM/STRCMP([B[B)I"); jvm_generate(p, 1, 0, "if%s L%i", cmpop, label_true); @@ -1624,6 +1755,10 @@ push_operator(gen_proc_t * p, oberon_oper_t * oper) push_expr(p, oper -> left); jvm_generate_cast_type(p, oper -> left -> result, oper -> result); break; + case OP_HARDCAST: + push_expr(p, oper -> left); + jvm_generate_hard_cast_type(p, oper -> left -> result, oper -> result); + break; case OP_COMPLEMENTATION: case OP_UNARY_MINUS: case OP_LOGIC_NOT: @@ -1736,6 +1871,7 @@ store_expr(gen_proc_t * p, oberon_expr_t * dst, oberon_expr_t * src) assert(item -> parent -> is_item); push_item(p, (oberon_item_t *) item -> parent); push_expr(p, item -> args); + check_index(p, item -> args -> result); push_expr(p, src); jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix); break; @@ -1844,3 +1980,29 @@ oberon_set_out_directory(oberon_context_t * ctx, const char * path) c -> dir = new_string(path); } + +void +oberon_set_typecheck(oberon_object_t * var, bool enable) +{ + var -> gen_var -> typecheck = enable; + var -> gen_var -> forcetype = (enable) ? (var -> type -> gen_type) : (NULL); +} + +void oberon_set_line(oberon_context_t * ctx, int line) +{ + gen_module_t * m; + gen_proc_t * p; + + m = ctx -> mod -> gen_mod; + if(m != NULL) + { + p = m -> class -> p; + + if(p != NULL) + { + jvm_generate(p, 0, 0, ".line %i", line); + } + + m -> line = line; + } +}