11 #include "../../oberon-internals.h"
12 #include "../../oberon-type-compat.h"
13 #include "../../generator.h"
14 #include "generator-jvm.h"
15 #include "generator-jvm-abi.h"
16 #include "generator-jvm-asm.h"
17 #include "generator-jvm-basic.h"
20 push_item(gen_proc_t
* p
, oberon_item_t
* item
);
23 jvm_generate_new(gen_proc_t
* p
, oberon_type_t
* type
, int num
);
26 jvm_generate_cast_prefix(gen_proc_t
* p
, char prefix
, char postfix
)
28 if((prefix
== 'b' || prefix
== 's') && (postfix
= 'l' || postfix
== 'd'))
38 if((prefix
== 'l' || prefix
== 'd') && (postfix
== 'b' || postfix
== 's'))
40 jvm_generate(p
, 2, 1, "%c2i", prefix
);
44 int from_cell_size
= jvm_cell_size_for_postfix(prefix
);
45 int to_cell_size
= jvm_cell_size_for_postfix(postfix
);
46 jvm_generate(p
, from_cell_size
, to_cell_size
, "%c2%c", prefix
, postfix
);
50 jvm_generate_cast_type(gen_proc_t
* p
, oberon_type_t
* from
, oberon_type_t
* to
)
52 if(to
-> class == OBERON_TYPE_RECORD
|| to
-> class == OBERON_TYPE_POINTER
)
54 if(to
-> class == OBERON_TYPE_POINTER
&& to
-> base
-> class == OBERON_TYPE_RECORD
)
56 char * full_name
= jvm_get_class_full_name(to
);
57 jvm_generate(p
, 1, 1, "checkcast %s", full_name
);
62 char prefix
= jvm_get_prefix(from
);
63 char postfix
= jvm_get_postfix(to
);
64 jvm_generate_cast_prefix(p
, prefix
, postfix
);
69 jvm_generate_hard_cast_type(gen_proc_t
* p
, oberon_type_t
* from
, oberon_type_t
* to
)
71 if(from
-> class == OBERON_TYPE_REAL
72 && (to
-> class == OBERON_TYPE_INTEGER
|| to
-> class == OBERON_TYPE_SYSTEM_BYTE
))
74 char postfix
= jvm_get_postfix(to
);
77 jvm_generate(p
, 1, 1, "invokestatic java/lang/Float/floatToRawIntBits(F)I");
78 jvm_generate_cast_prefix(p
, 'i', postfix
);
82 jvm_generate(p
, 2, 2, "invokestatic java/lang/Double/doubleToRawLongBits(D)J");
83 jvm_generate_cast_prefix(p
, 'l', postfix
);
86 else if((from
-> class == OBERON_TYPE_INTEGER
|| from
-> class == OBERON_TYPE_SYSTEM_BYTE
)
87 && to
-> class == OBERON_TYPE_REAL
)
89 char prefix
= jvm_get_prefix(from
);
92 jvm_generate_cast_prefix(p
, prefix
, 'i');
93 jvm_generate(p
, 1, 1, "invokestatic java/lang/Float/intBitsToFloat(I)F");
97 jvm_generate_cast_prefix(p
, prefix
, 'l');
98 jvm_generate(p
, 2, 2, "invokestatic java/lang/Double/longBitsToDouble(J)D");
103 jvm_generate_cast_type(p
, from
, to
);
108 check_index(gen_proc_t
* p
, oberon_type_t
* index_type
)
110 // TODO проверка валидности границ
111 char prefix
= jvm_get_prefix(index_type
);
112 jvm_generate_cast_prefix(p
, prefix
, 'i');
116 * Генерирует код для инициализации массива со статическим базовым типом
121 jvm_generate_array_initialization(gen_proc_t
* p
, oberon_type_t
* arr
)
124 oberon_type_t
* base
= arr
;
125 while(base
-> class == OBERON_TYPE_ARRAY
)
131 if(base
-> class != OBERON_TYPE_RECORD
)
133 jvm_generate(p
, 1, 0, "pop");
145 reg_dst
= jvm_alloc_register_untyped(p
-> rf
, false);
146 jvm_generate(p
, 1, 0, "astore %i", reg_dst
);
149 * Входящие параметры заграблены.
150 * Теперь генерируем эквивалентный код:
152 * int len = dst.length
157 * dst[i, ...] = new record;
162 * Где "..." такой же код (начало и конец) для следующей размерности.
165 for(int i
= 0; i
< dim
; i
++)
167 loop
[i
].reg_index
= jvm_alloc_register_untyped(p
-> rf
, false);
168 loop
[i
].reg_length
= jvm_alloc_register_untyped(p
-> rf
, false);
169 loop
[i
].start
= jvm_new_label_id(p
);
170 loop
[i
].end
= jvm_new_label_id(p
);
172 jvm_generate(p
, 0, 1, "iconst_0");
173 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_index
);
175 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
176 jvm_generate(p
, 1, 1, "arraylength");
177 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_length
);
179 /* if(i >= len) goto end; */
180 jvm_generate_label(p
, loop
[i
].start
);
181 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
182 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_length
);
183 jvm_generate(p
, 2, 0, "if_icmpge L%i", loop
[i
].end
);
186 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
187 jvm_generate(p
, 0, 1, "iload %i", loop
[0].reg_index
);
188 for(int i
= 1; i
< dim
; i
++)
190 jvm_generate(p
, 2, 1, "aaload");
191 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
193 jvm_generate_new(p
, base
, 0);
194 jvm_generate(p
, 3, 0, "aastore");
196 for(int i
= dim
- 1; i
>= 0; i
--)
198 jvm_generate(p
, 0, 0, "iinc %i 1", loop
[i
].reg_index
);
199 jvm_generate(p
, 0, 0, "goto L%i", loop
[i
].start
);
200 jvm_generate_label(p
, loop
[i
].end
);
205 jvm_generate_new(gen_proc_t
* p
, oberon_type_t
* type
, int num
)
210 oberon_type_t
* base
;
212 switch(type
-> class)
214 case OBERON_TYPE_INTEGER
:
215 case OBERON_TYPE_BOOLEAN
:
216 case OBERON_TYPE_PROCEDURE
:
217 case OBERON_TYPE_REAL
:
218 case OBERON_TYPE_POINTER
:
219 gen_error("jvm_generate_new_static: static alocation not allowed");
221 case OBERON_TYPE_RECORD
:
223 cname
= jvm_get_class_full_name(type
);
224 jvm_generate(p
, 0, 1, "new %s", cname
);
225 jvm_generate(p
, 1, 2, "dup");
226 jvm_generate(p
, 1, 0, "invokespecial %s/<init>()V", cname
);
228 case OBERON_TYPE_ARRAY
:
231 desc
= jvm_get_descriptor(type
);
232 while(base
-> class == OBERON_TYPE_ARRAY
)
236 assert(base
-> size
== 0);
241 assert(base
-> size
> 0);
242 jvm_generate_push_int(p
, base
-> size
);
249 jvm_generate(p
, dim
, 1, "multianewarray %s %i", desc
, dim
);
250 jvm_generate(p
, 1, 2, "dup");
251 jvm_generate_array_initialization(p
, type
);
254 gen_error("jvm_generate_new_static: unk type class %i", type
-> class);
260 * Генерирует код для копирования полей из первой записи во вторую.
261 * ( aref_dst aref_src -- )
266 jvm_generate_copy_record(gen_proc_t
* p
, oberon_type_t
* rec
)
268 assert(rec
-> class == OBERON_TYPE_RECORD
);
269 char * desc
= jvm_get_descriptor(rec
);
270 char * cname
= jvm_get_class_full_name(rec
);
271 jvm_generate(p
, 1 + 1, 0, "invokestatic %s/$COPY$(%s%s)V", cname
, desc
, desc
);
275 * Генерирует кода для копирования массивов.
276 * ( aref_dst aref_src -- )
281 jvm_generate_copy_array(gen_proc_t
* p
, oberon_type_t
* arr
)
284 oberon_type_t
* base
= arr
;
285 while(base
-> class == OBERON_TYPE_ARRAY
)
298 int reg_dst
= jvm_alloc_register_untyped(p
-> rf
, false);
299 int reg_src
= jvm_alloc_register_untyped(p
-> rf
, false);
300 jvm_generate(p
, 1, 0, "astore %i", reg_src
);
301 jvm_generate(p
, 1, 0, "astore %i", reg_dst
);
304 * Входящие параметры заграблены.
305 * Теперь генерируем эквивалентный код:
307 * int len = src.length
312 * copy from src[i, ...] to dst[i, ...];
317 * Где "..." такой же код (начало и конец) для следующей размерности.
320 for(int i
= 0; i
< dim
; i
++)
322 loop
[i
].reg_index
= jvm_alloc_register_untyped(p
-> rf
, false);
323 loop
[i
].reg_length
= jvm_alloc_register_untyped(p
-> rf
, false);
324 loop
[i
].start
= jvm_new_label_id(p
);
325 loop
[i
].end
= jvm_new_label_id(p
);
327 jvm_generate(p
, 0, 1, "iconst_0");
328 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_index
);
330 jvm_generate(p
, 0, 1, "aload %i", reg_src
);
331 jvm_generate(p
, 1, 1, "arraylength");
332 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_length
);
334 /* if(i >= len) goto end; */
335 jvm_generate_label(p
, loop
[i
].start
);
336 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
337 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_length
);
338 jvm_generate(p
, 2, 0, "if_icmpge L%i", loop
[i
].end
);
341 if(base
-> class == OBERON_TYPE_RECORD
)
343 /* Получаем записи по индексам ( -- dst src ) */
345 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
346 for(int i
= 0; i
< dim
; i
++)
348 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
349 jvm_generate(p
, 2, 1, "aaload");
352 jvm_generate(p
, 0, 1, "aload %i", reg_src
);
353 for(int i
= 0; i
< dim
; i
++)
355 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
356 jvm_generate(p
, 2, 1, "aaload");
359 /* Копируем записи ( dst src -- ) */
360 jvm_generate_copy_record(p
, base
);
364 char postfix
= jvm_get_postfix(base
);
365 int cell_size
= jvm_cell_size_for_postfix(postfix
);
367 /* Получаем массивы и индексы ( -- dst i src i ) */
369 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
370 jvm_generate(p
, 0, 1, "iload %i", loop
[0].reg_index
);
371 for(int i
= 1; i
< dim
; i
++)
373 jvm_generate(p
, 2, 1, "aaload");
374 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
377 jvm_generate(p
, 0, 1, "aload %i", reg_src
);
378 jvm_generate(p
, 0, 1, "iload %i", loop
[0].reg_index
);
379 for(int i
= 1; i
< dim
; i
++)
381 jvm_generate(p
, 2, 1, "aaload");
382 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
385 /* Копируем значения ( dst i src i -- ) */
386 jvm_generate(p
, 2, cell_size
, "%caload", postfix
);
387 jvm_generate(p
, 2 + cell_size
, 0, "%castore", postfix
);
390 for(int i
= dim
- 1; i
>= 0; i
--)
392 jvm_generate(p
, 0, 0, "iinc %i 1", loop
[i
].reg_index
);
393 jvm_generate(p
, 0, 0, "goto L%i", loop
[i
].start
);
394 jvm_generate_label(p
, loop
[i
].end
);
399 jvm_generate_push_procedure_pointer(gen_proc_t
* p
, oberon_object_t
* proc
)
401 char * full_name
= jvm_get_field_full_name_safe(proc
);
402 char * desc
= jvm_get_descriptor(proc
-> type
);
403 jvm_generate(p
, 0, 1, "getstatic %s/pointer %s", full_name
, desc
);
407 oberon_generator_init_context(oberon_context_t
* ctx
)
409 gen_context_t
* gen_context
= GC_MALLOC(sizeof *gen_context
);
410 memset(gen_context
, 0, sizeof *gen_context
);
412 ctx
-> gen_context
= gen_context
;
413 gen_context
-> dir
= ".";
417 oberon_generator_destroy_context(oberon_context_t
* ctx
)
422 oberon_generate_procedure_class(const char * dir
, oberon_type_t
* proc
)
427 struct gen_class
* class;
429 cname
= jvm_get_class_full_name(proc
);
430 class = jvm_create_class(dir
, cname
);
433 fprintf(fp
, ".source SYSTEM\n");
434 fprintf(fp
, ".class public abstract %s\n", cname
);
435 fprintf(fp
, ".super java/lang/Object\n\n");
437 fprintf(fp
, ".method <init>()V\n");
438 fprintf(fp
, " aload_0\n");
439 fprintf(fp
, " invokespecial java/lang/Object/<init>()V\n");
440 fprintf(fp
, " return\n");
441 fprintf(fp
, ".end method\n\n");
443 signature
= jvm_get_procedure_signature(proc
);
445 fprintf(fp
, ".method public abstract invoke%s\n", signature
);
446 fprintf(fp
, ".end method\n\n");
448 jvm_destroy_class(class);
452 oberon_generate_procedure_pointer_class(const char * dir
, oberon_object_t
* proc
)
459 struct gen_class
* class;
461 cname
= jvm_get_field_full_name_safe(proc
);
462 class = jvm_create_class(dir
, cname
);
463 abscname
= jvm_get_class_full_name(proc
-> type
);
464 absdesc
= jvm_get_descriptor(proc
-> type
);
467 fprintf(fp
, ".source %s\n", proc
-> module
-> name
);
468 fprintf(fp
, ".class public %s\n", cname
);
469 fprintf(fp
, ".super %s\n\n", abscname
);
471 fprintf(fp
, ".field public static pointer %s\n\n", absdesc
);
473 fprintf(fp
, ".method private <init>()V\n");
474 fprintf(fp
, " aload_0\n");
475 fprintf(fp
, " invokespecial %s/<init>()V\n", abscname
);
476 fprintf(fp
, " return\n");
477 fprintf(fp
, ".end method\n\n");
479 fprintf(fp
, ".method static <clinit>()V\n");
480 fprintf(fp
, " .limit stack 2\n");
481 fprintf(fp
, " new %s\n", cname
);
482 fprintf(fp
, " dup\n");
483 fprintf(fp
, " invokespecial %s/<init>()V\n", cname
);
484 fprintf(fp
, " putstatic %s/pointer %s\n", cname
, absdesc
);
485 fprintf(fp
, " return\n");
486 fprintf(fp
, ".end method\n\n");
488 signature
= jvm_get_procedure_signature(proc
-> type
);
490 gen_proc_t
* p
= jvm_create_proc(class);
491 jvm_generate_function_header(p
, "public", "invoke", signature
);
492 jvm_alloc_register_untyped(p
-> rf
, false);
495 int num
= proc
-> type
-> num_decl
;
496 oberon_object_t
* param
= proc
-> type
-> decl
;
497 for(int i
= 0; i
< num
; i
++)
499 gen_type_t
* t
= param
-> type
-> gen_type
;
500 if(param
-> class == OBERON_CLASS_VAR_PARAM
)
502 int reg
= jvm_alloc_register_untyped(p
-> rf
, true);
503 jvm_generate(p
, 0, 1, "aload %i", reg
);
504 jvm_generate(p
, 0, 1, "iload %i", reg
+ 1);
508 int reg
= jvm_alloc_register_untyped(p
-> rf
, t
-> wide
);
509 jvm_generate(p
, 0, t
-> cell_size
, "%cload %i", t
-> prefix
, reg
);
511 use_size
+= t
-> cell_size
;
512 param
= param
-> next
;
515 char * full_name
= jvm_get_field_full_name(proc
);
516 int cell_size
= jvm_cell_size_for_type(proc
-> type
-> base
);
517 jvm_generate(p
, use_size
, cell_size
, "invokestatic %s%s", full_name
, signature
);
519 if(proc
-> type
-> base
-> class == OBERON_TYPE_NOTYPE
)
521 jvm_generate(p
, 0, 0, "return");
525 char prefix
= jvm_get_prefix(proc
-> type
-> base
);
526 jvm_generate(p
, cell_size
, 0, "%creturn", prefix
);
529 jvm_generate_function_end(p
);
531 jvm_destroy_class(class);
535 oberon_generate_record_class(const char * dir
, gen_module_t
* m
, oberon_type_t
* rec
)
538 struct gen_class
* class;
540 /* Устанавливаем новоый id */
541 rec
-> gen_type
-> rec_id
= m
-> rec_id
;
544 cname
= jvm_get_class_full_name(rec
);
545 class = jvm_create_class(dir
, cname
);
547 fprintf(class -> fp
, ".source %s\n", rec
-> module
-> name
);
548 fprintf(class -> fp
, ".class public %s\n", cname
);
550 if(rec
-> base
== NULL
)
552 fprintf(class -> fp
, ".super java/lang/Object\n\n");
556 class -> base
= rec
-> base
-> gen_type
-> class;
557 fprintf(class -> fp
, ".super %s\n\n", class -> base
-> full_name
);
560 rec
-> gen_type
-> class = class;
564 oberon_generator_init_type(oberon_context_t
* ctx
, oberon_type_t
* type
)
566 gen_type_t
* t
= GC_MALLOC(sizeof *t
);
567 memset(t
, 0, sizeof *t
);
568 type
-> gen_type
= t
;
571 c
= ctx
-> gen_context
;
574 switch(type
-> class)
576 case OBERON_TYPE_NOTYPE
:
577 case OBERON_TYPE_INTEGER
:
578 case OBERON_TYPE_BOOLEAN
:
579 case OBERON_TYPE_ARRAY
:
580 case OBERON_TYPE_POINTER
:
581 case OBERON_TYPE_REAL
:
582 case OBERON_TYPE_CHAR
:
583 case OBERON_TYPE_STRING
:
584 case OBERON_TYPE_SET
:
585 case OBERON_TYPE_NIL
:
586 case OBERON_TYPE_SYSTEM_BYTE
:
587 case OBERON_TYPE_SYSTEM_PTR
:
589 case OBERON_TYPE_RECORD
:
590 m
= type
-> module
-> gen_mod
;
591 t
-> full_name
= jvm_get_class_full_name(type
);
592 oberon_generate_record_class(c
-> dir
, m
, type
);
594 case OBERON_TYPE_PROCEDURE
:
595 oberon_generate_procedure_class(c
-> dir
, type
);
598 gen_error("oberon_generator_init_type: unk calss %i", type
-> class);
602 if(type
-> class != OBERON_TYPE_NOTYPE
)
604 t
-> wide
= jvm_is_wide_type(type
);
605 t
-> prefix
= jvm_get_prefix(type
);
606 t
-> postfix
= jvm_get_postfix(type
);
609 if((type
-> class == OBERON_TYPE_POINTER
&& type
-> base
-> class == OBERON_TYPE_RECORD
) ||
610 type
-> class == OBERON_TYPE_PROCEDURE
||
611 type
-> class == OBERON_TYPE_RECORD
||
612 type
-> class == OBERON_TYPE_SYSTEM_PTR
)
614 t
-> full_name
= jvm_get_class_full_name(type
);
617 t
-> cell_size
= jvm_cell_size_for_type(type
);
619 if(type
-> class != OBERON_TYPE_NIL
)
621 t
-> desc
= jvm_get_descriptor(type
);
626 oberon_generator_init_record(oberon_context_t
* ctx
, oberon_type_t
* rec
)
628 struct gen_class
* class;
629 class = rec
-> gen_type
-> class;
631 int num
= rec
-> num_decl
;
632 oberon_object_t
* field
= rec
-> decl
;
633 for(int i
= 0; i
< num
; i
++)
635 jvm_generate_var(field
-> gen_var
);
636 field
= field
-> next
;
639 /* Стандартный конструктор класса */
640 /* Инициализирует внутренние статические записи и массивы */
641 gen_proc_t
* p
= jvm_create_proc(class);
642 jvm_generate_function_header(p
, "public", "<init>", "()V");
643 jvm_alloc_register_untyped(p
-> rf
, false);
644 jvm_generate(p
, 0, 1, "aload_0");
647 jvm_generate(p
, 1, 0, "invokespecial %s/<init>()V", class -> base
-> full_name
);
651 jvm_generate(p
, 1, 0, "invokespecial java/lang/Object/<init>()V");
653 num
= rec
-> num_decl
;
655 for(int i
= 0; i
< num
; i
++)
657 jvm_generate(p
, 0, 1, "aload_0");
658 jvm_generate_var_initialization(p
, field
-> gen_var
);
660 if(field
-> type
-> class == OBERON_TYPE_RECORD
661 || field
-> type
-> class == OBERON_TYPE_ARRAY
)
663 jvm_generate(p
, 0, 1, "aload_0");
664 jvm_generate_ldst_prepare(p
, field
-> gen_var
);
665 jvm_generate_new(p
, field
-> type
, 0);
666 jvm_generate_store(p
, field
-> gen_var
);
668 field
= field
-> next
;
670 jvm_generate(p
, 0, 0, "return");
671 jvm_generate_function_end(p
);
673 /* Метод для копирования полей класса */
674 /* reg0 == src -> reg1 == dst */
675 p
= jvm_create_proc(class);
676 char * signature
= new_string("(%s%s)V", rec
-> gen_type
-> desc
, rec
-> gen_type
-> desc
);
677 jvm_generate_function_header(p
, "public static", "$COPY$", signature
);
679 gen_var_t
* copy_dst
= jvm_create_function_var(p
, JVM_STORAGE_REGISTER
, "dst", rec
-> gen_type
);
680 gen_var_t
* copy_src
= jvm_create_function_var(p
, JVM_STORAGE_REGISTER
, "src", rec
-> gen_type
);
681 jvm_generate_var(copy_dst
);
682 jvm_generate_var(copy_src
);
683 jvm_generate_var_initialization(p
, copy_dst
);
684 jvm_generate_var_initialization(p
, copy_src
);
688 jvm_generate_load(p
, copy_dst
);
689 jvm_generate_load(p
, copy_src
);
690 jvm_generate_copy_record(p
, rec
-> base
);
693 num
= rec
-> num_decl
;
695 for(int i
= 0; i
< num
; i
++)
697 if(field
-> type
-> class == OBERON_TYPE_RECORD
)
699 jvm_generate_load(p
, copy_dst
);
700 jvm_generate_load(p
, field
-> gen_var
);
701 jvm_generate_load(p
, copy_src
);
702 jvm_generate_load(p
, field
-> gen_var
);
703 jvm_generate_copy_record(p
, field
-> type
);
705 else if(field
-> type
-> class == OBERON_TYPE_ARRAY
)
707 jvm_generate_load(p
, copy_dst
);
708 jvm_generate_load(p
, field
-> gen_var
);
709 jvm_generate_load(p
, copy_src
);
710 jvm_generate_load(p
, field
-> gen_var
);
711 jvm_generate_copy_array(p
, field
-> type
);
715 jvm_generate_load(p
, copy_dst
);
716 jvm_generate_ldst_prepare(p
, field
-> gen_var
);
717 jvm_generate_load(p
, copy_src
);
718 jvm_generate_load(p
, field
-> gen_var
);
719 jvm_generate_store(p
, field
-> gen_var
);
721 field
= field
-> next
;
723 jvm_generate(p
, 0, 0, "return");
724 jvm_generate_function_end(p
);
726 jvm_destroy_class(class);
730 oberon_generator_init_var(oberon_context_t
* ctx
, oberon_object_t
* var
)
733 m
= ctx
-> mod
-> gen_mod
;
735 struct gen_class
* class;
739 struct gen_class
* c
;
740 char * name
= var
-> name
;
741 gen_type_t
* t
= var
-> type
-> gen_type
;
746 gen_error("uninitialized type class %i", var
-> type
-> class);
751 case OBERON_CLASS_VAR_PARAM
:
752 p
= var
-> parent
-> gen_proc
;
753 var
-> gen_var
= jvm_create_function_var(p
, JVM_STORAGE_FRAME_PARAM_VARPTR
, name
, t
);
755 case OBERON_CLASS_PARAM
:
756 p
= var
-> parent
-> gen_proc
;
757 var
-> gen_var
= jvm_create_function_var(p
, JVM_STORAGE_FRAME_PARAM_VAR
, name
, t
);
759 case OBERON_CLASS_FIELD
:
760 c
= var
-> parent_type
-> gen_type
-> class;
761 var
-> gen_var
= jvm_create_class_var(c
, JVM_STORAGE_FIELD_VAR
, name
, t
);
763 case OBERON_CLASS_VAR
:
766 p
= var
-> parent
-> gen_proc
;
767 var
-> gen_var
= jvm_create_function_var(p
, JVM_STORAGE_FRAME_VAR
, name
, t
);
771 var
-> gen_var
= jvm_create_class_var(class, JVM_STORAGE_STATIC_VAR
, name
, t
);
772 jvm_generate_var(var
-> gen_var
);
776 gen_error("oberon_generator_init_var: unk var class %i", var
-> class);
782 oberon_generate_static_initialization(gen_proc_t
* p
, oberon_object_t
* x
)
784 if(x
-> type
-> class == OBERON_TYPE_ARRAY
785 || x
-> type
-> class == OBERON_TYPE_RECORD
)
787 jvm_generate_ldst_prepare(p
, x
-> gen_var
);
788 jvm_generate_new(p
, x
-> type
, 0);
789 jvm_generate_store(p
, x
-> gen_var
);
794 oberon_generator_init_temp_var(oberon_context_t
* ctx
, oberon_object_t
* var
)
796 assert(var
-> class == OBERON_CLASS_VAR
);
799 m
= ctx
-> mod
-> gen_mod
;
805 t
= var
-> type
-> gen_type
;
807 var
-> gen_var
= jvm_create_function_temp_var(p
, t
);
808 jvm_generate_var(var
-> gen_var
);
809 jvm_generate_var_initialization(p
, var
-> gen_var
);
810 oberon_generate_static_initialization(p
, var
);
814 oberon_generator_init_proc(oberon_context_t
* ctx
, oberon_object_t
* proc
)
816 struct gen_class
* class = proc
-> module
-> gen_mod
-> class;
817 proc
-> gen_proc
= jvm_create_proc(class);
818 proc
-> gen_proc
-> full_name
= jvm_get_field_full_name_safe(proc
);
819 jvm_create_static_links(proc
);
823 oberon_generator_init_module(oberon_context_t
* ctx
, oberon_module_t
* mod
)
825 gen_module_t
* m
= GC_MALLOC(sizeof *m
);
826 memset(m
, 0, sizeof *m
);
830 c
= ctx
-> gen_context
;
832 struct gen_class
* class;
833 class = jvm_create_class(c
-> dir
, mod
-> name
);
835 fprintf(class -> fp
, ".source %s\n", mod
-> name
);
836 fprintf(class -> fp
, ".class %s\n", mod
-> name
);
837 fprintf(class -> fp
, ".super java/lang/Object\n\n");
839 fprintf(class -> fp
, ".field private static $INITIALIZED$ Z\n\n");
847 oberon_generator_fini_module(oberon_module_t
* mod
)
849 jvm_destroy_class(mod
-> gen_mod
-> class);
853 push_expr(gen_proc_t
* p
, oberon_expr_t
* expr
);
856 oberon_generate_begin_module(oberon_context_t
* ctx
)
860 struct gen_class
* class;
862 class = ctx
-> mod
-> gen_mod
-> class;
864 p
= jvm_create_proc(class);
865 jvm_generate_function_header(p
, "public static", "BEGIN", "()V");
867 label_cont
= jvm_new_label_id(p
);
868 jvm_generate(p
, 0, 1, "getstatic %s/$INITIALIZED$ Z", class -> full_name
);
869 jvm_generate(p
, 1, 0, "ifeq L%i", label_cont
);
870 jvm_generate(p
, 0, 0, "return");
871 jvm_generate_label(p
, label_cont
);
873 jvm_generate(p
, 0, 1, "iconst_1");
874 jvm_generate(p
, 1, 0, "putstatic %s/$INITIALIZED$ Z", class -> full_name
);
876 /* Инициализация переменных объявленных в модуле */
877 oberon_object_t
* x
= ctx
-> mod
-> decl
-> list
-> next
;
880 if(x
-> class == OBERON_CLASS_MODULE
)
882 if(!x
-> module
-> intrinsic
)
884 jvm_generate(p
, 0, 0, "invokestatic %s/BEGIN()V", x
-> module
-> gen_mod
-> class -> full_name
);
887 else if(x
-> class == OBERON_CLASS_VAR
)
889 jvm_generate_var_initialization(p
, x
-> gen_var
);
890 oberon_generate_static_initialization(p
, x
);
898 oberon_generate_end_module(oberon_context_t
* ctx
)
900 struct gen_class
* class = ctx
-> mod
-> gen_mod
-> class;
901 gen_proc_t
* p
= class -> p
;
903 jvm_generate(p
, 0, 0, "return");
904 jvm_generate_function_end(class -> p
);
906 p
= jvm_create_proc(class);
907 jvm_generate_function_header(p
, "private", "<init>", "()V");
908 jvm_alloc_register_untyped(p
-> rf
, false);
909 jvm_generate(p
, 0, 1, "aload_0");
910 jvm_generate(p
, 1, 0, "invokespecial java/lang/Object/<init>()V");
911 jvm_generate(p
, 0, 0, "return");
912 jvm_generate_function_end(class -> p
);
916 * Генерирует код для получения размера измерения массива
917 * Аналог Обероновского LEN(v, n); где n = 0 - первое измерение.
922 jvm_generate_array_len(gen_proc_t
* p
, int dim
)
926 jvm_generate(p
, 0, 1, "iconst_0");
927 jvm_generate(p
, 2, 1, "aaload");
930 jvm_generate(p
, 1, 1, "arraylength");
934 jvm_generate_array_duplicate_and_replace(gen_proc_t
* p
, gen_var_t
* v
, oberon_type_t
* arr
)
936 jvm_generate_ldst_prepare(p
, v
);
939 oberon_type_t
* base
= arr
;
940 while(base
-> class == OBERON_TYPE_ARRAY
)
942 if(base
-> size
== 0)
944 jvm_generate_load(p
, v
);
945 jvm_generate_array_len(p
, dim
);
951 jvm_generate_new(p
, arr
, dim
);
952 jvm_generate(p
, 1, 2, "dup");
953 jvm_generate_load(p
, v
);
954 jvm_generate_copy_array(p
, arr
);
955 jvm_generate_store(p
, v
);
959 jvm_generate_record_duplicate_and_replace(gen_proc_t
* p
, gen_var_t
* v
, oberon_type_t
* rec
)
961 jvm_generate_ldst_prepare(p
, v
);
962 jvm_generate_new(p
, rec
, 0);
963 jvm_generate(p
, 1, 2, "dup");
964 jvm_generate_load(p
, v
);
965 jvm_generate_copy_record(p
, rec
);
966 jvm_generate_store(p
, v
);
970 jvm_generate_local_object(gen_proc_t
* p
, oberon_object_t
* x
)
973 struct gen_class
* class;
978 // Убеждаемся что сейчас находимся в функции
984 case OBERON_CLASS_VAR_PARAM
:
985 case OBERON_CLASS_PARAM
:
986 case OBERON_CLASS_VAR
:
989 case OBERON_CLASS_CONST
:
990 case OBERON_CLASS_TYPE
:
991 case OBERON_CLASS_PROC
:
994 gen_error("jvm_generate_local_initialization: wat class %i", x
-> class);
1000 jvm_generate_local_initialization(gen_proc_t
* p
, oberon_object_t
* x
)
1003 struct gen_class
* class;
1008 // Убеждаемся что сейчас находимся в функции
1014 case OBERON_CLASS_VAR_PARAM
:
1015 jvm_generate_var_initialization(p
, v
);
1017 case OBERON_CLASS_PARAM
:
1018 jvm_generate_var_initialization(p
, v
);
1019 if(x
-> type
-> class == OBERON_TYPE_ARRAY
)
1021 jvm_generate_array_duplicate_and_replace(p
, v
, x
-> type
);
1023 else if(x
-> type
-> class == OBERON_TYPE_RECORD
)
1025 jvm_generate_record_duplicate_and_replace(p
, v
, x
-> type
);
1028 case OBERON_CLASS_VAR
:
1029 jvm_generate_var_initialization(p
, v
);
1030 oberon_generate_static_initialization(p
, x
);
1032 case OBERON_CLASS_CONST
:
1033 case OBERON_CLASS_TYPE
:
1034 case OBERON_CLASS_PROC
:
1037 gen_error("jvm_generate_local_initialization: wat class %i", x
-> class);
1043 oberon_generate_begin_proc(oberon_context_t
* ctx
, oberon_object_t
* proc
)
1048 oberon_object_t
* var
;
1050 p
= proc
-> gen_proc
;
1054 signature
= jvm_get_local_procedure_signature(proc
);
1058 oberon_generate_procedure_pointer_class(p
-> class -> dir
, proc
);
1059 signature
= jvm_get_procedure_signature(proc
-> type
);
1062 name
= jvm_get_name(proc
);
1063 p
-> ret_prefix
= jvm_get_prefix(proc
-> type
-> base
);
1064 jvm_generate_function_header(p
, "public static", name
, signature
);
1068 jvm_generate_staticlinks(proc
);
1071 jvm_generate_procedure_frame(proc
);
1073 /* Создание параметров и переменных */
1074 var
= proc
-> scope
-> list
-> next
;
1077 jvm_generate_local_object(p
, var
);
1081 jvm_generate_frame_initialization(p
);
1083 /* Инициализация парамеров и переменных */
1084 var
= proc
-> scope
-> list
-> next
;
1087 jvm_generate_local_initialization(p
, var
);
1093 oberon_generate_end_proc(oberon_context_t
* ctx
)
1098 m
= ctx
-> mod
-> gen_mod
;
1099 p
= m
-> class -> p
;
1101 oberon_generate_trap(ctx
, -4);
1103 if(p
-> ret_prefix
== ' ')
1105 jvm_generate(p
, 0, 0, "return");
1109 int sz
= jvm_cell_size_for_postfix(p
-> ret_prefix
);
1110 switch(p
-> ret_prefix
)
1113 jvm_generate(p
, 0, 1, "aconst_null");
1116 jvm_generate_push_int_size(p
, 0, 8);
1119 jvm_generate_push_float(p
, 0, 4);
1122 jvm_generate_push_float(p
, 0, 8);
1125 jvm_generate_push_int(p
, 0);
1128 jvm_generate(p
, sz
, 0, "%creturn", p
-> ret_prefix
);
1131 jvm_generate_function_end(p
);
1135 oberon_generator_reserve_label(oberon_context_t
* ctx
)
1141 m
= ctx
-> mod
-> gen_mod
;
1142 p
= m
-> class -> p
;
1144 l
= GC_MALLOC(sizeof *l
);
1145 memset(l
, 0, sizeof *l
);
1147 l
-> id
= jvm_new_label_id(p
);
1152 oberon_generate_label(oberon_context_t
* ctx
, gen_label_t
* l
)
1157 m
= ctx
-> mod
-> gen_mod
;
1158 p
= m
-> class -> p
;
1160 jvm_generate_label(p
, l
-> id
);
1164 oberon_generate_goto(oberon_context_t
* ctx
, gen_label_t
* l
)
1169 m
= ctx
-> mod
-> gen_mod
;
1170 p
= m
-> class -> p
;
1172 jvm_generate(p
, 0, 0, "goto L%i", l
-> id
);
1176 oberon_generate_branch(oberon_context_t
* ctx
, oberon_expr_t
* cond
, bool gotoif
, gen_label_t
* l
)
1181 m
= ctx
-> mod
-> gen_mod
;
1182 p
= m
-> class -> p
;
1188 /* переход если false */
1189 jvm_generate(p
, 1, 0, "ifeq L%i", l
-> id
);
1193 /* переход если true */
1194 jvm_generate(p
, 1, 0, "ifne L%i", l
-> id
);
1199 push_varptr(gen_proc_t
* p
, oberon_expr_t
* expr
)
1201 assert(expr
-> is_item
);
1203 switch(expr
-> item
.mode
)
1206 jvm_generate_ldst_prepare(p
, expr
-> item
.var
-> gen_var
);
1209 push_item(p
, expr
-> item
.parent
);
1210 push_expr(p
, expr
-> item
.args
);
1211 check_index(p
, expr
-> item
.args
-> result
);
1214 push_item(p
, expr
-> item
.parent
);
1215 jvm_generate_ldst_prepare(p
, expr
-> item
.var
-> gen_var
);
1218 push_varptr(p
, (oberon_expr_t
*) expr
-> item
.parent
);
1221 gen_error("push_varptr: wat %i", expr
-> item
.mode
);
1227 jvm_generate_call_proc(gen_proc_t
* p
, oberon_item_t
* desig
)
1229 assert(desig
-> var
== NULL
);
1230 assert(desig
-> mode
== MODE_CALL
);
1232 bool direct_call
= false;
1233 if(desig
-> parent
-> mode
== MODE_VAR
)
1235 if(desig
-> parent
-> var
-> class == OBERON_CLASS_PROC
)
1241 oberon_type_t
* procsig
;
1242 procsig
= desig
-> parent
-> result
;
1244 if(direct_call
== false)
1246 /* Загружаем указатель на процедуру */
1247 push_item(p
, desig
-> parent
);
1252 jvm_generate_push_static_links(p
, desig
-> parent
-> var
);
1256 int result_cells
= jvm_cell_size_for_type(procsig
-> base
);
1258 int num
= desig
-> num_args
;
1259 oberon_expr_t
* arg
= desig
-> args
;
1260 oberon_object_t
* param
= procsig
-> decl
;
1261 for(int i
= 0; i
< num
; i
++)
1263 if(param
-> class == OBERON_CLASS_VAR_PARAM
)
1266 push_varptr(p
, arg
);
1270 args_cells
+= jvm_cell_size_for_type(arg
-> result
);
1274 param
= param
-> next
;
1279 char * full_name
= jvm_get_field_full_name(desig
-> parent
-> var
);
1280 char * signature
= jvm_get_local_procedure_signature(desig
-> parent
-> var
);
1281 jvm_generate(p
, args_cells
, result_cells
, "invokestatic %s%s", full_name
, signature
);
1285 char * cname
= jvm_get_class_full_name(procsig
);
1286 char * signature
= jvm_get_procedure_signature(procsig
);
1287 jvm_generate(p
, 1 + args_cells
, result_cells
, "invokevirtual %s/invoke%s", cname
, signature
);
1292 oberon_generate_call_proc(oberon_context_t
* ctx
, oberon_expr_t
* desig
)
1294 assert(desig
-> is_item
);
1295 jvm_generate_call_proc(ctx
-> mod
-> gen_mod
-> class -> p
, (oberon_item_t
*) desig
);
1299 oberon_generate_return(oberon_context_t
* ctx
, oberon_expr_t
* expr
)
1306 m
= ctx
-> mod
-> gen_mod
;
1307 p
= m
-> class -> p
;
1312 prefix
= jvm_get_prefix(expr
-> result
);
1313 cell_size
= jvm_cell_size_for_type(expr
-> result
);
1314 jvm_generate(p
, cell_size
, 0, "%creturn", prefix
);
1318 jvm_generate(p
, 0, 0, "return");
1323 jvm_generate_expr_new_pointer(gen_proc_t
* p
, oberon_type_t
* type
, int num
, oberon_expr_t
* arg
)
1325 assert(type
-> class == OBERON_TYPE_POINTER
);
1327 for(int i
= 0; i
< num
; i
++)
1330 check_index(p
, arg
-> result
);
1334 jvm_generate_new(p
, type
-> base
, num
);
1338 push_item(gen_proc_t
* p
, oberon_item_t
* item
)
1340 switch(item
-> mode
)
1343 if(item
-> var
-> class == OBERON_CLASS_PROC
)
1345 jvm_generate_push_procedure_pointer(p
, item
-> var
);
1349 jvm_generate_load(p
, item
-> var
-> gen_var
);
1356 jvm_generate_push_int_size(p
, item
-> integer
, item
-> result
-> size
);
1359 jvm_generate_call_proc(p
, item
);
1363 char postfix
= jvm_get_postfix(item
-> result
);
1364 int cell_size
= jvm_cell_size_for_postfix(postfix
);
1365 push_item(p
, item
-> parent
);
1366 push_expr(p
, item
-> args
);
1367 check_index(p
, item
-> args
-> result
);
1368 jvm_generate(p
, 1 + 1, cell_size
, "%caload", postfix
);
1371 push_item(p
, item
-> parent
);
1372 jvm_generate_load(p
, item
-> var
-> gen_var
);
1375 /* Все объекты в jvm представляются как указатели */
1376 push_item(p
, item
-> parent
);
1379 jvm_generate(p
, 0, 1, "aconst_null");
1382 jvm_generate_expr_new_pointer(p
, item
-> result
, item
-> num_args
, item
-> args
);
1385 jvm_generate_push_float(p
, item
-> real
, item
-> result
-> size
);
1388 jvm_generate_push_string(p
, item
-> string
, item
-> result
-> size
);
1391 push_item(p
, item
-> parent
);
1392 jvm_generate_array_len(p
, item
-> integer
);
1393 jvm_generate_cast_prefix(p
, 'i', jvm_get_postfix(item
-> result
));
1396 push_item(p
, item
-> parent
);
1397 jvm_generate_cast_type(p
, item
-> parent
-> result
, item
-> result
);
1400 gen_error("push_item: unk mode %i", item
-> mode
);
1406 jvm_generate_logical_not(gen_proc_t
* p
)
1408 int label_done
= jvm_new_label_id(p
);
1409 int label_false
= jvm_new_label_id(p
);
1411 jvm_generate(p
, 1, 0, "ifne L%i", label_false
);
1412 jvm_generate(p
, 0, 1, "iconst_1");
1413 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1414 jvm_generate_label(p
, label_false
);
1415 jvm_generate(p
, 0, 1, "iconst_0");
1416 jvm_generate_label(p
, label_done
);
1420 jvm_generate_abs(gen_proc_t
* p
, char prefix
)
1422 char t
= jvm_get_type_of_prefix(prefix
);
1423 int cell_size
= jvm_cell_size_for_postfix(prefix
);
1424 jvm_generate(p
, cell_size
, cell_size
, "invokestatic java/lang/Math/abs(%c)%c", t
, t
);
1428 jvm_get_compare_postfix(int op
)
1452 gen_error("jvm_generate_compare_op: wat");
1459 jvm_generate_compare_op(gen_proc_t
* p
, oberon_type_t
* t
, int op
)
1461 char prefix
= jvm_get_prefix(t
);
1462 int label_true
= jvm_new_label_id(p
);
1463 int label_done
= jvm_new_label_id(p
);
1464 int cell_size
= jvm_cell_size_for_type(t
);
1465 char * cmpop
= jvm_get_compare_postfix(op
);
1469 jvm_generate(p
, 2 * cell_size
, 1, "lcmp");
1470 jvm_generate(p
, 1, 1, "if%s L%i", cmpop
, label_true
);
1472 else if(prefix
== 'f' || prefix
== 'd')
1475 if(op
== OP_EQ
|| op
== OP_NEQ
|| op
== OP_GRT
|| op
== OP_GEQ
)
1483 jvm_generate(p
, 2 * cell_size
, 1, "%ccmp%c", prefix
, fop
);
1484 jvm_generate(p
, 1, 1, "if%s L%i", cmpop
, label_true
);
1486 else if(prefix
== 'a')
1488 if(oberon_is_array_of_char_type(t
) || oberon_is_string_type(t
))
1490 jvm_generate(p
, 2, 1, "invokestatic SYSTEM/STRCMP([B[B)I");
1491 jvm_generate(p
, 1, 0, "if%s L%i", cmpop
, label_true
);
1495 jvm_generate(p
, 1, 0, "if_acmp%s L%i", cmpop
, label_true
);
1500 jvm_generate(p
, 2 * cell_size
, 0, "if_%ccmp%s L%i", prefix
, cmpop
, label_true
);
1503 jvm_generate(p
, 0, 1, "iconst_0");
1504 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1505 jvm_generate_label(p
, label_true
);
1506 jvm_generate(p
, 0, 1, "iconst_1");
1507 jvm_generate_label(p
, label_done
);
1511 jvm_generate_operator(gen_proc_t
* p
, oberon_type_t
* t
, int op
)
1513 char prefix
= jvm_get_prefix(t
);
1514 int cell_size
= jvm_cell_size_for_type(t
);
1517 case OP_UNARY_MINUS
:
1518 jvm_generate(p
, cell_size
, cell_size
, "%cneg", prefix
);
1520 case OP_COMPLEMENTATION
:
1521 jvm_generate_push_int_size(p
, -1, t
-> size
);
1522 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cxor", prefix
);
1525 jvm_generate_logical_not(p
);
1528 jvm_generate_abs(p
, prefix
);
1531 jvm_generate(p
, cell_size
, cell_size
, "invokestatic java/lang/Character/toUpperCase(I)I");
1535 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cadd", prefix
);
1538 jvm_generate(p
, 2 * cell_size
, cell_size
, "%csub", prefix
);
1541 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cmul", prefix
);
1544 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cdiv", prefix
);
1547 jvm_generate(p
, 2 * cell_size
, cell_size
, "%crem", prefix
);
1550 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cor", prefix
);
1552 case OP_INTERSECTION
:
1553 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cand", prefix
);
1556 /* (a - b) == a & ~b */
1557 jvm_generate_push_int_size(p
, -1, t
-> size
);
1558 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cxor", prefix
);
1559 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cand", prefix
);
1561 case OP_SYM_DIFFERENCE
:
1562 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cxor", prefix
);
1571 jvm_generate_compare_op(p
, t
, op
);
1574 gen_error("jvm_generate_operator: unk op %i", op
);
1580 jvm_generate_logical_or(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1582 int label_calc_b
= jvm_new_label_id(p
);
1583 int label_done
= jvm_new_label_id(p
);
1585 /* a OR b -- если a, то TRUE, иначе b */
1588 jvm_generate(p
, 1, 0, "ifeq L%i", label_calc_b
);
1589 jvm_generate(p
, 0, 1, "iconst_1");
1590 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1591 jvm_generate_label(p
, label_calc_b
);
1593 jvm_generate_label(p
, label_done
);
1597 jvm_generate_logical_and(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1599 int label_false
= jvm_new_label_id(p
);
1600 int label_done
= jvm_new_label_id(p
);
1602 /* a AND b -- если a, то b, иначе FALSE */
1605 jvm_generate(p
, 1, 0, "ifeq L%i", label_false
);
1607 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1608 jvm_generate_label(p
, label_false
);
1609 jvm_generate(p
, 0, 1, "iconst_0");
1610 jvm_generate_label(p
, label_done
);
1614 jvm_generate_range(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1616 /* { a } == 1 << a */
1617 /* { a..b } == (a <= b) ? ((2 << b) - (1 << a)) : (0); */
1621 oberon_type_t
* type
;
1628 cell_size
= jvm_cell_size_for_type(type
);
1629 prefix
= jvm_get_prefix(type
);
1633 jvm_generate_push_int_size(p
, 1, type
-> size
);
1635 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1639 ra
= jvm_create_function_temp_var(p
, type
-> gen_type
);
1640 rb
= jvm_create_function_temp_var(p
, type
-> gen_type
);
1641 jvm_generate_var(ra
);
1642 jvm_generate_var(rb
);
1643 jvm_generate_var_initialization(p
, ra
);
1644 jvm_generate_var_initialization(p
, rb
);
1645 label_else
= jvm_new_label_id(p
);
1646 label_end
= jvm_new_label_id(p
);
1649 jvm_generate_store(p
, ra
);
1651 jvm_generate_store(p
, rb
);
1653 jvm_generate_load(p
, ra
);
1654 jvm_generate_load(p
, rb
);
1655 jvm_generate(p
, 2 * cell_size
, 0, "if_%ccmpgt L%i", prefix
, label_else
);
1657 jvm_generate_push_int_size(p
, 2, type
-> size
);
1658 jvm_generate_load(p
, rb
);
1659 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1660 jvm_generate_push_int_size(p
, 2, type
-> size
);
1661 jvm_generate_load(p
, ra
);
1662 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1663 jvm_generate(p
, 2 * cell_size
, cell_size
, "%csub", prefix
);
1664 jvm_generate(p
, 0, 0, "goto L%i", label_end
);
1666 jvm_generate_label(p
, label_else
);
1667 jvm_generate_push_int_size(p
, 0, type
-> size
);
1668 jvm_generate_label(p
, label_end
);
1671 /* TODO free registers */
1675 jvm_generate_in(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1677 oberon_type_t
* t
= a
-> result
;
1678 int cell_size
= jvm_cell_size_for_type(t
);
1679 char prefix
= jvm_get_prefix(t
);
1680 int label_else
= jvm_new_label_id(p
);
1681 int label_end
= jvm_new_label_id(p
);
1683 /* (a IN b) == (1 << a) & b */
1684 jvm_generate_push_int_size(p
, 1, t
-> size
);
1686 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1688 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cand", prefix
);
1692 jvm_generate(p
, cell_size
, 0, "lcmp");
1695 jvm_generate(p
, 1, 0, "ifeq L%i", label_else
);
1696 jvm_generate(p
, 0, 1, "iconst_1");
1697 jvm_generate(p
, 0, 0, "goto L%i", label_end
);
1698 jvm_generate_label(p
, label_else
);
1699 jvm_generate(p
, 0, 1, "iconst_0");
1700 jvm_generate_label(p
, label_end
);
1704 jvm_generate_shift(gen_proc_t
* p
, int op
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1706 oberon_type_t
* t
= a
-> result
;
1707 int cell_size
= jvm_cell_size_for_type(t
);
1708 char prefix
= jvm_get_prefix(t
);
1709 char dt
= jvm_get_type_of_prefix(prefix
);
1712 jvm_generate_cast_type(p
, a
-> result
, t
);
1714 jvm_generate_cast_type(p
, b
-> result
, t
);
1729 gen_error("jvm_generate_shift: invalid op %i", op
);
1732 jvm_generate(p
, 2 * cell_size
, cell_size
, "invokestatic SYSTEM/%s(%c%c)%c", opname
, dt
, dt
, dt
);
1736 jvm_generate_entier(gen_proc_t
* p
, oberon_expr_t
* x
, oberon_type_t
* res
)
1738 char prefix
= jvm_get_prefix(x
-> result
);
1739 char postfix
= jvm_get_postfix(res
);
1742 jvm_generate_cast_prefix(p
, prefix
, 'd');
1743 jvm_generate(p
, 2, 2, "invokestatic java/lang/Math/floor(D)D");
1744 jvm_generate_cast_prefix(p
, 'd', postfix
);
1748 push_operator(gen_proc_t
* p
, oberon_oper_t
* oper
)
1750 oberon_type_t
* preq
= oper
-> left
-> result
;
1751 int op
= oper
-> op
;
1755 push_expr(p
, oper
-> left
);
1756 jvm_generate_cast_type(p
, oper
-> left
-> result
, oper
-> result
);
1759 push_expr(p
, oper
-> left
);
1760 jvm_generate_hard_cast_type(p
, oper
-> left
-> result
, oper
-> result
);
1762 case OP_COMPLEMENTATION
:
1763 case OP_UNARY_MINUS
:
1767 push_expr(p
, oper
-> left
);
1768 jvm_generate_operator(p
, preq
, op
);
1771 jvm_generate_entier(p
, oper
-> left
, oper
-> result
);
1781 case OP_INTERSECTION
:
1783 case OP_SYM_DIFFERENCE
:
1791 push_expr(p
, oper
-> left
);
1792 push_expr(p
, oper
-> right
);
1793 jvm_generate_operator(p
, preq
, op
);
1797 jvm_generate_logical_or(p
, oper
-> left
, oper
-> right
);
1800 jvm_generate_logical_and(p
, oper
-> left
, oper
-> right
);
1804 preq
= oper
-> right
-> result
;
1805 char * cname
= jvm_get_class_full_name(preq
);
1806 push_expr(p
, oper
-> left
);
1807 jvm_generate(p
, 1, 1, "instanceof %s", cname
);
1810 jvm_generate_range(p
, oper
-> left
, oper
-> right
);
1813 jvm_generate_in(p
, oper
-> left
, oper
-> right
);
1819 jvm_generate_shift(p
, op
, oper
-> left
, oper
-> right
);
1822 gen_error("push_oper: unk op %i", op
);
1828 push_expr(gen_proc_t
* p
, oberon_expr_t
* expr
)
1832 push_item(p
, (oberon_item_t
*) expr
);
1836 push_operator(p
, (oberon_oper_t
*) expr
);
1841 store_expr(gen_proc_t
* p
, oberon_expr_t
* dst
, oberon_expr_t
* src
)
1843 assert(dst
-> is_item
);
1844 oberon_item_t
* item
= (oberon_item_t
*) dst
;
1846 if(dst
-> result
-> class == OBERON_TYPE_ARRAY
1847 || src
-> result
-> class == OBERON_TYPE_ARRAY
)
1851 jvm_generate_copy_array(p
, dst
-> result
);
1853 else if(dst
-> result
-> class == OBERON_TYPE_RECORD
1854 || src
-> result
-> class == OBERON_TYPE_RECORD
)
1858 jvm_generate_copy_record(p
, dst
-> result
);
1860 else switch(item
-> mode
)
1863 jvm_generate_ldst_prepare(p
, item
-> var
-> gen_var
);
1865 jvm_generate_store(p
, item
-> var
-> gen_var
);
1869 char postfix
= jvm_get_postfix(src
-> result
);
1870 int cell_size
= jvm_cell_size_for_postfix(postfix
);
1871 assert(item
-> parent
-> is_item
);
1872 push_item(p
, (oberon_item_t
*) item
-> parent
);
1873 push_expr(p
, item
-> args
);
1874 check_index(p
, item
-> args
-> result
);
1876 jvm_generate(p
, 1 + 1 + cell_size
, 0, "%castore", postfix
);
1879 assert(item
-> parent
-> is_item
);
1880 push_item(p
, (oberon_item_t
*) item
-> parent
);
1881 jvm_generate_ldst_prepare(p
, item
-> var
-> gen_var
);
1883 jvm_generate_store(p
, item
-> var
-> gen_var
);
1886 gen_error("store_expr: unk mode %i", item
-> mode
);
1892 oberon_generate_assign(oberon_context_t
* ctx
, oberon_expr_t
* src
, oberon_expr_t
* dst
)
1897 m
= ctx
-> mod
-> gen_mod
;
1898 p
= m
-> class -> p
;
1900 store_expr(p
, dst
, src
);
1904 oberon_generate_copy(oberon_context_t
* ctx
, oberon_expr_t
* src
, oberon_expr_t
* dst
)
1910 m
= ctx
-> mod
-> gen_mod
;
1911 p
= m
-> class -> p
;
1916 desc
= jvm_get_descriptor(dst
-> result
);
1918 jvm_generate(p
, 2, 0, "invokestatic SYSTEM/COPY(%s%s)V", desc
, desc
);
1922 oberon_generate_assert(oberon_context_t
* ctx
, oberon_expr_t
* cond
)
1927 m
= ctx
-> mod
-> gen_mod
;
1928 p
= m
-> class -> p
;
1931 jvm_generate(p
, 1, 0, "invokestatic SYSTEM/ASSERT(Z)V");
1935 oberon_generate_assert_n(oberon_context_t
* ctx
, oberon_expr_t
* cond
, int64_t n
)
1940 m
= ctx
-> mod
-> gen_mod
;
1941 p
= m
-> class -> p
;
1944 jvm_generate_push_int_size(p
, n
, 8);
1945 jvm_generate(p
, 1 + 2, 0, "invokestatic SYSTEM/ASSERT(ZJ)V");
1949 oberon_generate_trap(oberon_context_t
* ctx
, int64_t n
)
1954 m
= ctx
-> mod
-> gen_mod
;
1955 p
= m
-> class -> p
;
1957 jvm_generate_push_int_size(p
, n
, 8);
1958 jvm_generate(p
, 2, 0, "invokestatic SYSTEM/TRAP(J)V");
1962 oberon_generate_halt(oberon_context_t
* ctx
, int64_t n
)
1967 m
= ctx
-> mod
-> gen_mod
;
1968 p
= m
-> class -> p
;
1970 jvm_generate_push_int_size(p
, n
, 8);
1971 jvm_generate(p
, 2, 0, "invokestatic SYSTEM/HALT(J)V");
1975 oberon_set_out_directory(oberon_context_t
* ctx
, const char * path
)
1979 c
= ctx
-> gen_context
;
1981 c
-> dir
= new_string(path
);
1985 oberon_set_typecheck(oberon_object_t
* var
, bool enable
)
1987 var
-> gen_var
-> typecheck
= enable
;
1988 var
-> gen_var
-> forcetype
= (enable
) ? (var
-> type
-> gen_type
) : (NULL
);
1991 void oberon_set_line(oberon_context_t
* ctx
, int line
)
1996 m
= ctx
-> mod
-> gen_mod
;
1999 p
= m
-> class -> p
;
2003 jvm_generate(p
, 0, 0, ".line %i", line
);