JVM: Реализованы переменные-процедуры в генераторе

[dsw-obn.git] / src / backends / jvm / generator-jvm.c

diff --git a/src/backends/jvm/generator-jvm.c b/src/backends/jvm/generator-jvm.c
index dc79ea11cd0cbb656036a37d67d9a512c46517ae..f0768d8b69d5d9fda94829c343d116d44a2b0e7f 100644 (file)
--- a/src/backends/jvm/generator-jvm.c
+++ b/src/backends/jvm/generator-jvm.c
@@ -610,6 +610,14 @@ jvm_generate_copy_array(gen_proc_t * p, oberon_type_t * arr)
        }
 }
 
+static void
+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);
+}
+
 // ==========================================
 // ==========================================
 // ==========================================
@@ -644,7 +652,7 @@ oberon_generate_procedure_class(oberon_type_t * proc)
        fprintf(fp, ".class  public abstract %s\n", cname);
        fprintf(fp, ".super  java/lang/Object\n\n");
 
-       fprintf(fp, ".method public <init>()V\n");
+       fprintf(fp, ".method <init>()V\n");
        fprintf(fp, "  aload_0\n");
        fprintf(fp, "  invokespecial java/lang/Object/<init>()V\n");
        fprintf(fp, "  return\n");
@@ -658,6 +666,85 @@ oberon_generate_procedure_class(oberon_type_t * proc)
        jvm_destroy_class(class);
 }
 
+static void
+oberon_generate_procedure_pointer_class(oberon_object_t * proc)
+{
+       FILE * fp;
+       char * cname;
+       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 <init>()V\n");
+       fprintf(fp, "  aload_0\n");
+       fprintf(fp, "  invokespecial %s/<init>()V\n", abscname);
+       fprintf(fp, "  aload_0\n");
+       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)
 {
@@ -846,6 +933,8 @@ oberon_generator_init_proc(oberon_context_t * ctx, oberon_object_t * proc)
        {
                gen_error("generator: local procedures not implemented");
        }
+
+       oberon_generate_procedure_pointer_class(proc);
 }
 
 void
@@ -900,6 +989,13 @@ oberon_generate_begin_module(oberon_context_t * ctx)
                                jvm_generate_store(p, x -> type, x -> gen_var);
                        }
                }
+               else if(x -> class == OBERON_CLASS_PROC)
+               {
+                       char * cname = jvm_get_field_full_name_safe(x);
+                       jvm_generate(p, 0, 1, "new %s", cname);
+                       jvm_generate(p, 1, 0, "invokespecial %s/<init>()V", cname);
+               }
+
                x = x -> next;
        }
 }
@@ -1058,6 +1154,12 @@ jvm_generate_call_proc(gen_proc_t * p, oberon_expr_t * desig)
        fullname = jvm_get_field_full_name(proc);
        signature = jvm_get_procedure_signature(proc -> type);
 
+       if(proc -> class != OBERON_CLASS_PROC)
+       {
+               /* Загружаем указатель на процедуру */
+               jvm_generate_load(p, proc -> type, proc -> gen_var);
+       }
+
        int args_cells = 0;
        int result_cells = jvm_cell_size_for_type(proc -> type -> base);
 
@@ -1070,7 +1172,17 @@ jvm_generate_call_proc(gen_proc_t * p, oberon_expr_t * desig)
                arg = arg -> next;
        }
 
-       jvm_generate(p, args_cells, result_cells, "invokestatic %s%s", fullname, signature);
+       if(proc -> class == OBERON_CLASS_PROC)
+       {
+               /* Обычная статическая процедура */
+               jvm_generate(p, args_cells, result_cells, "invokestatic %s%s", fullname, signature);            
+       }
+       else
+       {
+               /* Процедура-переменная */
+               char * class = jvm_get_class_full_name(proc -> type);
+               jvm_generate(p, 1 + args_cells, result_cells, "invokevirtual %s/invoke%s", class, signature);
+       }
 }
 
 void
@@ -1123,7 +1235,14 @@ push_item(gen_proc_t * p, oberon_item_t * item)
        switch(item -> mode)
        {
                case MODE_VAR:
-                       jvm_generate_load(p, item -> result, item -> var -> gen_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:
                        jvm_generate_push_int(p, item -> integer);