Теперь возможен вызов процедур-переменных из полей записей

[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 8c9d69f61258fb91af3a443771b682692fb7d1ee..d986a8e4cbc9af35a1fcf9361c531238c1de3fa8 100644 (file)
--- a/src/backends/jvm/generator-jvm.c
+++ b/src/backends/jvm/generator-jvm.c
@@ -166,7 +166,7 @@ jvm_generate_push_int(gen_proc_t * p, int64_t i)
        }
        else
        {
-               jvm_generate(p, 0, 2, "ldc2 %li", i);
+               jvm_generate(p, 0, 2, "ldc2_w %li", i);
        }
 }
 
@@ -198,7 +198,7 @@ jvm_generate_push_int_size(gen_proc_t * p, int64_t i, int size)
        else
        {
                pushed_cell = 2;
-               jvm_generate(p, 0, 2, "ldc2 %li", i);
+               jvm_generate(p, 0, 2, "ldc2_w %li", i);
        }
 
        assert(size <= 8);
@@ -258,7 +258,7 @@ jvm_generate_push_float(gen_proc_t * p, double f, int size)
                }
                else
                {
-                       jvm_generate(p, 0, 2, "ldc2 %lf", f);
+                       jvm_generate(p, 0, 2, "ldc2_w %lf", f);
                }
        }
 }
@@ -689,6 +689,9 @@ jvm_generate_push_procedure_pointer(gen_proc_t * p, oberon_object_t * proc)
 // ==========================================
 // ==========================================
 
+static void
+push_item(gen_proc_t * p, oberon_item_t * item);
+
 void
 oberon_generator_init_context(oberon_context_t * ctx)
 {
@@ -1224,30 +1227,39 @@ oberon_generate_end_proc(oberon_context_t * ctx)
 }
 
 static void
-jvm_generate_call_proc(gen_proc_t * p, oberon_expr_t * desig)
+jvm_generate_call_proc(gen_proc_t * p, oberon_item_t * desig)
 {
-       assert(desig -> is_item);
-       assert(desig -> item.mode == MODE_CALL);
-       
-       oberon_object_t * proc;
-       char * fullname;
-       char * signature;
+       assert(desig -> var == NULL);
+       assert(desig -> mode == MODE_CALL);
 
-       proc = desig -> item.var;
-       fullname = jvm_get_field_full_name(proc);
-       signature = jvm_get_procedure_signature(proc -> type);
+       char * signature = NULL;
+
+       bool direct_call = false;
+       if(desig -> parent -> mode == MODE_VAR)
+       {
+               if(desig -> parent -> var -> class == OBERON_CLASS_PROC)
+               {
+                       direct_call = true;
+               }
+       }
+
+       printf("direct_call == %i\n", direct_call);
+
+       oberon_type_t * procsig;
+       procsig = desig -> parent -> result;
+       signature = jvm_get_procedure_signature(procsig);
 
-       if(proc -> class != OBERON_CLASS_PROC)
+       if(direct_call == false)
        {
                /* Загружаем указатель на процедуру */
-               jvm_generate_load(p, proc -> type, proc -> gen_var);
+               push_item(p, desig -> parent);
        }
 
        int args_cells = 0;
-       int result_cells = jvm_cell_size_for_type(proc -> type -> base);
+       int result_cells = jvm_cell_size_for_type(procsig -> base);
 
-       int num = desig -> item.num_args;
-       oberon_expr_t * arg = desig -> item.args;
+       int num = desig -> num_args;
+       oberon_expr_t * arg = desig -> args;
        for(int i = 0; i < num; i++)
        {
                args_cells += jvm_cell_size_for_type(arg -> result);
@@ -1255,23 +1267,23 @@ jvm_generate_call_proc(gen_proc_t * p, oberon_expr_t * desig)
                arg = arg -> next;
        }
 
-       if(proc -> class == OBERON_CLASS_PROC)
+       if(direct_call)
        {
-               /* Обычная статическая процедура */
-               jvm_generate(p, args_cells, result_cells, "invokestatic %s%s", fullname, signature);            
+               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
        {
-               /* Процедура-переменная */
-               char * class = jvm_get_class_full_name(proc -> type);
-               jvm_generate(p, 1 + args_cells, result_cells, "invokevirtual %s/invoke%s", class, signature);
+               char * cname = jvm_get_class_full_name(procsig);
+               jvm_generate(p, 1 + args_cells, result_cells, "invokevirtual %s/invoke%s", cname, signature);
        }
 }
 
 void
 oberon_generate_call_proc(oberon_context_t * ctx, oberon_expr_t * desig)
 {
-       jvm_generate_call_proc(ctx -> mod -> gen_mod -> class -> p, desig);
+       assert(desig -> is_item);
+       jvm_generate_call_proc(ctx -> mod -> gen_mod -> class -> p, (oberon_item_t *) desig);
 }
 
 void
@@ -1360,7 +1372,7 @@ push_item(gen_proc_t * p, oberon_item_t * item)
                        jvm_generate_push_int_size(p, item -> boolean, item -> result -> size);
                        break;
                case MODE_CALL:
-                       jvm_generate_call_proc(p, (oberon_expr_t *) item);
+                       jvm_generate_call_proc(p, item);
                        break;
                case MODE_INDEX:
                        ;
@@ -1390,10 +1402,6 @@ push_item(gen_proc_t * p, oberon_item_t * item)
                case MODE_REAL:
                        jvm_generate_push_float(p, item -> real, item -> result -> size);
                        break;
-               case MODE_CAST:
-                       push_expr(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;
@@ -1573,6 +1581,10 @@ push_operator(gen_proc_t * p, oberon_oper_t * oper)
        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_UNARY_MINUS:
                case OP_BITWISE_NOT:
                case OP_LOGIC_NOT: