X-Git-Url: http://deadsoftware.ru/gitweb?a=blobdiff_plain;f=src%2Fbackends%2Fjvm%2Fgenerator-jvm.c;h=a107efc119eca8a22afc620cbc912e8e284f86fa;hb=2c43a7d73a91f64b1318306fa259a9337951a3a3;hp=215f6d757b1d92fd1b1b2c67ed088333959e927d;hpb=351f950548241d4c4bd799acabbcd98a39b096cc;p=dsw-obn.git diff --git a/src/backends/jvm/generator-jvm.c b/src/backends/jvm/generator-jvm.c index 215f6d7..a107efc 100644 --- a/src/backends/jvm/generator-jvm.c +++ b/src/backends/jvm/generator-jvm.c @@ -1,5 +1,7 @@ #include +#include #include +#include #include #include #include @@ -9,270 +11,862 @@ #include "../../../include/oberon.h" #include "../../oberon-internals.h" #include "generator-jvm.h" +#include "generator-jvm-basic.h" -char * -new_string(const char * format, ...) +// ========================================== +// ========================================== +// ========================================== + +gen_proc_t * +jvm_create_proc(struct gen_class * class) +{ + gen_proc_t * p = GC_MALLOC(sizeof *p); + memset(p, 0, sizeof *p); + + struct gen_register_file * rf = GC_MALLOC(sizeof *rf); + memset(rf, 0, sizeof *rf); + + struct gen_stack * stack = GC_MALLOC(sizeof *stack); + memset(rf, 0, sizeof *stack); + + p -> rf = rf; + p -> stack = stack; + p -> class = class; + p -> label_id = 0; + + return p; +} + +void +jvm_generate_function_header(gen_proc_t * p, char * access, char * name, char * signature) +{ + struct gen_class * class; + class = p -> class; + + /* Делаем процедуру текущей в этом классе */ + assert(class -> p == NULL); + class -> p = p; + + fprintf(class -> fp, ".method %s %s%s\n", access, name, signature); + fprintf(class -> fp, " start:\n"); +} + +void +jvm_generate_function_end(gen_proc_t * p) +{ + struct gen_class * class; + class = p -> class; + + assert(class -> p); + class -> p = NULL; + + int pointer = p -> stack -> pointer; + int max_pointer = p -> stack -> max_pointer; + int locals = p -> rf -> num_used; + int max_locals = p -> rf -> max_used; + + fprintf(class -> fp, " .limit stack %i \t; current(%i)\n", max_pointer, pointer); + fprintf(class -> fp, " .limit locals %i \t; current(%i)\n", max_locals, locals); + fprintf(class -> fp, " end:\n"); + fprintf(class -> fp, ".end method\n\n"); +} + +struct gen_class * +jvm_create_class(char * full_name) +{ + struct gen_class * class = GC_MALLOC(sizeof *class); + memset(class, 0, sizeof *class); + + char * fname = new_string("%s.j", full_name); + class -> full_name = new_string(full_name); + class -> fp = fopen(fname, "w"); + assert(class -> fp); + + return class; +} + +static void +jvm_destroy_class(struct gen_class * class) +{ + assert(class -> p == NULL); + fclose(class -> fp); +} + +static void +jvm_stack_push(gen_proc_t * p, unsigned size) +{ + p -> stack -> pointer += size; + if(p -> stack -> pointer > p -> stack -> max_pointer) + { + p -> stack -> max_pointer = p -> stack -> pointer; + } +} + +static void +jvm_stack_pop(gen_proc_t * p, unsigned size) +{ + p -> stack -> pointer -= size; + + if(p -> stack -> pointer < 0) + { + printf("WARING: stack pointer %i\n", p -> stack -> pointer); + } +} + +static void +jvm_generate(gen_proc_t * p, unsigned get, unsigned push, char * format, ...) { va_list ptr; va_start(ptr, format); - char buf[1024]; - vsnprintf(buf, 1024, format, ptr); + jvm_stack_pop(p, get); + fprintf(p -> class -> fp, " "); + vfprintf(p -> class -> fp, format, ptr); + jvm_stack_push(p, push); + fprintf(p -> class -> fp, " \t ;>>>> %i -- %i : current_stack(%i)\n", get, push, p -> stack -> pointer); va_end(ptr); +} - char * result; - int size; +static void +jvm_generate_comment(gen_proc_t * p, char * format, ...) +{ + va_list ptr; + va_start(ptr, format); - size = strlen(buf); - result = GC_MALLOC(size + 1); - memset(result, 0, size); - strncpy(result, buf, size); + fprintf(p -> class -> fp, " ;;;; "); + vfprintf(p -> class -> fp, format, ptr); + fprintf(p -> class -> fp, "\n"); - return result; + va_end(ptr); } -void -oberon_generator_init_context(oberon_context_t * ctx) +static void +jvm_generate_push_int(gen_proc_t * p, int64_t i) { - gen_context_t * gen_context = GC_MALLOC(sizeof *gen_context); - memset(gen_context, 0, sizeof *gen_context); + if(i == -1) + { + jvm_generate(p, 0, 1, "iconst_m1"); + } + else if(i >= 0 && i <= 5) + { + jvm_generate(p, 0, 1, "iconst_%li", i); + } + else if(i >= -128 && i <= 127) + { + jvm_generate(p, 0, 1, "bipush %li", i); + } + else if(i >= -32768 && i <= 32767) + { + jvm_generate(p, 0, 1, "sipush %li", i); + } + else if(i >= -2147483648 && i <= 2147483647) + { + jvm_generate(p, 0, 1, "ldc %li", i); + } + else + { + jvm_generate(p, 0, 2, "ldc2_w %li", i); + } +} - ctx -> gen_context = gen_context; +static void +jvm_generate_push_int_size(gen_proc_t * p, int64_t i, int size) +{ + int pushed_cell = 1; + + if(i == -1) + { + jvm_generate(p, 0, 1, "iconst_m1"); + } + else if(i >= 0 && i <= 5) + { + jvm_generate(p, 0, 1, "iconst_%li", i); + } + else if(i >= -128 && i <= 127) + { + jvm_generate(p, 0, 1, "bipush %li", i); + } + else if(i >= -32768 && i <= 32767) + { + jvm_generate(p, 0, 1, "sipush %li", i); + } + else if(i >= -2147483648 && i <= 2147483647) + { + jvm_generate(p, 0, 1, "ldc %li", i); + } + else + { + pushed_cell = 2; + jvm_generate(p, 0, 2, "ldc2_w %li", i); + } + + assert(size <= 8); + if(size > 4 && pushed_cell == 1) + { + jvm_generate(p, pushed_cell, 2, "i2l"); + } + else if(size <= 4) + { + if(pushed_cell > 1) + { + jvm_generate(p, 2, 1, "l2i"); + } + + if(size == 2) + { + jvm_generate(p, 1, 1, "i2s"); + } + else if(size == 1) + { + jvm_generate(p, 1, 1, "i2b"); + } + } } -void -oberon_generator_destroy_context(oberon_context_t * ctx) +static void +jvm_generate_push_float(gen_proc_t * p, double f, int size) +{ + if(size <= 4) + { + if(f == 0.0) + { + jvm_generate(p, 0, 1, "fconst_0"); + } + if(f == 1.0) + { + jvm_generate(p, 0, 1, "fconst_1"); + } + if(f == 2.0) + { + jvm_generate(p, 0, 1, "fconst_2"); + } + else + { + jvm_generate(p, 0, 1, "ldc %lf", f); + } + } + else + { + if(f == 0.0) + { + jvm_generate(p, 0, 2, "dconst_0"); + } + if(f == 1.0) + { + jvm_generate(p, 0, 2, "dconst_1"); + } + else + { + jvm_generate(p, 0, 2, "ldc2_w %lf", f); + } + } +} + +static void +jvm_generate_push_string(gen_proc_t * p, char * str, int char_size) { - ctx -> gen_context = NULL; + assert(char_size == 1); + int len = strlen(str); + + jvm_generate_push_int(p, len + 1); + jvm_generate(p, 1, 1, "newarray byte"); + + for(int i = 0; i < len; i++) + { + jvm_generate(p, 1, 2, "dup"); + jvm_generate_push_int(p, i); + jvm_generate_push_int(p, str[i]); + jvm_generate(p, 3, 0, "bastore"); + } } -static char * get_class_full_name(oberon_context_t * ctx, oberon_type_t * type); +static gen_var_t * +oberon_generator_new_var() +{ + gen_var_t * v = GC_MALLOC(sizeof *v); + memset(v, 0, sizeof *v); + return v; +} + +static void +jvm_generate_and_init_global_var(gen_var_t * v, struct gen_class * class, char * access, char * name, char * desc) +{ + assert(class -> p == NULL); + fprintf(class -> fp, ".field %s static %s %s\n\n", access, name, desc); + + v -> storage = JVM_STORAGE_STATIC; + v -> full_name = new_string("%s/%s", class -> full_name, name); + v -> desc = new_string(desc); +} + +static void +jvm_generate_and_init_field(gen_var_t * v, struct gen_class * class, char * access, char * name, char * desc) +{ + assert(class -> p == NULL); + fprintf(class -> fp, ".field %s %s %s\n\n", access, name, desc); + + v -> storage = JVM_STORAGE_FIELD; + v -> full_name = new_string("%s/%s", class -> full_name, name); + v -> desc = new_string(desc); +} + +static void +jvm_generate_and_init_local_var(gen_var_t * v, gen_proc_t * p, bool wide) +{ + v -> storage = JVM_STORAGE_REGISTER; + v -> reg = jvm_alloc_register_untyped(p -> rf, wide); +} + +static void +jvm_generate_and_init_named_local_var(gen_var_t * v, gen_proc_t * p, bool wide, char * name, char * desc) +{ + jvm_generate_and_init_local_var(v, p, wide); + v -> desc = new_string(desc); + jvm_generate(p, 0, 0, ".var %i is %s %s from start to end", v -> reg, name, desc); +} + +static int +jvm_new_label_id(gen_proc_t * p) +{ + int label_id = p -> label_id; + p -> label_id += 1; + return label_id; +} static char * -get_descriptor(oberon_context_t * ctx, oberon_type_t * type) +jvm_get_label_name(int label_id) { - char * desc; + return new_string("L%i", label_id); +} - switch(type -> class) +static void +jvm_generate_label(gen_proc_t * p, int label_id) +{ + jvm_generate(p, 0, 0, "L%i:", label_id); +} + +static void +jvm_generate_load(gen_proc_t * p, oberon_type_t * src_type, gen_var_t * src) +{ + char prefix; + int cell_size; + + cell_size = jvm_cell_size_for_type(src_type); + + switch(src -> storage) { - case OBERON_TYPE_VOID: - return new_string("V"); - break; - case OBERON_TYPE_INTEGER: - switch(type -> size) - { - case 1: - return new_string("B"); - break; - case 2: - return new_string("S"); - break; - case 4: - return new_string("I"); - break; - case 8: - return new_string("J"); - break; - default: - oberon_error(ctx, "get_descriptor: unsupported int size %i", type -> size); - break; - } + case JVM_STORAGE_REGISTER: + prefix = jvm_get_prefix(src_type); + jvm_generate(p, 0, cell_size, "%cload %i", prefix, src -> reg); break; - case OBERON_TYPE_REAL: - switch(type -> size) - { - case 4: - return new_string("F"); - break; - case 8: - return new_string("D"); - break; - default: - oberon_error(ctx, "get_descriptor: unsupported float size %i", type -> size); - break; - } - break; - case OBERON_TYPE_BOOLEAN: - return new_string("Z"); + case JVM_STORAGE_STATIC: + jvm_generate(p, 0, cell_size, "getstatic %s %s", src -> full_name, src -> desc); break; - case OBERON_TYPE_POINTER: - return get_descriptor(ctx, type -> base); - break; - case OBERON_TYPE_PROCEDURE: - case OBERON_TYPE_RECORD: - desc = get_class_full_name(ctx, type); - return new_string("L%s;", desc); - break; - case OBERON_TYPE_ARRAY: - desc = get_descriptor(ctx, type -> base); - return new_string("[%s", desc); + case JVM_STORAGE_FIELD: + jvm_generate(p, 1, cell_size, "getfield %s %s", src -> full_name, src -> desc); break; default: - oberon_error(ctx, "print_descriptor: unsupported type class %i", type -> class); + gen_error("jvm_generate_load: unknow storage type %i", src -> storage); break; } - - return NULL; } -static char -get_prefix(oberon_context_t * ctx, oberon_type_t * type) +static void +jvm_generate_store(gen_proc_t * p, oberon_type_t * src_type, gen_var_t * dst) { - int size = type -> size; - switch(type -> class) + char prefix; + int cell_size; + + cell_size = jvm_cell_size_for_type(src_type); + + switch(dst -> storage) { - case OBERON_TYPE_BOOLEAN: - case OBERON_TYPE_INTEGER: - return (size <= 4) ? ('i') : ('l'); + case JVM_STORAGE_REGISTER: + prefix = jvm_get_prefix(src_type); + jvm_generate(p, cell_size, 0, "%cstore %i", prefix, dst -> reg); break; - case OBERON_TYPE_PROCEDURE: - case OBERON_TYPE_ARRAY: - case OBERON_TYPE_RECORD: - case OBERON_TYPE_POINTER: - return 'a'; + case JVM_STORAGE_STATIC: + jvm_generate(p, cell_size, 0, "putstatic %s %s", dst -> full_name, dst -> desc); break; - case OBERON_TYPE_REAL: - return (size <= 4) ? ('f') : ('d'); + case JVM_STORAGE_FIELD: + jvm_generate(p, 1 + cell_size, 0, "putfield %s %s", dst -> full_name, dst -> desc); + break; + default: + gen_error("jvm_generate_store: unknow storage type %i", dst -> storage); break; } - - oberon_error(ctx, "get_prefix: wat"); - return '!'; } -static char * -get_field_full_name(oberon_context_t * ctx, oberon_object_t * x) +static void +jvm_generate_new(gen_proc_t * p, oberon_type_t * type, int num); + +/* + * Генерирует код для инициализации массива со статическим базовым типом + * ( aref -- ) + */ + +static void +jvm_generate_array_initialization(gen_proc_t * p, oberon_type_t * arr) { - switch(x -> class) + int dim = 0; + oberon_type_t * base = arr; + while(base -> class == OBERON_TYPE_ARRAY) { - case OBERON_CLASS_VAR: - return new_string("%s/%s", x -> module -> name, x -> name); - case OBERON_CLASS_FIELD:; - char * rec_name = get_class_full_name(ctx, x -> parent_type); - return new_string("%s/%s", rec_name, x -> name); - case OBERON_CLASS_MODULE: - return new_string(x -> module -> name); - default: - oberon_error(ctx, "get_field_full_name: wat"); - break; + dim += 1; + base = base -> base; } - return NULL; + if(base -> class != OBERON_TYPE_RECORD) + { + jvm_generate(p, 1, 0, "pop"); + return; + } + + struct { + gen_var_t * index; + gen_var_t * length; + int start; + int end; + } loop[dim]; + + gen_var_t * dst = oberon_generator_new_var(); + jvm_generate_and_init_local_var(dst, p, false); + jvm_generate_store(p, arr, dst); + + /* + * Входящие параметры заграблены. + * Теперь генерируем эквивалентный код: + * int i = 0; + * int len = dst.length + * while(i < len) + * { + * ... + * { + * dst[i, ...] = new record; + * } + * ... + * i += 1; + * } + * Где "..." такой же код (начало и конец) для следующей размерности. + */ + + for(int i = 0; i < dim; i++) + { + loop[i].index = oberon_generator_new_var(); + loop[i].length = oberon_generator_new_var(); + loop[i].start = jvm_new_label_id(p); + loop[i].end = jvm_new_label_id(p); + jvm_generate_and_init_local_var(loop[i].index, p, false); + jvm_generate_and_init_local_var(loop[i].length, p, false); + + /* TODO преределать через jvm_generate_load{{store}} */ + + jvm_generate(p, 0, 1, "iconst_0"); + jvm_generate(p, 1, 0, "istore %i", loop[i].index -> reg); + + jvm_generate_load(p, arr, dst); + jvm_generate(p, 1, 1, "arraylength"); + jvm_generate(p, 1, 0, "istore %i", loop[i].length -> reg); + + /* if(i >= len) goto end; */ + jvm_generate_label(p, loop[i].start); + jvm_generate(p, 0, 1, "iload %i", loop[i].index -> reg); + jvm_generate(p, 0, 1, "iload %i", loop[i].length -> reg); + jvm_generate(p, 2, 0, "if_icmpge L%i", loop[i].end); + } + + jvm_generate_load(p, arr, dst); + jvm_generate(p, 0, 1, "iload %i", loop[0].index -> reg); + for(int i = 1; i < dim; i++) + { + jvm_generate(p, 2, 1, "aaload"); + jvm_generate(p, 0, 1, "iload %i", loop[i].index -> reg); + } + jvm_generate_new(p, base, 0); + jvm_generate(p, 3, 0, "aastore"); + + for(int i = dim - 1; i >= 0; i--) + { + jvm_generate(p, 0, 0, "iinc %i 1", loop[i].index -> reg); + jvm_generate(p, 0, 0, "goto L%i", loop[i].start); + jvm_generate_label(p, loop[i].end); + } } -static char * -get_class_full_name(oberon_context_t * ctx, oberon_type_t * type) +static void +jvm_generate_new(gen_proc_t * p, oberon_type_t * type, int num) { - int rec_id; - char * name = NULL; + int dim; + char * cname; + char * desc; + oberon_type_t * base; switch(type -> class) { + case OBERON_TYPE_INTEGER: + case OBERON_TYPE_BOOLEAN: case OBERON_TYPE_PROCEDURE: - name = new_string("SYSTEM$PROCEDURE"); - - char * desc; - desc = get_descriptor(ctx, type -> base); - name = new_string("%s$%s", name, desc); - - int num = type -> num_decl; - oberon_object_t * arg = type -> decl; - for(int i = 0; i < num; i++) + case OBERON_TYPE_REAL: + case OBERON_TYPE_POINTER: + gen_error("jvm_generate_new_static: static alocation not allowed"); + break; + case OBERON_TYPE_RECORD: + assert(num == 0); + cname = jvm_get_class_full_name(type); + jvm_generate(p, 0, 1, "new %s", cname); + jvm_generate(p, 1, 2, "dup"); + jvm_generate(p, 1, 0, "invokespecial %s/()V", cname); + break; + case OBERON_TYPE_ARRAY: + dim = 0; + base = type; + desc = jvm_get_descriptor(type); + while(base -> class == OBERON_TYPE_ARRAY) { - desc = get_descriptor(ctx, arg -> type); - name = new_string("%s%s", name, desc); - arg = arg -> next; + if(num > 0) + { + assert(base -> size == 0); + num -= 1; + } + else + { + assert(base -> size > 0); + jvm_generate_push_int(p, base -> size); + } + dim += 1; + base = base -> base; } - break; - case OBERON_TYPE_RECORD: - rec_id = type -> gen_type -> rec_id; - name = new_string("%s$RECORD%i", type -> module -> name, rec_id); + assert(num == 0); + jvm_generate(p, dim, 1, "multianewarray %s %i", desc, dim); + jvm_generate(p, 1, 2, "dup"); + jvm_generate_array_initialization(p, type); break; default: - oberon_error(ctx, "get_record_full_name: unk type class %i", type -> class); + gen_error("jvm_generate_new_static: unk type class %i", type -> class); break; } +} + +/* + * Генерирует код для копирования полей из первой записи во вторую. + * ( aref_dst aref_src -- ) + * dst := src; + */ - return name; +static void +jvm_generate_copy_record(gen_proc_t * p, oberon_type_t * rec) +{ + assert(rec -> class == OBERON_TYPE_RECORD); + char * desc = jvm_get_descriptor(rec); + char * cname = jvm_get_class_full_name(rec); + jvm_generate(p, 1 + 1, 0, "invokestatic %s/$COPY$(%s%s)V", cname, desc, desc); } -static char * -get_procedure_signature(oberon_context_t * ctx, oberon_type_t * proc) +/* + * Генерирует кода для копирования массивов. + * ( aref_dst aref_src -- ) + * dst := src; + */ + +static void +jvm_generate_copy_array(gen_proc_t * p, oberon_type_t * arr) { - char * signature; - char * desc; + int dim = 0; + oberon_type_t * base = arr; + while(base -> class == OBERON_TYPE_ARRAY) + { + dim += 1; + base = base -> base; + } - signature = new_string("("); + struct { + gen_var_t * index; + gen_var_t * length; + int start; + int end; + } loop[dim]; + + gen_var_t * dst = oberon_generator_new_var(); + gen_var_t * src = oberon_generator_new_var(); + jvm_generate_and_init_local_var(dst, p, false); + jvm_generate_and_init_local_var(src, p, false); + + jvm_generate_store(p, arr, src); + jvm_generate_store(p, arr, dst); + + /* + * Входящие параметры заграблены. + * Теперь генерируем эквивалентный код: + * int i = 0; + * int len = src.length + * while(i < len) + * { + * ... + * { + * copy from src[i, ...] to dst[i, ...]; + * } + * ... + * i += 1; + * } + * Где "..." такой же код (начало и конец) для следующей размерности. + */ + + for(int i = 0; i < dim; i++) + { + loop[i].index = oberon_generator_new_var(); + loop[i].length = oberon_generator_new_var(); + loop[i].start = jvm_new_label_id(p); + loop[i].end = jvm_new_label_id(p); + jvm_generate_and_init_local_var(loop[i].index, p, false); + jvm_generate_and_init_local_var(loop[i].length, p, false); + + /* TODO преределать через jvm_generate_load{{store}} */ + + jvm_generate(p, 0, 1, "iconst_0"); + jvm_generate(p, 1, 0, "istore %i", loop[i].index -> reg); + + jvm_generate_load(p, arr, src); + jvm_generate(p, 1, 1, "arraylength"); + jvm_generate(p, 1, 0, "istore %i", loop[i].length -> reg); + + /* if(i >= len) goto end; */ + jvm_generate_label(p, loop[i].start); + jvm_generate(p, 0, 1, "iload %i", loop[i].index -> reg); + jvm_generate(p, 0, 1, "iload %i", loop[i].length -> reg); + jvm_generate(p, 2, 0, "if_icmpge L%i", loop[i].end); + } - int num = proc -> num_decl; - oberon_object_t * arg = proc -> decl; - for(int i = 0; i < num; i++) + if(base -> class == OBERON_TYPE_RECORD) { - desc = get_descriptor(ctx, arg -> type); - signature = new_string("%s%s", signature, desc); - arg = arg -> next; + /* Получаем записи по индексам ( -- dst src ) */ + + jvm_generate_load(p, arr, dst); + for(int i = 0; i < dim; i++) + { + jvm_generate(p, 0, 1, "iload %i", loop[i].index -> reg); + jvm_generate(p, 2, 1, "aaload"); + } + + jvm_generate_load(p, arr, src); + for(int i = 0; i < dim; i++) + { + jvm_generate(p, 0, 1, "iload %i", loop[i].index -> reg); + jvm_generate(p, 2, 1, "aaload"); + } + + /* Копируем записи ( dst src -- ) */ + jvm_generate_copy_record(p, base); } + else + { + char postfix = jvm_get_postfix(base); + int cell_size = jvm_cell_size_for_postfix(postfix); + + /* Получаем массивы и индексы ( -- dst i src i ) */ + + jvm_generate_load(p, arr, dst); + jvm_generate(p, 0, 1, "iload %i", loop[0].index -> reg); + for(int i = 1; i < dim; i++) + { + jvm_generate(p, 2, 1, "aaload"); + jvm_generate(p, 0, 1, "iload %i", loop[i].index -> reg); + } + + jvm_generate_load(p, arr, src); + jvm_generate(p, 0, 1, "iload %i", loop[0].index -> reg); + for(int i = 1; i < dim; i++) + { + jvm_generate(p, 2, 1, "aaload"); + jvm_generate(p, 0, 1, "iload %i", loop[i].index -> reg); + } - desc = get_descriptor(ctx, proc -> base); - signature = new_string("%s)%s", signature, desc); + /* Копируем значения ( dst i src i -- ) */ + jvm_generate(p, 2, cell_size, "%caload", postfix); + jvm_generate(p, 2 + cell_size, 0, "%castore", postfix); + } - return signature; + for(int i = dim - 1; i >= 0; i--) + { + jvm_generate(p, 0, 0, "iinc %i 1", loop[i].index -> reg); + jvm_generate(p, 0, 0, "goto L%i", loop[i].start); + jvm_generate_label(p, loop[i].end); + } } static void -oberon_generate_procedure_class(oberon_context_t * ctx, oberon_type_t * proc) +jvm_generate_push_procedure_pointer(gen_proc_t * p, oberon_object_t * proc) +{ + char * full_name = jvm_get_field_full_name_safe(proc); + char * desc = jvm_get_descriptor(proc -> type); + jvm_generate(p, 0, 1, "getstatic %s/pointer %s", full_name, desc); +} + +// ========================================== +// ========================================== +// ========================================== + +static void +push_item(gen_proc_t * p, oberon_item_t * item); + +void +oberon_generator_init_context(oberon_context_t * ctx) +{ + gen_context_t * gen_context = GC_MALLOC(sizeof *gen_context); + memset(gen_context, 0, sizeof *gen_context); + + ctx -> gen_context = gen_context; +} + +void +oberon_generator_destroy_context(oberon_context_t * ctx) +{ +} + +static void +oberon_generate_procedure_class(oberon_type_t * proc) { FILE * fp; char * cname; - char * fname; char * signature; + struct gen_class * class; - cname = get_class_full_name(ctx, proc); - fname = new_string("%s.j", cname); - - fp = fopen(fname, "w"); + cname = jvm_get_class_full_name(proc); + class = jvm_create_class(cname); + fp = class -> fp; fprintf(fp, ".source SYSTEM\n"); fprintf(fp, ".class public abstract %s\n", cname); fprintf(fp, ".super java/lang/Object\n\n"); - signature = get_procedure_signature(ctx, proc); - - fprintf(fp, ".method public ()V\n"); + fprintf(fp, ".method ()V\n"); fprintf(fp, " aload_0\n"); fprintf(fp, " invokespecial java/lang/Object/()V\n"); fprintf(fp, " return\n"); fprintf(fp, ".end method\n\n"); + signature = jvm_get_procedure_signature(proc); + fprintf(fp, ".method public abstract invoke%s\n", signature); fprintf(fp, ".end method\n\n"); - fclose(fp); + jvm_destroy_class(class); } static void -oberon_generate_record_class(oberon_context_t * ctx, oberon_type_t * rec) +oberon_generate_procedure_pointer_class(oberon_object_t * proc) { FILE * fp; char * cname; - char * fname; + char * abscname; + char * absdesc; + char * signature; + struct gen_class * class; + + cname = jvm_get_field_full_name_safe(proc); + class = jvm_create_class(cname); + abscname = jvm_get_class_full_name(proc -> type); + absdesc = jvm_get_descriptor(proc -> type); + fp = class -> fp; + + fprintf(fp, ".source %s\n", proc -> module -> name); + fprintf(fp, ".class public %s\n", cname); + fprintf(fp, ".super %s\n\n", abscname); + + fprintf(fp, ".field public static pointer %s\n\n", absdesc); + + fprintf(fp, ".method ()V\n"); + fprintf(fp, " aload_0\n"); + fprintf(fp, " invokespecial %s/()V\n", abscname); + fprintf(fp, " return\n"); + fprintf(fp, ".end method\n\n"); + + fprintf(fp, ".method static ()V\n"); + fprintf(fp, " .limit stack 2\n"); + fprintf(fp, " new %s\n", cname); + fprintf(fp, " dup\n"); + fprintf(fp, " invokespecial %s/()V\n", cname); + fprintf(fp, " putstatic %s/pointer %s\n", cname, absdesc); + fprintf(fp, " return\n"); + fprintf(fp, ".end method\n\n"); + + signature = jvm_get_procedure_signature(proc -> type); + + gen_proc_t * p; + gen_var_t * this_v; + + p = jvm_create_proc(class); + jvm_generate_function_header(p, "public", "invoke", signature); + + this_v = oberon_generator_new_var(); + jvm_generate_and_init_local_var(this_v, p, false); + + gen_var_t * v; + int use_size = 0; + int num = proc -> type -> num_decl; + oberon_object_t * arg = proc -> type -> decl; + for(int i = 0; i < num; i++) + { + v = oberon_generator_new_var(); + bool wide = jvm_is_wide_type(arg -> type); + char * desc = jvm_get_descriptor(arg -> type); + jvm_generate_and_init_named_local_var(v, p, wide, arg -> name, desc); + + jvm_generate_load(p, arg -> type, v); + + use_size += (wide) ? (2) : (1); + + arg = arg -> next; + } + + char * full_name = jvm_get_field_full_name(proc); + int cell_size = jvm_cell_size_for_type(proc -> type -> base); + + jvm_generate(p, use_size, cell_size, "invokestatic %s%s", full_name, signature); + + if(proc -> type -> base -> class == OBERON_TYPE_VOID) + { + jvm_generate(p, 0, 0, "return"); + } + else + { + char prefix = jvm_get_prefix(proc -> type -> base); + jvm_generate(p, cell_size, 0, "%creturn", prefix); + } + + jvm_generate_function_end(p); + + jvm_destroy_class(class); +} + +static void +oberon_generate_record_class(gen_module_t * m, oberon_type_t * rec) +{ + char * cname; + struct gen_class * class; /* Устанавливаем новоый id */ - rec -> gen_type -> rec_id = rec -> module -> gen_mod -> rec_id; - rec -> module -> gen_mod -> rec_id += 1; + rec -> gen_type -> rec_id = m -> rec_id; + m -> rec_id += 1; - cname = get_class_full_name(ctx, rec); - fname = new_string("%s.j", cname); + cname = jvm_get_class_full_name(rec); + class = jvm_create_class(cname); - fp = fopen(fname, "w"); + fprintf(class -> fp, ".source %s\n", rec -> module -> name); + fprintf(class -> fp, ".class public %s\n", cname); - fprintf(fp, ".source %s\n", rec -> module -> name); - fprintf(fp, ".class public %s\n", cname); - fprintf(fp, ".super java/lang/Object\n\n"); + if(rec -> base == NULL) + { + fprintf(class -> fp, ".super java/lang/Object\n\n"); + } + else + { + class -> base = rec -> base -> gen_type -> class; + fprintf(class -> fp, ".super %s\n\n", class -> base -> full_name); + } - rec -> gen_type -> fp = fp; + rec -> gen_type -> class = class; } void @@ -289,42 +883,23 @@ oberon_generator_init_type(oberon_context_t * ctx, oberon_type_t * type) case OBERON_TYPE_BOOLEAN: case OBERON_TYPE_ARRAY: case OBERON_TYPE_REAL: + case OBERON_TYPE_CHAR: + case OBERON_TYPE_STRING: + case OBERON_TYPE_SET: break; case OBERON_TYPE_RECORD: - oberon_generate_record_class(ctx, type); + ; + gen_module_t * m; + m = type -> module -> gen_mod; + oberon_generate_record_class(m, type); break; case OBERON_TYPE_PROCEDURE: - oberon_generate_procedure_class(ctx, type); + oberon_generate_procedure_class(type); break; case OBERON_TYPE_POINTER: break; default: - oberon_error(ctx, "oberon_generator_init_type: unk calss %i", type -> class); - break; - } -} - -static void -oberon_generate_object(oberon_context_t * ctx, FILE * fp, oberon_object_t * x) -{ - char * name; - char * desc; - - name = x -> name; - desc = get_descriptor(ctx, x -> type); - switch(x -> class) - { - case OBERON_CLASS_VAR: - if(x -> local == 0) - { - fprintf(fp, ".field public static %s %s\n\n", name, desc); - } - break; - case OBERON_CLASS_FIELD: - fprintf(fp, ".field public %s %s\n\n", name, desc); - break; - default: - oberon_error(ctx, "oberon_generate_object: unk class %i", x -> class); + gen_error("oberon_generator_init_type: unk calss %i", type -> class); break; } } @@ -332,68 +907,168 @@ oberon_generate_object(oberon_context_t * ctx, FILE * fp, oberon_object_t * x) void oberon_generator_init_record(oberon_context_t * ctx, oberon_type_t * rec) { - FILE * fp; - - fp = rec -> gen_type -> fp; + struct gen_class * class; + class = rec -> gen_type -> class; int num = rec -> num_decl; oberon_object_t * field = rec -> decl; for(int i = 0; i < num; i++) { - oberon_generate_object(ctx, fp, field); + gen_var_t * v = field -> gen_var; + char * name = field -> name; + char * desc = jvm_get_descriptor(field -> type); + jvm_generate_and_init_field(v, class, "public", name, desc); field = field -> next; } - fprintf(fp, ".method public ()V\n"); - fprintf(fp, " aload_0\n"); - fprintf(fp, " invokespecial java/lang/Object/()V\n"); - fprintf(fp, " return\n"); - fprintf(fp, ".end method\n"); + /* Стандартный конструктор класса */ + /* Инициализирует внутренние статические записи и массивы */ + gen_proc_t * p = jvm_create_proc(class); + jvm_generate_function_header(p, "public", "", "()V"); + jvm_alloc_register_untyped(p -> rf, false); + jvm_generate(p, 0, 1, "aload_0"); + if(class -> base) + { + jvm_generate(p, 1, 0, "invokespecial %s/()V", class -> base -> full_name); + } + else + { + jvm_generate(p, 1, 0, "invokespecial java/lang/Object/()V"); + } + num = rec -> num_decl; + field = rec -> decl; + for(int i = 0; i < num; i++) + { + if(field -> type -> class == OBERON_TYPE_RECORD + || field -> type -> class == OBERON_TYPE_ARRAY) + { + jvm_generate(p, 0, 1, "aload_0"); + jvm_generate_new(p, field -> type, 0); + jvm_generate_store(p, field -> type, field -> gen_var); + } + field = field -> next; + } + jvm_generate(p, 0, 0, "return"); + jvm_generate_function_end(p); + + /* Метод для копирования полей класса */ + /* reg0 == src -> reg1 == dst */ + p = jvm_create_proc(class); + gen_var_t * copy_dst = oberon_generator_new_var(); + gen_var_t * copy_src = oberon_generator_new_var(); + char * desc = jvm_get_descriptor(rec); + char * signature = new_string("(%s%s)V", desc, desc); + jvm_generate_function_header(p, "public static", "$COPY$", signature); + jvm_generate_and_init_named_local_var(copy_dst, p, false, "dst", desc); + jvm_generate_and_init_named_local_var(copy_src, p, false, "src", desc); + num = rec -> num_decl; + field = rec -> decl; + for(int i = 0; i < num; i++) + { + if(field -> type -> class == OBERON_TYPE_RECORD) + { + jvm_generate_load(p, rec, copy_dst); + jvm_generate_load(p, field -> type, field -> gen_var); + jvm_generate_load(p, rec, copy_src); + jvm_generate_load(p, field -> type, field -> gen_var); + jvm_generate_copy_record(p, field -> type); + } + else if(field -> type -> class == OBERON_TYPE_ARRAY) + { + jvm_generate_load(p, rec, copy_dst); + jvm_generate_load(p, field -> type, field -> gen_var); + jvm_generate_load(p, rec, copy_src); + jvm_generate_load(p, field -> type, field -> gen_var); + jvm_generate_copy_array(p, field -> type); + } + else + { + jvm_generate_load(p, rec, copy_dst); + jvm_generate_load(p, rec, copy_src); + jvm_generate_load(p, field -> type, field -> gen_var); + jvm_generate_store(p, field -> type, field -> gen_var); + } + field = field -> next; + } + jvm_generate(p, 0, 0, "return"); + jvm_generate_function_end(p); - fclose(fp); + jvm_destroy_class(class); } void oberon_generator_init_var(oberon_context_t * ctx, oberon_object_t * var) { - gen_var_t * v = GC_MALLOC(sizeof *v); - memset(v, 0, sizeof *v); + gen_var_t * v = oberon_generator_new_var(); var -> gen_var = v; - gen_module_t * m = ctx -> mod -> gen_mod; + gen_module_t * m; + m = ctx -> mod -> gen_mod; + struct gen_class * class; + class = m -> class; + + char * desc; switch(var -> class) { case OBERON_CLASS_VAR_PARAM: - oberon_error(ctx, "generator: VAR-parameters not implemented"); + gen_error("generator: VAR-parameters not implemented"); break; case OBERON_CLASS_PARAM: + /* Заполняется при генерации функции */ + /* смотри jvm_init_local_object() */ + break; case OBERON_CLASS_FIELD: + /* Заполняются при инициализации структуры */ + /* смотри oberon_generator_init_record() */ break; case OBERON_CLASS_VAR: - oberon_generate_object(ctx, m -> fp, var); + /* Локальные заполняются при генерации функции */ + /* смотри jvm_init_local_object() */ + if(var -> local == 0) + { + desc = jvm_get_descriptor(var -> type); + jvm_generate_and_init_global_var(v, class, "public", var -> name, desc); + } break; default: - oberon_error(ctx, "oberon_generator_init_var: unk var class %i", var -> class); + gen_error("oberon_generator_init_var: unk var class %i", var -> class); break; } } void -oberon_generator_init_proc(oberon_context_t * ctx, oberon_object_t * proc) +oberon_generator_init_temp_var(oberon_context_t * ctx, oberon_object_t * var) { - gen_proc_t * p = GC_MALLOC(sizeof *p); - memset(p, 0, sizeof *p); - proc -> gen_proc = p; + assert(var -> class == OBERON_CLASS_VAR); - struct gen_register_file * rf = GC_MALLOC(sizeof *rf); - memset(rf, 0, sizeof *rf); - p -> rf = rf; + gen_var_t * v = oberon_generator_new_var(); + var -> gen_var = v; + + gen_module_t * m; + m = ctx -> mod -> gen_mod; + + gen_proc_t * p; + p = m -> class -> p; + + bool wide; + wide = jvm_is_wide_type(var -> type); + + jvm_generate_and_init_local_var(v, p, wide); +} + +void +oberon_generator_init_proc(oberon_context_t * ctx, oberon_object_t * proc) +{ + struct gen_class * class = proc -> module -> gen_mod -> class; + proc -> gen_proc = jvm_create_proc(class); if(proc -> local) { - oberon_error(ctx, "generator: local procedures not implemented"); + gen_error("generator: local procedures not implemented"); } + + oberon_generate_procedure_pointer_class(proc); } void @@ -403,566 +1078,591 @@ oberon_generator_init_module(oberon_context_t * ctx, oberon_module_t * mod) memset(m, 0, sizeof *m); mod -> gen_mod = m; - int fnamesz = strlen(mod -> name) + 3; - char fname[fnamesz + 1]; - snprintf(fname, fnamesz, "%s.j", mod -> name); + struct gen_class * class; + class = jvm_create_class(mod -> name); - FILE * fp; - fp = fopen(fname, "w"); - assert(fp != NULL); + fprintf(class -> fp, ".source %s\n", mod -> name); + fprintf(class -> fp, ".class %s\n", mod -> name); + fprintf(class -> fp, ".super java/lang/Object\n\n"); - fprintf(fp, ".source %s\n", mod -> name); - fprintf(fp, ".class %s\n", mod -> name); - fprintf(fp, ".super java/lang/Object\n\n"); + m -> class = class; - m -> fp = fp; + ctx -> gen_context -> current_m = m; } -// ======================================================================= -// GENERATOR -// ======================================================================= - -static void -push_expr(oberon_context_t * ctx, FILE * fp, oberon_expr_t * expr); - void -oberon_generate_begin_module(oberon_context_t * ctx) +oberon_generator_fini_module(oberon_module_t * mod) { - gen_module_t * m = ctx -> mod -> gen_mod; - fprintf(m -> fp, ".method public ()V\n"); - fprintf(m -> fp, " aload_0\n"); - fprintf(m -> fp, " invokespecial java/lang/Object/()V\n"); + jvm_destroy_class(mod -> gen_mod -> class); } +static void +push_expr(gen_proc_t * p, oberon_expr_t * expr); + void -oberon_generate_end_module(oberon_context_t * ctx) +oberon_generate_begin_module(oberon_context_t * ctx) { - gen_module_t * m = ctx -> mod -> gen_mod; + struct gen_class * class = ctx -> mod -> gen_mod -> class; + gen_proc_t * p = jvm_create_proc(class); - fprintf(m -> fp, " .limit stack 32\n"); - fprintf(m -> fp, " .limit locals 32\n"); - fprintf(m -> fp, " return\n"); - fprintf(m -> fp, ".end method\n"); -} + jvm_generate_function_header(p, "public", "", "()V"); + jvm_alloc_register_untyped(p -> rf, false); + jvm_generate(p, 0, 1, "aload_0"); + jvm_generate(p, 1, 0, "invokespecial java/lang/Object/()V"); -static int -jvm_cell_size_for_type(oberon_type_t * type) -{ - if(type -> class == OBERON_TYPE_INTEGER - || type -> class == OBERON_TYPE_REAL) + /* Инициализация переменных объявленных в модуле */ + oberon_object_t * x = ctx -> mod -> decl -> list -> next; + while(x != NULL) { - if(type -> size > 4) + if(x -> class == OBERON_CLASS_VAR) { - return 2; + if(x -> type -> class == OBERON_TYPE_ARRAY + || x -> type -> class == OBERON_TYPE_RECORD) + { + jvm_generate_new(p, x -> type, 0); + jvm_generate_store(p, x -> type, x -> gen_var); + } } - } - - return 1; -} - -static bool -jvm_is_wide_type(oberon_type_t * type) -{ - int cell; - cell = jvm_cell_size_for_type(type); - assert(cell <= 2); - return (cell == 2); -} - -static bool -jvm_is_free_register(struct gen_register_file * rf, int i, bool wide) -{ - if(wide) - { - assert(i + 1 < MAX_REGISTERS); - return !(rf -> reg[i].used || rf -> reg[i + 1].used); - } - else - { - assert(i < MAX_REGISTERS); - return !(rf -> reg[i].used); - } -} - -static int -jvm_alloc_register(struct gen_register_file * rf, oberon_type_t * type) -{ - bool wide; - wide = jvm_is_wide_type(type); - - int i = 0; - while(i < MAX_REGISTERS && !jvm_is_free_register(rf, i, wide)) - { - i += 1; - } - - if(wide) - { - assert(i + 1 <= MAX_REGISTERS); - rf -> num_used += 2; - rf -> reg[i].used = true; - rf -> reg[i + 1].used = true; - rf -> reg[i].used = true; - rf -> reg[i + 1].wide = false; - } - else - { - assert(i <= MAX_REGISTERS); - rf -> num_used += 1; - rf -> reg[i].used = true; - rf -> reg[i].wide = false; - } - if(rf -> num_used > rf -> max_used) - { - rf -> max_used = rf -> num_used; + x = x -> next; } +} + +void +oberon_generate_end_module(oberon_context_t * ctx) +{ + struct gen_class * class = ctx -> mod -> gen_mod -> class; + gen_proc_t * p = class -> p; - return i; + jvm_generate(p, 0, 0, "return"); + jvm_generate_function_end(class -> p); } static void -jvm_init_local_object(oberon_context_t * ctx, FILE * fp, oberon_object_t * x) +jvm_init_local_object(gen_proc_t * p, oberon_object_t * x) { - int reg; - gen_context_t * c; gen_var_t * v; + bool wide; char * desc; + struct gen_class * class; - c = ctx -> gen_context; v = x -> gen_var; - desc = get_descriptor(ctx, x -> type); + class = p -> class; + wide = jvm_is_wide_type(x -> type); + desc = jvm_get_descriptor(x -> type); + + // Убеждаемся что сейчас находимся в функции + assert(class -> p); + assert(x -> local); - reg = -1; switch(x -> class) { case OBERON_CLASS_VAR: case OBERON_CLASS_PARAM: - if(x -> local) - { - reg = jvm_alloc_register(c -> rf, x -> type); - } - v -> reg = reg; - fprintf(fp, ".var %i is %s %s from start to end\n", reg, x -> name, desc); + jvm_generate_and_init_named_local_var(v, p, wide, x -> name, desc); break; default: - oberon_error(ctx, "jvm_init_local_object: wat"); + gen_error("jvm_init_local_object: wat"); break; } } +/* + * Генерирует код для получения размера измерения массива + * Аналог Обероновского LEN(v, n); где n = 0 - первое измерение. + * ( aref -- int ) + */ + +static void +jvm_generate_array_len(gen_proc_t * p, int dim) +{ + while(dim > 0) + { + jvm_generate(p, 0, 1, "iconst_0"); + jvm_generate(p, 2, 1, "aaload"); + dim -= 1; + } + jvm_generate(p, 1, 1, "arraylength"); +} + +static void +jvm_generate_array_duplicate_and_replace(gen_proc_t * p, gen_var_t * v, oberon_type_t * arr) +{ + int dim = 0; + oberon_type_t * base = arr; + while(base -> class == OBERON_TYPE_ARRAY) + { + if(base -> size == 0) + { + jvm_generate_load(p, arr, v); + jvm_generate_array_len(p, dim); + dim += 1; + } + base = base -> base; + } + + jvm_generate_new(p, arr, dim); + jvm_generate(p, 1, 2, "dup"); + jvm_generate_load(p, arr, v); + jvm_generate_copy_array(p, arr); + jvm_generate_store(p, arr, v); +} + +static void +jvm_generate_record_duplicate_and_replace(gen_proc_t * p, gen_var_t * v, oberon_type_t * rec) +{ + jvm_generate_new(p, rec, 0); + jvm_generate(p, 1, 2, "dup"); + jvm_generate_load(p, rec, v); + jvm_generate_copy_record(p, rec); + jvm_generate_store(p, rec, v); +} + void oberon_generate_begin_proc(oberon_context_t * ctx, oberon_object_t * proc) { - gen_context_t * c; - gen_module_t * m; gen_proc_t * p; char * signature; - c = ctx -> gen_context; - m = ctx -> mod -> gen_mod; p = proc -> gen_proc; - signature = get_procedure_signature(ctx, proc -> type); - fprintf(m -> fp, ".method public static %s%s\n", proc -> name, signature); - - /* Сохраняем регистровый файл в стеке */ - p -> rf -> up = c -> rf; - c -> rf = p -> rf; + signature = jvm_get_procedure_signature(proc -> type); + jvm_generate_function_header(p, "public static", proc -> name, signature); + /* Выделение регистров под параметры и переменные */ oberon_object_t * var = proc -> type -> decl; while(var) { - jvm_init_local_object(ctx, m -> fp, var); + jvm_init_local_object(p, var); var = var -> next; } - fprintf(m -> fp, "start:\n"); + /* Копирование статических/открытых массивов и записей */ + var = proc -> type -> decl; + while(var) + { + if(var -> class == OBERON_CLASS_PARAM || var -> class == OBERON_CLASS_VAR_PARAM) + { + if(var -> type -> class == OBERON_TYPE_ARRAY) + { + jvm_generate_array_duplicate_and_replace(p, var -> gen_var, var -> type); + } + else if(var -> type -> class == OBERON_TYPE_RECORD) + { + jvm_generate_record_duplicate_and_replace(p, var -> gen_var, var -> type); + } + } + var = var -> next; + } } void oberon_generate_end_proc(oberon_context_t * ctx) { - gen_context_t * c; gen_module_t * m; + gen_proc_t * p; + + m = ctx -> mod -> gen_mod; + p = m -> class -> p; + + jvm_generate_function_end(p); +} + +gen_label_t * +oberon_generator_reserve_label(oberon_context_t * ctx) +{ + gen_module_t * m; + gen_proc_t * p; + gen_label_t * l; - c = ctx -> gen_context; m = ctx -> mod -> gen_mod; + p = m -> class -> p; - fprintf(m -> fp, "end:\n"); - fprintf(m -> fp, " .limit stack 32\n"); - fprintf(m -> fp, " .limit locals %i\n", c -> rf -> max_used); - fprintf(m -> fp, ".end method\n\n"); + l = GC_MALLOC(sizeof *l); + memset(l, 0, sizeof *l); - /* Возвращаем исходный регистровый файл */ - c -> rf = c -> rf -> up; + l -> id = jvm_new_label_id(p); + return l; } void -oberon_generate_call_proc(oberon_context_t * ctx, oberon_expr_t * desig) +oberon_generate_label(oberon_context_t * ctx, gen_label_t * l) { - oberon_object_t * proc; gen_module_t * m; - char * fullname; - char * signature; - - assert(desig -> is_item); - assert(desig -> item.mode == MODE_CALL); + gen_proc_t * p; m = ctx -> mod -> gen_mod; - proc = desig -> item.var; - fullname = get_field_full_name(ctx, proc); - signature = get_procedure_signature(ctx, proc -> type); + p = m -> class -> p; - int num = desig -> item.num_args; - oberon_expr_t * arg = desig -> item.args; - for(int i = 0; i < num; i++) - { - push_expr(ctx, m -> fp, arg); - arg = arg -> next; - } + jvm_generate_label(p, l -> id); +} + +void +oberon_generate_goto(oberon_context_t * ctx, gen_label_t * l) +{ + gen_module_t * m; + gen_proc_t * p; + + m = ctx -> mod -> gen_mod; + p = m -> class -> p; - fprintf(m -> fp, "invokestatic %s%s\n", fullname, signature); + jvm_generate(p, 0, 0, "goto L%i", l -> id); } void -oberon_generate_return(oberon_context_t * ctx, oberon_expr_t * expr) +oberon_generate_branch(oberon_context_t * ctx, oberon_expr_t * cond, bool gotoif, gen_label_t * l) { gen_module_t * m; - char prefix; + gen_proc_t * p; m = ctx -> mod -> gen_mod; + p = m -> class -> p; - if(expr) + push_expr(p, cond); + + if(gotoif == false) { - push_expr(ctx, m -> fp, expr); - prefix = get_prefix(ctx, expr -> result); - fprintf(m -> fp, " %creturn\n", prefix); + /* переход если false */ + jvm_generate(p, 1, 0, "ifeq L%i", l -> id); } else { - fprintf(m -> fp, " return\n"); + /* переход если true */ + jvm_generate(p, 1, 0, "ifne L%i", l -> id); } } static void -push_int(FILE * fp, long i) +jvm_generate_call_proc(gen_proc_t * p, oberon_item_t * desig) { - if(i == -1) - { - fprintf(fp, "iconst_m1\n"); - } - else if(i >= 0 && i <= 5) + assert(desig -> var == NULL); + assert(desig -> mode == MODE_CALL); + + char * signature = NULL; + + bool direct_call = false; + if(desig -> parent -> mode == MODE_VAR) { - fprintf(fp, "iconst_%li\n", i); + if(desig -> parent -> var -> class == OBERON_CLASS_PROC) + { + direct_call = true; + } } - else if(i >= -128 && i <= 127) + + printf("direct_call == %i\n", direct_call); + + oberon_type_t * procsig; + procsig = desig -> parent -> result; + signature = jvm_get_procedure_signature(procsig); + + if(direct_call == false) { - fprintf(fp, "bipush %li\n", i); + /* Загружаем указатель на процедуру */ + push_item(p, desig -> parent); } - else if(i >= -32768 && i <= 32767) + + int args_cells = 0; + int result_cells = jvm_cell_size_for_type(procsig -> base); + + int num = desig -> num_args; + oberon_expr_t * arg = desig -> args; + for(int i = 0; i < num; i++) { - fprintf(fp, "sipush %li\n", i); + args_cells += jvm_cell_size_for_type(arg -> result); + push_expr(p, arg); + arg = arg -> next; } - else if(i >= -2147483648 && i <= 2147483647) + + if(direct_call) { - fprintf(fp, "ldc %li\n", i); + char * full_name = jvm_get_field_full_name(desig -> parent -> var); + jvm_generate(p, args_cells, result_cells, "invokestatic %s%s", full_name, signature); } else { - fprintf(fp, "ldc2 %li\n", i); + char * cname = jvm_get_class_full_name(procsig); + jvm_generate(p, 1 + args_cells, result_cells, "invokevirtual %s/invoke%s", cname, signature); } } -static void -push_float(FILE * fp, double f, int size) +void +oberon_generate_call_proc(oberon_context_t * ctx, oberon_expr_t * desig) { - if(size <= 4) - { - if(f == 0.0) - { - fprintf(fp, "fconst_0\n"); - } - if(f == 1.0) - { - fprintf(fp, "fconst_1\n"); - } - if(f == 2.0) - { - fprintf(fp, "fconst_2\n"); - } - else - { - fprintf(fp, "ldc %lf\n", f); - } - } - else - { - if(f == 0.0) - { - fprintf(fp, "dconst_0\n"); - } - if(f == 1.0) - { - fprintf(fp, "dconst_1\n"); - } - else - { - fprintf(fp, "ldc2 %lf\n", f); - } - } + assert(desig -> is_item); + jvm_generate_call_proc(ctx -> mod -> gen_mod -> class -> p, (oberon_item_t *) desig); } -static void -push_var(oberon_context_t * ctx, FILE * fp, oberon_object_t * var) +void +oberon_generate_return(oberon_context_t * ctx, oberon_expr_t * expr) { - if(var -> local) + gen_module_t * m; + gen_proc_t * p; + char prefix; + int cell_size; + + m = ctx -> mod -> gen_mod; + p = m -> class -> p; + + if(expr) { - int reg = var -> gen_var -> reg; - char prefix = get_prefix(ctx, var -> type); - fprintf(fp, "%cload %i\n", prefix, reg); + push_expr(p, expr); + prefix = jvm_get_prefix(expr -> result); + cell_size = jvm_cell_size_for_type(expr -> result); + jvm_generate(p, cell_size, 0, "%creturn", prefix); } else { - char * fullname = get_field_full_name(ctx, var); - char * desc = get_descriptor(ctx, var -> type); - fprintf(fp, "getstatic %s %s\n", fullname, desc); + jvm_generate(p, 0, 0, "return"); } } static void -jvm_generate_new_static(oberon_context_t * ctx, FILE * fp, oberon_type_t * type, int num, oberon_expr_t * arg) +jvm_generate_expr_new_pointer(gen_proc_t * p, oberon_type_t * type, int num, oberon_expr_t * arg) { - //char * desc; - char * cname; - //desc = get_descriptor(ctx, type); - cname = get_class_full_name(ctx, type); + assert(type -> class == OBERON_TYPE_POINTER); - switch(type -> class) + for(int i = 0; i < num; i++) { - case OBERON_TYPE_INTEGER: - case OBERON_TYPE_BOOLEAN: - case OBERON_TYPE_PROCEDURE: - case OBERON_TYPE_REAL: - case OBERON_TYPE_POINTER: - /* ничего не генерируем */ - break; - case OBERON_TYPE_RECORD: - fprintf(fp, "new %s\n", cname); - fprintf(fp, "dup\n"); - fprintf(fp, "invokespecial %s/()V\n", cname); - break; - case OBERON_TYPE_ARRAY: - oberon_error(ctx, "jvm_generate_new_static: TODO array"); - break; - default: - oberon_error(ctx, "jvm_generate_new_static: unk type class %i", type -> class); - break; + push_expr(p, arg); + arg = arg -> next; } + + jvm_generate_new(p, type -> base, num); } static void -jvm_generate_new_pointer(oberon_context_t * ctx, FILE * fp, oberon_type_t * type, int num, oberon_expr_t * arg) +jvm_generate_cast_type(gen_proc_t * p, oberon_type_t * from, oberon_type_t * to) { - assert(type -> class == OBERON_TYPE_POINTER); - jvm_generate_new_static(ctx, fp, type -> base, num, arg); + if(to -> class == OBERON_TYPE_RECORD || to -> class == OBERON_TYPE_POINTER) + { + 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); + int from_cell_size = jvm_cell_size_for_type(from); + int to_cell_size = jvm_cell_size_for_type(to); + + jvm_generate_comment(p, "cast type class from %i(%i) to %i(%i)", from -> class, from -> size, to -> class, to -> size); + + if(prefix == postfix) + { + return; + } + + jvm_generate(p, from_cell_size, to_cell_size, "%c2%c", prefix, postfix); + } } static void -push_item(oberon_context_t * ctx, FILE * fp, oberon_item_t * item) +push_item(gen_proc_t * p, oberon_item_t * item) { switch(item -> mode) { case MODE_VAR: - push_var(ctx, fp, item -> var); + if(item -> var -> class == OBERON_CLASS_PROC) + { + jvm_generate_push_procedure_pointer(p, item -> var); + } + else + { + jvm_generate_load(p, item -> result, item -> var -> gen_var); + } break; case MODE_INTEGER: - push_int(fp, item -> integer); + case MODE_CHAR: + case MODE_SET: + jvm_generate_push_int_size(p, item -> integer, item -> result -> size); break; case MODE_BOOLEAN: - push_int(fp, item -> boolean); + jvm_generate_push_int_size(p, item -> boolean, item -> result -> size); break; case MODE_CALL: - oberon_generate_call_proc(ctx, (oberon_expr_t *) item); + jvm_generate_call_proc(p, item); break; case MODE_INDEX: - oberon_error(ctx, "push_item: TODO index"); + ; + char postfix = jvm_get_postfix(item -> result); + int cell_size = jvm_cell_size_for_postfix(postfix); + assert(item -> parent -> is_item); + push_item(p, (oberon_item_t *) item -> parent); + push_expr(p, item -> args); + jvm_generate(p, 1 + 1, cell_size, "%caload", postfix); break; case MODE_FIELD: - push_item(ctx, fp, item -> parent); - char * field = get_field_full_name(ctx, item -> var); - char * desc = get_descriptor(ctx, item -> var -> type); - fprintf(fp, "getfield %s %s\n", field, desc); + assert(item -> parent -> is_item); + push_item(p, (oberon_item_t *) item -> parent); + jvm_generate_load(p, item -> result, item -> var -> gen_var); break; case MODE_DEREF: - /* Все объекты представляются как увказатели */ - push_item(ctx, fp, item -> parent); + /* Все объекты в jvm представляются как указатели */ + assert(item -> parent -> is_item); + push_item(p, (oberon_item_t *) item -> parent); break; case MODE_NIL: - fprintf(fp, "aconst_null\n"); + jvm_generate(p, 0, 1, "aconst_null"); break; case MODE_NEW: - jvm_generate_new_pointer(ctx, fp, item -> result, item -> num_args, item -> args); + jvm_generate_expr_new_pointer(p, item -> result, item -> num_args, item -> args); break; case MODE_REAL: - push_float(fp, item -> real, item -> result -> size); + jvm_generate_push_float(p, item -> real, item -> result -> size); + break; + case MODE_STRING: + jvm_generate_push_string(p, item -> string, item -> result -> size); break; default: - oberon_error(ctx, "push_item: unk mode %i", item -> mode); + gen_error("push_item: unk mode %i", item -> mode); break; } } -static int -jvm_new_label_id(oberon_context_t * ctx) -{ - gen_context_t * c = ctx -> gen_context; - int label_id = c -> label_id; - c -> label_id += 1; - return label_id; -} - -static char * -jvm_get_label_name(int label_id) -{ - return new_string("L%i", label_id); -} - -static void -jvm_generate_label(FILE * fp, int label_id) -{ - fprintf(fp, "L%i:\n", label_id); -} - static void -jvm_generate_logical_not(oberon_context_t * ctx, FILE * fp) +jvm_generate_logical_not(gen_proc_t * p) { - int label_true = jvm_new_label_id(ctx); - int label_false = jvm_new_label_id(ctx); - char * label_name_true = jvm_get_label_name(label_true); + int label_done = jvm_new_label_id(p); + int label_false = jvm_new_label_id(p); + char * label_name_done = jvm_get_label_name(label_done); char * label_name_false = jvm_get_label_name(label_false); - fprintf(fp, "ifne %s\n", label_name_false); - fprintf(fp, "iconst_1\n"); - fprintf(fp, "goto %s\n", label_name_true); - jvm_generate_label(fp, label_false); - fprintf(fp, "iconst_0\n"); - jvm_generate_label(fp, label_true); -} - -static char -jvm_get_type_of_prefix(char prefix) -{ - switch(prefix) - { - case 'b': - return 'B'; - case 'c': - return 'C'; - case 'd': - return 'D'; - case 'f': - return 'F'; - case 'i': - return 'I'; - case 'l': - return 'J'; - } - - assert(0); + jvm_generate(p, 1, 0, "ifne %s", label_name_false); + jvm_generate(p, 0, 1, "iconst_1"); + jvm_generate(p, 0, 0, "goto %s", label_name_done); + jvm_generate_label(p, label_false); + jvm_generate(p, 0, 1, "iconst_0"); + jvm_generate_label(p, label_done); } static void -jvm_generate_abs(FILE * fp, char prefix) +jvm_generate_abs(gen_proc_t * p, char prefix) { char t = jvm_get_type_of_prefix(prefix); - fprintf(fp, "invokestatic java/lang/Math/abs(%c)%c\n", t, t); + int cell_size = jvm_cell_size_for_postfix(prefix); + jvm_generate(p, cell_size, cell_size, "invokestatic java/lang/Math/abs(%c)%c", t, t); } -static void -jvm_generate_compare_op(oberon_context_t * ctx, FILE *fp, char prefix, int op) +static char * +jvm_get_compare_postfix(int op) { - int label_true = jvm_new_label_id(ctx); - int label_false = jvm_new_label_id(ctx); - char * label_name_true = jvm_get_label_name(label_true); - char * label_name_false = jvm_get_label_name(label_false); - - assert(prefix == 'i' || prefix == 'a'); - + char * cmpop = ""; switch(op) { case OP_EQ: - fprintf(fp, "if_%ccmpeq %s\n", prefix, label_name_true); + cmpop = "eq"; break; case OP_NEQ: - fprintf(fp, "if_%ccmpne %s\n", prefix, label_name_true); + cmpop = "ne"; break; case OP_LSS: - fprintf(fp, "if_icmplt %s\n", label_name_true); + cmpop = "lt"; break; case OP_LEQ: - fprintf(fp, "if_icmple %s\n", label_name_true); + cmpop = "le"; break; case OP_GRT: - fprintf(fp, "if_icmpgt %s\n", label_name_true); + cmpop = "gt"; break; case OP_GEQ: - fprintf(fp, "if_icmpge %s\n", label_name_true); + cmpop = "ge"; break; default: - oberon_error(ctx, "jvm_generate_compare_op: wat"); + gen_error("jvm_generate_compare_op: wat"); break; } + return cmpop; +} + +static void +jvm_generate_compare_op(gen_proc_t * p, oberon_type_t * t, int op) +{ + char prefix = jvm_get_prefix(t); + int label_true = jvm_new_label_id(p); + int label_done = jvm_new_label_id(p); + int cell_size = jvm_cell_size_for_type(t); + char * cmpop = jvm_get_compare_postfix(op); + + if(prefix == 'l') + { + jvm_generate(p, 2 * cell_size, 1, "lcmp"); + jvm_generate(p, 1, 1, "if%s L%i", cmpop, label_true); + } + else if(prefix == 'f' || prefix == 'd') + { + char fop; + if(op == OP_EQ || op == OP_NEQ || op == OP_GRT || op == OP_GEQ) + { + fop = 'l'; + } + else + { + fop = 'g'; + } + jvm_generate(p, 2 * cell_size, 1, "%ccmp%c", prefix, fop); + jvm_generate(p, 1, 1, "if%s L%i", cmpop, label_true); + } + else + { + jvm_generate(p, 2 * cell_size, 0, "if_%ccmp%s L%i", prefix, cmpop, label_true); + } - fprintf(fp, "iconst_0\n"); - fprintf(fp, "goto %s\n", label_name_false); - jvm_generate_label(fp, label_true); - fprintf(fp, "iconst_1\n"); - jvm_generate_label(fp, label_false); + jvm_generate(p, 0, 1, "iconst_0"); + jvm_generate(p, 0, 0, "goto L%i", label_done); + jvm_generate_label(p, label_true); + jvm_generate(p, 0, 1, "iconst_1"); + jvm_generate_label(p, label_done); } static void -jvm_generate_operator(oberon_context_t * ctx, FILE *fp, char prefix, int op) +jvm_generate_operator(gen_proc_t * p, oberon_type_t * t, int op) { + char prefix = jvm_get_prefix(t); + int cell_size = jvm_cell_size_for_type(t); switch(op) { case OP_UNARY_MINUS: - fprintf(fp, "%cneg\n", prefix); + jvm_generate(p, cell_size, cell_size, "%cneg", prefix); break; - case OP_BITWISE_NOT: - push_int(fp, -1); - fprintf(fp, "%cxor\n", prefix); + case OP_COMPLEMENTATION: + jvm_generate_push_int_size(p, -1, t -> size); + jvm_generate(p, 2 * cell_size, cell_size, "%cxor", prefix); break; case OP_LOGIC_NOT: - jvm_generate_logical_not(ctx, fp); + jvm_generate_logical_not(p); break; case OP_ABS: - jvm_generate_abs(fp, prefix); + jvm_generate_abs(p, prefix); break; case OP_ADD: - fprintf(fp, "%cadd\n", prefix); + jvm_generate(p, 2 * cell_size, cell_size, "%cadd", prefix); break; case OP_SUB: - fprintf(fp, "%csub\n", prefix); + jvm_generate(p, 2 * cell_size, cell_size, "%csub", prefix); break; case OP_MUL: - fprintf(fp, "%cmul\n", prefix); + jvm_generate(p, 2 * cell_size, cell_size, "%cmul", prefix); break; case OP_DIV: - fprintf(fp, "%cdiv\n", prefix); + jvm_generate(p, 2 * cell_size, cell_size, "%cdiv", prefix); break; case OP_MOD: - fprintf(fp, "%crem\n", prefix); + jvm_generate(p, 2 * cell_size, cell_size, "%crem", prefix); break; - case OP_BITWISE_AND: - fprintf(fp, "%cand\n", prefix); + case OP_UNION: + jvm_generate(p, 2 * cell_size, cell_size, "%cor", prefix); break; - case OP_BITWISE_XOR: - fprintf(fp, "%cxor\n", prefix); + case OP_INTERSECTION: + jvm_generate(p, 2 * cell_size, cell_size, "%cand", prefix); break; - case OP_BITWISE_OR: - fprintf(fp, "%cor\n", prefix); + case OP_DIFFERENCE: + jvm_generate_push_int_size(p, -1, t -> size); + jvm_generate(p, 2 * cell_size, cell_size, "%cxor", prefix); + jvm_generate(p, 2 * cell_size, cell_size, "%cand", prefix); + break; + case OP_SYM_DIFFERENCE: + jvm_generate(p, 2 * cell_size, cell_size, "%cxor", prefix); break; case OP_EQ: @@ -971,65 +1671,158 @@ jvm_generate_operator(oberon_context_t * ctx, FILE *fp, char prefix, int op) case OP_LEQ: case OP_GRT: case OP_GEQ: - jvm_generate_compare_op(ctx, fp, prefix, op); + jvm_generate_compare_op(p, t, op); break; default: - oberon_error(ctx, "jvm_generate_operator: unk op %i", op); + gen_error("jvm_generate_operator: unk op %i", op); break; } } static void -jvm_generate_logical_or(oberon_context_t * ctx, FILE * fp, oberon_expr_t * p, oberon_expr_t * q) +jvm_generate_logical_or(gen_proc_t * p, oberon_expr_t * a, oberon_expr_t * b) { - int label_calc_q = jvm_new_label_id(ctx); - int label_done = jvm_new_label_id(ctx); - char * label_name_calc_q = jvm_get_label_name(label_calc_q); + int label_calc_b = jvm_new_label_id(p); + int label_done = jvm_new_label_id(p); + char * label_name_calc_b = jvm_get_label_name(label_calc_b); char * label_name_done = jvm_get_label_name(label_done); - /* p OR q -- если p, то TRUE, иначе q */ + /* a OR b -- если a, то TRUE, иначе b */ - push_expr(ctx, fp, p); - fprintf(fp, "ifne %s\n", label_name_calc_q); - fprintf(fp, "iconst_1\n"); - fprintf(fp, "goto %s\n", label_name_done); - jvm_generate_label(fp, label_calc_q); - push_expr(ctx, fp, q); - jvm_generate_label(fp, label_done); + push_expr(p, a); + jvm_generate(p, 1, 0, "ifeq %s", label_name_calc_b); + jvm_generate(p, 0, 1, "iconst_1"); + jvm_generate(p, 0, 0, "goto %s", label_name_done); + jvm_generate_label(p, label_calc_b); + push_expr(p, b); + jvm_generate_label(p, label_done); } static void -jvm_generate_logical_and(oberon_context_t * ctx, FILE * fp, oberon_expr_t * p, oberon_expr_t * q) +jvm_generate_logical_and(gen_proc_t * p, oberon_expr_t * a, oberon_expr_t * b) { - int label_false = jvm_new_label_id(ctx); - int label_done = jvm_new_label_id(ctx); + int label_false = jvm_new_label_id(p); + int label_done = jvm_new_label_id(p); char * label_name_false = jvm_get_label_name(label_false); char * label_name_done = jvm_get_label_name(label_done); - /* p AND q -- если p, то q, иначе FALSE */ + /* a AND b -- если a, то b, иначе FALSE */ + + push_expr(p, a); + jvm_generate(p, 1, 0, "ifeq %s", label_name_false); + push_expr(p, b); + jvm_generate(p, 0, 0, "goto %s", label_name_done); + jvm_generate_label(p, label_false); + jvm_generate(p, 0, 1, "iconst_0"); + jvm_generate_label(p, label_done); +} + +static void +jvm_generate_range(gen_proc_t * p, oberon_expr_t * a, oberon_expr_t * b) +{ + /* { a } == 1 << a */ + /* { a..b } == (a <= b) ? ((2 << b) - (1 << a)) : (0); */ + + char prefix; + int cell_size; + oberon_type_t * t; + gen_var_t * ra; + gen_var_t * rb; + int label_else; + int label_end; + bool wide; + + t = a -> result; + cell_size = jvm_cell_size_for_type(t); + prefix = jvm_get_prefix(t); + + if(b == NULL) + { + jvm_generate_push_int_size(p, 1, t -> size); + push_expr(p, a); + jvm_generate(p, 2 * cell_size, cell_size, "%cshl", prefix); + } + else + { + wide = jvm_is_wide_type(t); + ra = oberon_generator_new_var(); + rb = oberon_generator_new_var(); + jvm_generate_and_init_local_var(ra, p, wide); + jvm_generate_and_init_local_var(rb, p, wide); + label_else = jvm_new_label_id(p); + label_end = jvm_new_label_id(p); + + push_expr(p, a); + jvm_generate_store(p, t, ra); + push_expr(p, b); + jvm_generate_store(p, t, rb); + + jvm_generate_load(p, t, ra); + jvm_generate_load(p, t, rb); + jvm_generate(p, 2 * cell_size, 0, "if_%ccmpgt L%i", prefix, label_else); + + jvm_generate_push_int_size(p, 2, t -> size); + jvm_generate_load(p, t, rb); + jvm_generate(p, 2 * cell_size, cell_size, "%cshl", prefix); + jvm_generate_push_int_size(p, 2, t -> size); + jvm_generate_load(p, t, ra); + jvm_generate(p, 2 * cell_size, cell_size, "%cshl", prefix); + jvm_generate(p, 2 * cell_size, cell_size, "%csub", prefix); + jvm_generate(p, 0, 0, "goto L%i", label_end); + + jvm_generate_label(p, label_else); + jvm_generate_push_int_size(p, 0, t -> size); + jvm_generate_label(p, label_end); + } + + /* TODO free registers */ +} + +static void +jvm_generate_in(gen_proc_t * p, oberon_expr_t * a, oberon_expr_t * b) +{ + oberon_type_t * t = a -> result; + int cell_size = jvm_cell_size_for_type(t); + char prefix = jvm_get_prefix(t); + int label_else = jvm_new_label_id(p); + int label_end = jvm_new_label_id(p); + + jvm_generate_push_int_size(p, 1, t -> size); + push_expr(p, a); + jvm_generate(p, 2 * cell_size, cell_size, "%cshl", prefix); + push_expr(p, b); + jvm_generate(p, 2 * cell_size, cell_size, "%cand", prefix); + + if(cell_size > 1) + { + jvm_generate(p, cell_size, 0, "lcmp"); + } - push_expr(ctx, fp, p); - fprintf(fp, "ifne %s\n", label_name_false); - push_expr(ctx, fp, q); - fprintf(fp, "goto %s\n", label_name_done); - jvm_generate_label(fp, label_false); - fprintf(fp, "iconst_0\n"); - jvm_generate_label(fp, label_done); + jvm_generate(p, 1, 0, "ifeq L%i", label_else); + jvm_generate(p, 0, 1, "iconst_1"); + jvm_generate(p, 0, 0, "goto L%i", label_end); + jvm_generate_label(p, label_else); + jvm_generate(p, 0, 1, "iconst_0"); + jvm_generate_label(p, label_end); } static void -push_operator(oberon_context_t * ctx, FILE * fp, oberon_oper_t * oper) +push_operator(gen_proc_t * p, oberon_oper_t * oper) { - char prefix = get_prefix(ctx, oper -> result); + oberon_type_t * preq = oper -> left -> result; int op = oper -> op; switch(op) { + case OP_CAST: + push_expr(p, oper -> left); + jvm_generate_cast_type(p, oper -> left -> result, oper -> result); + break; + case OP_COMPLEMENTATION: case OP_UNARY_MINUS: - case OP_BITWISE_NOT: case OP_LOGIC_NOT: case OP_ABS: - push_expr(ctx, fp, oper -> left); - jvm_generate_operator(ctx, fp, prefix, op); + push_expr(p, oper -> left); + jvm_generate_operator(p, preq, op); break; case OP_ADD: @@ -1037,9 +1830,11 @@ push_operator(oberon_context_t * ctx, FILE * fp, oberon_oper_t * oper) case OP_MUL: case OP_DIV: case OP_MOD: - case OP_BITWISE_AND: - case OP_BITWISE_XOR: - case OP_BITWISE_OR: + + case OP_UNION: + case OP_INTERSECTION: + case OP_DIFFERENCE: + case OP_SYM_DIFFERENCE: case OP_EQ: case OP_NEQ: @@ -1047,77 +1842,93 @@ push_operator(oberon_context_t * ctx, FILE * fp, oberon_oper_t * oper) case OP_LEQ: case OP_GRT: case OP_GEQ: - push_expr(ctx, fp, oper -> left); - push_expr(ctx, fp, oper -> right); - jvm_generate_operator(ctx, fp, prefix, op); + push_expr(p, oper -> left); + push_expr(p, oper -> right); + jvm_generate_operator(p, preq, op); break; case OP_LOGIC_OR: - jvm_generate_logical_or(ctx, fp, oper -> left, oper -> right); + jvm_generate_logical_or(p, oper -> left, oper -> right); break; case OP_LOGIC_AND: - jvm_generate_logical_and(ctx, fp, oper -> left, oper -> right); + jvm_generate_logical_and(p, oper -> left, oper -> right); + break; + + case OP_IS: + preq = oper -> right -> result; + char * cname = jvm_get_class_full_name(preq); + push_expr(p, oper -> left); + jvm_generate(p, 1, 1, "instanceof %s", cname); + break; + case OP_RANGE: + jvm_generate_range(p, oper -> left, oper -> right); + break; + case OP_IN: + jvm_generate_in(p, oper -> left, oper -> right); break; default: - oberon_error(ctx, "push_oper: unk op %i", op); + gen_error("push_oper: unk op %i", op); break; } } static void -push_expr(oberon_context_t * ctx, FILE * fp, oberon_expr_t * expr) +push_expr(gen_proc_t * p, oberon_expr_t * expr) { if(expr -> is_item) { - push_item(ctx, fp, (oberon_item_t *) expr); + push_item(p, (oberon_item_t *) expr); } else { - push_operator(ctx, fp, (oberon_oper_t *) expr); + push_operator(p, (oberon_oper_t *) expr); } } static void -store_expr(oberon_context_t * ctx, FILE * fp, oberon_expr_t * dst, oberon_expr_t * src) +store_expr(gen_proc_t * p, oberon_expr_t * dst, oberon_expr_t * src) { assert(dst -> is_item); oberon_item_t * item = (oberon_item_t *) dst; - char prefix; - switch(item -> mode) + if(dst -> result -> class == OBERON_TYPE_ARRAY + || src -> result -> class == OBERON_TYPE_ARRAY) + { + push_expr(p, dst); + push_expr(p, src); + jvm_generate_copy_array(p, dst -> result); + } + else if(dst -> result -> class == OBERON_TYPE_RECORD + || src -> result -> class == OBERON_TYPE_RECORD) + { + push_expr(p, dst); + push_expr(p, src); + jvm_generate_copy_record(p, dst -> result); + } + else switch(item -> mode) { case MODE_VAR: - push_expr(ctx, fp, src); - if(item -> var -> local) - { - int reg = item -> var -> gen_var -> reg; - prefix = get_prefix(ctx, item -> result); - fprintf(fp, "%cstore %i\n", prefix, reg); - } - else - { - char * fullname = get_field_full_name(ctx, item -> var); - char * desc = get_descriptor(ctx, item -> result); - fprintf(fp, "putstatic %s %s\n", fullname, desc); - } + push_expr(p, src); + jvm_generate_store(p, src -> result, item -> var -> gen_var); break; case MODE_INDEX: - oberon_error(ctx, "store_expr: TODO index"); + ; + char postfix = jvm_get_postfix(src -> result); + int cell_size = jvm_cell_size_for_postfix(postfix); + assert(item -> parent -> is_item); + push_item(p, (oberon_item_t *) item -> parent); + push_expr(p, item -> args); + push_expr(p, src); + jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix); break; case MODE_FIELD: - { - char * fullname = get_field_full_name(ctx, item -> var); - char * desc = get_descriptor(ctx, item -> result); - printf("push parent\n"); - push_item(ctx, fp, item -> parent); - printf("push expr\n"); - push_expr(ctx, fp, src); - printf("store to field %s:%s\n", fullname, desc); - fprintf(fp, "putfield %s %s ; store field\n", fullname, desc); - } + assert(item -> parent -> is_item); + push_item(p, (oberon_item_t *) item -> parent); + push_expr(p, src); + jvm_generate_store(p, src -> result, item -> var -> gen_var); break; default: - oberon_error(ctx, "store_expr: unk mode %i", item -> mode); + gen_error("store_expr: unk mode %i", item -> mode); break; } } @@ -1126,9 +1937,12 @@ void oberon_generate_assign(oberon_context_t * ctx, oberon_expr_t * src, oberon_expr_t * dst) { gen_module_t * m; + gen_proc_t * p; + m = ctx -> mod -> gen_mod; + p = m -> class -> p; - store_expr(ctx, m -> fp, dst, src); + store_expr(p, dst, src); } void