index 8c9d69f61258fb91af3a443771b682692fb7d1ee..f111fd16eff755440676a4b6a6e433713cc43b4b 100644 (file)
}
else
{
- jvm_generate(p, 0, 2, "ldc2 %li", i);
+ jvm_generate(p, 0, 2, "ldc2_w %li", i);
}
}
else
{
pushed_cell = 2;
- jvm_generate(p, 0, 2, "ldc2 %li", i);
+ jvm_generate(p, 0, 2, "ldc2_w %li", i);
}
assert(size <= 8);
}
else
{
- jvm_generate(p, 0, 2, "ldc2 %lf", f);
+ jvm_generate(p, 0, 2, "ldc2_w %lf", f);
}
}
}
+static void
+jvm_generate_push_string(gen_proc_t * p, char * str, int char_size)
+{
+ 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 gen_var_t *
oberon_generator_new_var()
{
* Входящие параметры заграблены.
* Теперь генерируем эквивалентный код:
* int i = 0;
- * int len = dst.length
+ * int len = src.length
* while(i < len)
* {
* ...
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_load(p, arr, src);
jvm_generate(p, 1, 1, "arraylength");
jvm_generate(p, 1, 0, "istore %i", loop[i].length -> reg);
// ==========================================
// ==========================================
+static void
+push_item(gen_proc_t * p, oberon_item_t * item);
+
void
oberon_generator_init_context(oberon_context_t * ctx)
{
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, " return\n");
+ fprintf(fp, ".end method\n\n");
+
+ fprintf(fp, ".method static <clinit>()V\n");
+ fprintf(fp, " .limit stack 2\n");
+ fprintf(fp, " new %s\n", cname);
+ fprintf(fp, " dup\n");
+ fprintf(fp, " invokespecial %s/<init>()V\n", cname);
fprintf(fp, " putstatic %s/pointer %s\n", cname, absdesc);
fprintf(fp, " return\n");
fprintf(fp, ".end method\n\n");
case OBERON_TYPE_BOOLEAN:
case OBERON_TYPE_ARRAY:
case OBERON_TYPE_REAL:
+ case OBERON_TYPE_CHAR:
+ case OBERON_TYPE_STRING:
break;
case OBERON_TYPE_RECORD:
;
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;
}
}
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;
- if(proc -> class != OBERON_CLASS_PROC)
+ 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(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);
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
}
break;
case MODE_INTEGER:
+ case MODE_CHAR:
jvm_generate_push_int_size(p, item -> integer, item -> result -> size);
break;
case MODE_BOOLEAN:
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:
;
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);
+ case MODE_STRING:
+ jvm_generate_push_string(p, item -> string, item -> result -> size);
break;
default:
gen_error("push_item: unk mode %i", item -> mode);
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: