4f49cfb86ca94df0b220be27f0d5fad68ac99a3b
11 #include "../../oberon-internals.h"
12 #include "../../generator.h"
13 #include "generator-jvm.h"
14 #include "generator-jvm-abi.h"
15 #include "generator-jvm-asm.h"
16 #include "generator-jvm-basic.h"
19 push_item(gen_proc_t
* p
, oberon_item_t
* item
);
22 jvm_generate_new(gen_proc_t
* p
, oberon_type_t
* type
, int num
);
25 jvm_generate_cast_prefix(gen_proc_t
* p
, char prefix
, char postfix
)
27 if((prefix
== 'b' || prefix
== 's') && (postfix
= 'l' || postfix
== 'd'))
37 if((prefix
== 'l' || prefix
== 'd') && (postfix
== 'b' || postfix
== 's'))
39 jvm_generate(p
, 2, 1, "%c2i", prefix
);
43 int from_cell_size
= jvm_cell_size_for_postfix(prefix
);
44 int to_cell_size
= jvm_cell_size_for_postfix(postfix
);
45 jvm_generate(p
, from_cell_size
, to_cell_size
, "%c2%c", prefix
, postfix
);
49 jvm_generate_cast_type(gen_proc_t
* p
, oberon_type_t
* from
, oberon_type_t
* to
)
51 if(to
-> class == OBERON_TYPE_RECORD
|| to
-> class == OBERON_TYPE_POINTER
)
53 if(to
-> class == OBERON_TYPE_POINTER
&& to
-> base
-> class == OBERON_TYPE_RECORD
)
55 char * full_name
= jvm_get_class_full_name(to
);
56 jvm_generate(p
, 1, 1, "checkcast %s", full_name
);
61 char prefix
= jvm_get_prefix(from
);
62 char postfix
= jvm_get_postfix(to
);
63 jvm_generate_cast_prefix(p
, prefix
, postfix
);
68 jvm_generate_hard_cast_type(gen_proc_t
* p
, oberon_type_t
* from
, oberon_type_t
* to
)
70 if(from
-> class == OBERON_TYPE_REAL
71 && (to
-> class == OBERON_TYPE_INTEGER
|| to
-> class == OBERON_TYPE_SYSTEM_BYTE
))
73 char postfix
= jvm_get_postfix(to
);
76 jvm_generate(p
, 1, 1, "invokestatic java/lang/Float/floatToRawIntBits(F)I");
77 jvm_generate_cast_prefix(p
, 'i', postfix
);
81 jvm_generate(p
, 2, 2, "invokestatic java/lang/Double/doubleToRawIntBits(D)J");
82 jvm_generate_cast_prefix(p
, 'l', postfix
);
85 else if((from
-> class == OBERON_TYPE_INTEGER
|| from
-> class == OBERON_TYPE_SYSTEM_BYTE
)
86 && to
-> class == OBERON_TYPE_REAL
)
88 char prefix
= jvm_get_prefix(from
);
91 jvm_generate_cast_prefix(p
, prefix
, 'i');
92 jvm_generate(p
, 1, 1, "invokestatic java/lang/Float/intBitsToFloat(I)F");
96 jvm_generate_cast_prefix(p
, prefix
, 'l');
97 jvm_generate(p
, 2, 2, "invokestatic java/lang/Double/longBitsToDouble(J)D");
102 jvm_generate_cast_type(p
, from
, to
);
107 * Генерирует код для инициализации массива со статическим базовым типом
112 jvm_generate_array_initialization(gen_proc_t
* p
, oberon_type_t
* arr
)
115 oberon_type_t
* base
= arr
;
116 while(base
-> class == OBERON_TYPE_ARRAY
)
122 if(base
-> class != OBERON_TYPE_RECORD
)
124 jvm_generate(p
, 1, 0, "pop");
136 reg_dst
= jvm_alloc_register_untyped(p
-> rf
, false);
137 jvm_generate(p
, 1, 0, "astore %i", reg_dst
);
140 * Входящие параметры заграблены.
141 * Теперь генерируем эквивалентный код:
143 * int len = dst.length
148 * dst[i, ...] = new record;
153 * Где "..." такой же код (начало и конец) для следующей размерности.
156 for(int i
= 0; i
< dim
; i
++)
158 loop
[i
].reg_index
= jvm_alloc_register_untyped(p
-> rf
, false);
159 loop
[i
].reg_length
= jvm_alloc_register_untyped(p
-> rf
, false);
160 loop
[i
].start
= jvm_new_label_id(p
);
161 loop
[i
].end
= jvm_new_label_id(p
);
163 jvm_generate(p
, 0, 1, "iconst_0");
164 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_index
);
166 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
167 jvm_generate(p
, 1, 1, "arraylength");
168 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_length
);
170 /* if(i >= len) goto end; */
171 jvm_generate_label(p
, loop
[i
].start
);
172 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
173 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_length
);
174 jvm_generate(p
, 2, 0, "if_icmpge L%i", loop
[i
].end
);
177 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
178 jvm_generate(p
, 0, 1, "iload %i", loop
[0].reg_index
);
179 for(int i
= 1; i
< dim
; i
++)
181 jvm_generate(p
, 2, 1, "aaload");
182 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
184 jvm_generate_new(p
, base
, 0);
185 jvm_generate(p
, 3, 0, "aastore");
187 for(int i
= dim
- 1; i
>= 0; i
--)
189 jvm_generate(p
, 0, 0, "iinc %i 1", loop
[i
].reg_index
);
190 jvm_generate(p
, 0, 0, "goto L%i", loop
[i
].start
);
191 jvm_generate_label(p
, loop
[i
].end
);
196 jvm_generate_new(gen_proc_t
* p
, oberon_type_t
* type
, int num
)
201 oberon_type_t
* base
;
203 switch(type
-> class)
205 case OBERON_TYPE_INTEGER
:
206 case OBERON_TYPE_BOOLEAN
:
207 case OBERON_TYPE_PROCEDURE
:
208 case OBERON_TYPE_REAL
:
209 case OBERON_TYPE_POINTER
:
210 gen_error("jvm_generate_new_static: static alocation not allowed");
212 case OBERON_TYPE_RECORD
:
214 cname
= jvm_get_class_full_name(type
);
215 jvm_generate(p
, 0, 1, "new %s", cname
);
216 jvm_generate(p
, 1, 2, "dup");
217 jvm_generate(p
, 1, 0, "invokespecial %s/<init>()V", cname
);
219 case OBERON_TYPE_ARRAY
:
222 desc
= jvm_get_descriptor(type
);
223 while(base
-> class == OBERON_TYPE_ARRAY
)
227 assert(base
-> size
== 0);
232 assert(base
-> size
> 0);
233 jvm_generate_push_int(p
, base
-> size
);
240 jvm_generate(p
, dim
, 1, "multianewarray %s %i", desc
, dim
);
241 jvm_generate(p
, 1, 2, "dup");
242 jvm_generate_array_initialization(p
, type
);
245 gen_error("jvm_generate_new_static: unk type class %i", type
-> class);
251 * Генерирует код для копирования полей из первой записи во вторую.
252 * ( aref_dst aref_src -- )
257 jvm_generate_copy_record(gen_proc_t
* p
, oberon_type_t
* rec
)
259 assert(rec
-> class == OBERON_TYPE_RECORD
);
260 char * desc
= jvm_get_descriptor(rec
);
261 char * cname
= jvm_get_class_full_name(rec
);
262 jvm_generate(p
, 1 + 1, 0, "invokestatic %s/$COPY$(%s%s)V", cname
, desc
, desc
);
266 * Генерирует кода для копирования массивов.
267 * ( aref_dst aref_src -- )
272 jvm_generate_copy_array(gen_proc_t
* p
, oberon_type_t
* arr
)
275 oberon_type_t
* base
= arr
;
276 while(base
-> class == OBERON_TYPE_ARRAY
)
289 int reg_dst
= jvm_alloc_register_untyped(p
-> rf
, false);
290 int reg_src
= jvm_alloc_register_untyped(p
-> rf
, false);
291 jvm_generate(p
, 1, 0, "astore %i", reg_src
);
292 jvm_generate(p
, 1, 0, "astore %i", reg_dst
);
295 * Входящие параметры заграблены.
296 * Теперь генерируем эквивалентный код:
298 * int len = src.length
303 * copy from src[i, ...] to dst[i, ...];
308 * Где "..." такой же код (начало и конец) для следующей размерности.
311 for(int i
= 0; i
< dim
; i
++)
313 loop
[i
].reg_index
= jvm_alloc_register_untyped(p
-> rf
, false);
314 loop
[i
].reg_length
= jvm_alloc_register_untyped(p
-> rf
, false);
315 loop
[i
].start
= jvm_new_label_id(p
);
316 loop
[i
].end
= jvm_new_label_id(p
);
318 jvm_generate(p
, 0, 1, "iconst_0");
319 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_index
);
321 jvm_generate(p
, 0, 1, "aload %i", reg_src
);
322 jvm_generate(p
, 1, 1, "arraylength");
323 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_length
);
325 /* if(i >= len) goto end; */
326 jvm_generate_label(p
, loop
[i
].start
);
327 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
328 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_length
);
329 jvm_generate(p
, 2, 0, "if_icmpge L%i", loop
[i
].end
);
332 if(base
-> class == OBERON_TYPE_RECORD
)
334 /* Получаем записи по индексам ( -- dst src ) */
336 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
337 for(int i
= 0; i
< dim
; i
++)
339 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
340 jvm_generate(p
, 2, 1, "aaload");
343 jvm_generate(p
, 0, 1, "aload %i", reg_src
);
344 for(int i
= 0; i
< dim
; i
++)
346 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
347 jvm_generate(p
, 2, 1, "aaload");
350 /* Копируем записи ( dst src -- ) */
351 jvm_generate_copy_record(p
, base
);
355 char postfix
= jvm_get_postfix(base
);
356 int cell_size
= jvm_cell_size_for_postfix(postfix
);
358 /* Получаем массивы и индексы ( -- dst i src i ) */
360 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
361 jvm_generate(p
, 0, 1, "iload %i", loop
[0].reg_index
);
362 for(int i
= 1; i
< dim
; i
++)
364 jvm_generate(p
, 2, 1, "aaload");
365 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
368 jvm_generate(p
, 0, 1, "aload %i", reg_src
);
369 jvm_generate(p
, 0, 1, "iload %i", loop
[0].reg_index
);
370 for(int i
= 1; i
< dim
; i
++)
372 jvm_generate(p
, 2, 1, "aaload");
373 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
376 /* Копируем значения ( dst i src i -- ) */
377 jvm_generate(p
, 2, cell_size
, "%caload", postfix
);
378 jvm_generate(p
, 2 + cell_size
, 0, "%castore", postfix
);
381 for(int i
= dim
- 1; i
>= 0; i
--)
383 jvm_generate(p
, 0, 0, "iinc %i 1", loop
[i
].reg_index
);
384 jvm_generate(p
, 0, 0, "goto L%i", loop
[i
].start
);
385 jvm_generate_label(p
, loop
[i
].end
);
390 jvm_generate_push_procedure_pointer(gen_proc_t
* p
, oberon_object_t
* proc
)
392 char * full_name
= jvm_get_field_full_name_safe(proc
);
393 char * desc
= jvm_get_descriptor(proc
-> type
);
394 jvm_generate(p
, 0, 1, "getstatic %s/pointer %s", full_name
, desc
);
398 oberon_generator_init_context(oberon_context_t
* ctx
)
400 gen_context_t
* gen_context
= GC_MALLOC(sizeof *gen_context
);
401 memset(gen_context
, 0, sizeof *gen_context
);
403 ctx
-> gen_context
= gen_context
;
404 gen_context
-> dir
= ".";
408 oberon_generator_destroy_context(oberon_context_t
* ctx
)
413 oberon_generate_procedure_class(const char * dir
, oberon_type_t
* proc
)
418 struct gen_class
* class;
420 cname
= jvm_get_class_full_name(proc
);
421 class = jvm_create_class(dir
, cname
);
424 fprintf(fp
, ".source SYSTEM\n");
425 fprintf(fp
, ".class public abstract %s\n", cname
);
426 fprintf(fp
, ".super java/lang/Object\n\n");
428 fprintf(fp
, ".method <init>()V\n");
429 fprintf(fp
, " aload_0\n");
430 fprintf(fp
, " invokespecial java/lang/Object/<init>()V\n");
431 fprintf(fp
, " return\n");
432 fprintf(fp
, ".end method\n\n");
434 signature
= jvm_get_procedure_signature(proc
);
436 fprintf(fp
, ".method public abstract invoke%s\n", signature
);
437 fprintf(fp
, ".end method\n\n");
439 jvm_destroy_class(class);
443 oberon_generate_procedure_pointer_class(const char * dir
, oberon_object_t
* proc
)
450 struct gen_class
* class;
452 cname
= jvm_get_field_full_name_safe(proc
);
453 class = jvm_create_class(dir
, cname
);
454 abscname
= jvm_get_class_full_name(proc
-> type
);
455 absdesc
= jvm_get_descriptor(proc
-> type
);
458 fprintf(fp
, ".source %s\n", proc
-> module
-> name
);
459 fprintf(fp
, ".class public %s\n", cname
);
460 fprintf(fp
, ".super %s\n\n", abscname
);
462 fprintf(fp
, ".field public static pointer %s\n\n", absdesc
);
464 fprintf(fp
, ".method private <init>()V\n");
465 fprintf(fp
, " aload_0\n");
466 fprintf(fp
, " invokespecial %s/<init>()V\n", abscname
);
467 fprintf(fp
, " return\n");
468 fprintf(fp
, ".end method\n\n");
470 fprintf(fp
, ".method static <clinit>()V\n");
471 fprintf(fp
, " .limit stack 2\n");
472 fprintf(fp
, " new %s\n", cname
);
473 fprintf(fp
, " dup\n");
474 fprintf(fp
, " invokespecial %s/<init>()V\n", cname
);
475 fprintf(fp
, " putstatic %s/pointer %s\n", cname
, absdesc
);
476 fprintf(fp
, " return\n");
477 fprintf(fp
, ".end method\n\n");
479 signature
= jvm_get_procedure_signature(proc
-> type
);
481 gen_proc_t
* p
= jvm_create_proc(class);
482 jvm_generate_function_header(p
, "public", "invoke", signature
);
483 jvm_alloc_register_untyped(p
-> rf
, false);
486 int num
= proc
-> type
-> num_decl
;
487 oberon_object_t
* param
= proc
-> type
-> decl
;
488 for(int i
= 0; i
< num
; i
++)
490 gen_type_t
* t
= param
-> type
-> gen_type
;
491 if(param
-> class == OBERON_CLASS_VAR_PARAM
)
493 int reg
= jvm_alloc_register_untyped(p
-> rf
, true);
494 jvm_generate(p
, 0, 1, "aload %i", reg
);
495 jvm_generate(p
, 0, 1, "iload %i", reg
+ 1);
499 int reg
= jvm_alloc_register_untyped(p
-> rf
, t
-> wide
);
500 jvm_generate(p
, 0, t
-> cell_size
, "%cload %i", t
-> prefix
, reg
);
502 use_size
+= t
-> cell_size
;
503 param
= param
-> next
;
506 char * full_name
= jvm_get_field_full_name(proc
);
507 int cell_size
= jvm_cell_size_for_type(proc
-> type
-> base
);
508 jvm_generate(p
, use_size
, cell_size
, "invokestatic %s%s", full_name
, signature
);
510 if(proc
-> type
-> base
-> class == OBERON_TYPE_NOTYPE
)
512 jvm_generate(p
, 0, 0, "return");
516 char prefix
= jvm_get_prefix(proc
-> type
-> base
);
517 jvm_generate(p
, cell_size
, 0, "%creturn", prefix
);
520 jvm_generate_function_end(p
);
522 jvm_destroy_class(class);
526 oberon_generate_record_class(const char * dir
, gen_module_t
* m
, oberon_type_t
* rec
)
529 struct gen_class
* class;
531 /* Устанавливаем новоый id */
532 rec
-> gen_type
-> rec_id
= m
-> rec_id
;
535 cname
= jvm_get_class_full_name(rec
);
536 class = jvm_create_class(dir
, cname
);
538 fprintf(class -> fp
, ".source %s\n", rec
-> module
-> name
);
539 fprintf(class -> fp
, ".class public %s\n", cname
);
541 if(rec
-> base
== NULL
)
543 fprintf(class -> fp
, ".super java/lang/Object\n\n");
547 class -> base
= rec
-> base
-> gen_type
-> class;
548 fprintf(class -> fp
, ".super %s\n\n", class -> base
-> full_name
);
551 rec
-> gen_type
-> class = class;
555 oberon_generator_init_type(oberon_context_t
* ctx
, oberon_type_t
* type
)
557 gen_type_t
* t
= GC_MALLOC(sizeof *t
);
558 memset(t
, 0, sizeof *t
);
559 type
-> gen_type
= t
;
562 c
= ctx
-> gen_context
;
565 switch(type
-> class)
567 case OBERON_TYPE_NOTYPE
:
568 case OBERON_TYPE_INTEGER
:
569 case OBERON_TYPE_BOOLEAN
:
570 case OBERON_TYPE_ARRAY
:
571 case OBERON_TYPE_POINTER
:
572 case OBERON_TYPE_REAL
:
573 case OBERON_TYPE_CHAR
:
574 case OBERON_TYPE_STRING
:
575 case OBERON_TYPE_SET
:
576 case OBERON_TYPE_NIL
:
577 case OBERON_TYPE_SYSTEM_BYTE
:
578 case OBERON_TYPE_SYSTEM_PTR
:
580 case OBERON_TYPE_RECORD
:
581 m
= type
-> module
-> gen_mod
;
582 oberon_generate_record_class(c
-> dir
, m
, type
);
584 case OBERON_TYPE_PROCEDURE
:
585 oberon_generate_procedure_class(c
-> dir
, type
);
588 gen_error("oberon_generator_init_type: unk calss %i", type
-> class);
592 if(type
-> class != OBERON_TYPE_NOTYPE
)
594 t
-> wide
= jvm_is_wide_type(type
);
595 t
-> prefix
= jvm_get_prefix(type
);
596 t
-> postfix
= jvm_get_postfix(type
);
599 t
-> cell_size
= jvm_cell_size_for_type(type
);
601 if(type
-> class != OBERON_TYPE_NIL
)
603 t
-> desc
= jvm_get_descriptor(type
);
608 oberon_generator_init_record(oberon_context_t
* ctx
, oberon_type_t
* rec
)
610 struct gen_class
* class;
611 class = rec
-> gen_type
-> class;
613 int num
= rec
-> num_decl
;
614 oberon_object_t
* field
= rec
-> decl
;
615 for(int i
= 0; i
< num
; i
++)
617 jvm_generate_var(field
-> gen_var
);
618 field
= field
-> next
;
621 /* Стандартный конструктор класса */
622 /* Инициализирует внутренние статические записи и массивы */
623 gen_proc_t
* p
= jvm_create_proc(class);
624 jvm_generate_function_header(p
, "public", "<init>", "()V");
625 jvm_alloc_register_untyped(p
-> rf
, false);
626 jvm_generate(p
, 0, 1, "aload_0");
629 jvm_generate(p
, 1, 0, "invokespecial %s/<init>()V", class -> base
-> full_name
);
633 jvm_generate(p
, 1, 0, "invokespecial java/lang/Object/<init>()V");
635 num
= rec
-> num_decl
;
637 for(int i
= 0; i
< num
; i
++)
639 jvm_generate(p
, 0, 1, "aload_0");
640 jvm_generate_var_initialization(p
, field
-> gen_var
);
642 if(field
-> type
-> class == OBERON_TYPE_RECORD
643 || field
-> type
-> class == OBERON_TYPE_ARRAY
)
645 jvm_generate(p
, 0, 1, "aload_0");
646 jvm_generate_ldst_prepare(p
, field
-> gen_var
);
647 jvm_generate_new(p
, field
-> type
, 0);
648 jvm_generate_store(p
, field
-> gen_var
);
650 field
= field
-> next
;
652 jvm_generate(p
, 0, 0, "return");
653 jvm_generate_function_end(p
);
655 /* Метод для копирования полей класса */
656 /* reg0 == src -> reg1 == dst */
657 p
= jvm_create_proc(class);
658 char * signature
= new_string("(%s%s)V", rec
-> gen_type
-> desc
, rec
-> gen_type
-> desc
);
659 jvm_generate_function_header(p
, "public static", "$COPY$", signature
);
661 gen_var_t
* copy_dst
= jvm_create_function_var(p
, JVM_STORAGE_REGISTER
, "dst", rec
-> gen_type
);
662 gen_var_t
* copy_src
= jvm_create_function_var(p
, JVM_STORAGE_REGISTER
, "src", rec
-> gen_type
);
663 jvm_generate_var(copy_dst
);
664 jvm_generate_var(copy_src
);
665 jvm_generate_var_initialization(p
, copy_dst
);
666 jvm_generate_var_initialization(p
, copy_src
);
670 jvm_generate_load(p
, copy_dst
);
671 jvm_generate_load(p
, copy_src
);
672 jvm_generate_copy_record(p
, rec
-> base
);
675 num
= rec
-> num_decl
;
677 for(int i
= 0; i
< num
; i
++)
679 if(field
-> type
-> class == OBERON_TYPE_RECORD
)
681 jvm_generate_load(p
, copy_dst
);
682 jvm_generate_load(p
, field
-> gen_var
);
683 jvm_generate_load(p
, copy_src
);
684 jvm_generate_load(p
, field
-> gen_var
);
685 jvm_generate_copy_record(p
, field
-> type
);
687 else if(field
-> type
-> class == OBERON_TYPE_ARRAY
)
689 jvm_generate_load(p
, copy_dst
);
690 jvm_generate_load(p
, field
-> gen_var
);
691 jvm_generate_load(p
, copy_src
);
692 jvm_generate_load(p
, field
-> gen_var
);
693 jvm_generate_copy_array(p
, field
-> type
);
697 jvm_generate_load(p
, copy_dst
);
698 jvm_generate_ldst_prepare(p
, field
-> gen_var
);
699 jvm_generate_load(p
, copy_src
);
700 jvm_generate_load(p
, field
-> gen_var
);
701 jvm_generate_store(p
, field
-> gen_var
);
703 field
= field
-> next
;
705 jvm_generate(p
, 0, 0, "return");
706 jvm_generate_function_end(p
);
708 jvm_destroy_class(class);
712 oberon_generator_init_var(oberon_context_t
* ctx
, oberon_object_t
* var
)
715 m
= ctx
-> mod
-> gen_mod
;
717 struct gen_class
* class;
721 struct gen_class
* c
;
722 char * name
= var
-> name
;
723 gen_type_t
* t
= var
-> type
-> gen_type
;
728 gen_error("uninitialized type class %i", var
-> type
-> class);
733 case OBERON_CLASS_VAR_PARAM
:
734 p
= var
-> parent
-> gen_proc
;
735 var
-> gen_var
= jvm_create_function_var(p
, JVM_STORAGE_FRAME_PARAM_VARPTR
, name
, t
);
737 case OBERON_CLASS_PARAM
:
738 p
= var
-> parent
-> gen_proc
;
739 var
-> gen_var
= jvm_create_function_var(p
, JVM_STORAGE_FRAME_PARAM_VAR
, name
, t
);
741 case OBERON_CLASS_FIELD
:
742 c
= var
-> parent_type
-> gen_type
-> class;
743 var
-> gen_var
= jvm_create_class_var(c
, JVM_STORAGE_FIELD_VAR
, name
, t
);
745 case OBERON_CLASS_VAR
:
748 p
= var
-> parent
-> gen_proc
;
749 var
-> gen_var
= jvm_create_function_var(p
, JVM_STORAGE_FRAME_VAR
, name
, t
);
753 var
-> gen_var
= jvm_create_class_var(class, JVM_STORAGE_STATIC_VAR
, name
, t
);
754 jvm_generate_var(var
-> gen_var
);
758 gen_error("oberon_generator_init_var: unk var class %i", var
-> class);
764 oberon_generator_init_temp_var(oberon_context_t
* ctx
, oberon_object_t
* var
)
766 assert(var
-> class == OBERON_CLASS_VAR
);
769 m
= ctx
-> mod
-> gen_mod
;
775 t
= var
-> type
-> gen_type
;
777 var
-> gen_var
= jvm_create_function_temp_var(p
, t
);
778 jvm_generate_var(var
-> gen_var
);
779 jvm_generate_var_initialization(p
, var
-> gen_var
);
783 oberon_generator_init_proc(oberon_context_t
* ctx
, oberon_object_t
* proc
)
785 struct gen_class
* class = proc
-> module
-> gen_mod
-> class;
786 proc
-> gen_proc
= jvm_create_proc(class);
787 proc
-> gen_proc
-> full_name
= jvm_get_field_full_name_safe(proc
);
788 jvm_create_static_links(proc
);
792 oberon_generator_init_module(oberon_context_t
* ctx
, oberon_module_t
* mod
)
794 gen_module_t
* m
= GC_MALLOC(sizeof *m
);
795 memset(m
, 0, sizeof *m
);
799 c
= ctx
-> gen_context
;
801 struct gen_class
* class;
802 class = jvm_create_class(c
-> dir
, mod
-> name
);
804 fprintf(class -> fp
, ".source %s\n", mod
-> name
);
805 fprintf(class -> fp
, ".class %s\n", mod
-> name
);
806 fprintf(class -> fp
, ".super java/lang/Object\n\n");
808 fprintf(class -> fp
, ".field private static $INITIALIZED$ Z\n\n");
816 oberon_generator_fini_module(oberon_module_t
* mod
)
818 jvm_destroy_class(mod
-> gen_mod
-> class);
822 push_expr(gen_proc_t
* p
, oberon_expr_t
* expr
);
825 oberon_generate_static_initialization(gen_proc_t
* p
, oberon_object_t
* x
)
827 if(x
-> type
-> class == OBERON_TYPE_ARRAY
828 || x
-> type
-> class == OBERON_TYPE_RECORD
)
830 jvm_generate_ldst_prepare(p
, x
-> gen_var
);
831 jvm_generate_new(p
, x
-> type
, 0);
832 jvm_generate_store(p
, x
-> gen_var
);
837 oberon_generate_begin_module(oberon_context_t
* ctx
)
841 struct gen_class
* class;
843 class = ctx
-> mod
-> gen_mod
-> class;
845 p
= jvm_create_proc(class);
846 jvm_generate_function_header(p
, "public static", "BEGIN", "()V");
848 label_cont
= jvm_new_label_id(p
);
849 jvm_generate(p
, 0, 1, "getstatic %s/$INITIALIZED$ Z", class -> full_name
);
850 jvm_generate(p
, 1, 0, "ifeq L%i", label_cont
);
851 jvm_generate(p
, 0, 0, "return");
852 jvm_generate_label(p
, label_cont
);
854 jvm_generate(p
, 0, 1, "iconst_1");
855 jvm_generate(p
, 1, 0, "putstatic %s/$INITIALIZED$ Z", class -> full_name
);
857 /* Инициализация переменных объявленных в модуле */
858 oberon_object_t
* x
= ctx
-> mod
-> decl
-> list
-> next
;
861 if(x
-> class == OBERON_CLASS_MODULE
)
863 if(!x
-> module
-> intrinsic
)
865 jvm_generate(p
, 0, 0, "invokestatic %s/BEGIN()V", x
-> module
-> gen_mod
-> class -> full_name
);
868 else if(x
-> class == OBERON_CLASS_VAR
)
870 jvm_generate_var_initialization(p
, x
-> gen_var
);
871 oberon_generate_static_initialization(p
, x
);
879 oberon_generate_end_module(oberon_context_t
* ctx
)
881 struct gen_class
* class = ctx
-> mod
-> gen_mod
-> class;
882 gen_proc_t
* p
= class -> p
;
884 jvm_generate(p
, 0, 0, "return");
885 jvm_generate_function_end(class -> p
);
887 p
= jvm_create_proc(class);
888 jvm_generate_function_header(p
, "private", "<init>", "()V");
889 jvm_alloc_register_untyped(p
-> rf
, false);
890 jvm_generate(p
, 0, 1, "aload_0");
891 jvm_generate(p
, 1, 0, "invokespecial java/lang/Object/<init>()V");
892 jvm_generate(p
, 0, 0, "return");
893 jvm_generate_function_end(class -> p
);
897 * Генерирует код для получения размера измерения массива
898 * Аналог Обероновского LEN(v, n); где n = 0 - первое измерение.
903 jvm_generate_array_len(gen_proc_t
* p
, int dim
)
907 jvm_generate(p
, 0, 1, "iconst_0");
908 jvm_generate(p
, 2, 1, "aaload");
911 jvm_generate(p
, 1, 1, "arraylength");
915 jvm_generate_array_duplicate_and_replace(gen_proc_t
* p
, gen_var_t
* v
, oberon_type_t
* arr
)
917 jvm_generate_ldst_prepare(p
, v
);
920 oberon_type_t
* base
= arr
;
921 while(base
-> class == OBERON_TYPE_ARRAY
)
923 if(base
-> size
== 0)
925 jvm_generate_load(p
, v
);
926 jvm_generate_array_len(p
, dim
);
932 jvm_generate_new(p
, arr
, dim
);
933 jvm_generate(p
, 1, 2, "dup");
934 jvm_generate_load(p
, v
);
935 jvm_generate_copy_array(p
, arr
);
936 jvm_generate_store(p
, v
);
940 jvm_generate_record_duplicate_and_replace(gen_proc_t
* p
, gen_var_t
* v
, oberon_type_t
* rec
)
942 jvm_generate_ldst_prepare(p
, v
);
943 jvm_generate_new(p
, rec
, 0);
944 jvm_generate(p
, 1, 2, "dup");
945 jvm_generate_load(p
, v
);
946 jvm_generate_copy_record(p
, rec
);
947 jvm_generate_store(p
, v
);
951 jvm_generate_local_object(gen_proc_t
* p
, oberon_object_t
* x
)
954 struct gen_class
* class;
959 // Убеждаемся что сейчас находимся в функции
965 case OBERON_CLASS_VAR_PARAM
:
966 case OBERON_CLASS_PARAM
:
967 case OBERON_CLASS_VAR
:
970 case OBERON_CLASS_CONST
:
971 case OBERON_CLASS_TYPE
:
972 case OBERON_CLASS_PROC
:
975 gen_error("jvm_generate_local_initialization: wat class %i", x
-> class);
981 jvm_generate_local_initialization(gen_proc_t
* p
, oberon_object_t
* x
)
984 struct gen_class
* class;
989 // Убеждаемся что сейчас находимся в функции
995 case OBERON_CLASS_VAR_PARAM
:
996 jvm_generate_var_initialization(p
, v
);
998 case OBERON_CLASS_PARAM
:
999 jvm_generate_var_initialization(p
, v
);
1000 if(x
-> type
-> class == OBERON_TYPE_ARRAY
)
1002 jvm_generate_array_duplicate_and_replace(p
, v
, x
-> type
);
1004 else if(x
-> type
-> class == OBERON_TYPE_RECORD
)
1006 jvm_generate_record_duplicate_and_replace(p
, v
, x
-> type
);
1009 case OBERON_CLASS_VAR
:
1010 jvm_generate_var_initialization(p
, v
);
1011 oberon_generate_static_initialization(p
, x
);
1013 case OBERON_CLASS_CONST
:
1014 case OBERON_CLASS_TYPE
:
1015 case OBERON_CLASS_PROC
:
1018 gen_error("jvm_generate_local_initialization: wat class %i", x
-> class);
1024 oberon_generate_begin_proc(oberon_context_t
* ctx
, oberon_object_t
* proc
)
1029 oberon_object_t
* var
;
1031 p
= proc
-> gen_proc
;
1035 signature
= jvm_get_local_procedure_signature(proc
);
1039 oberon_generate_procedure_pointer_class(p
-> class -> dir
, proc
);
1040 signature
= jvm_get_procedure_signature(proc
-> type
);
1043 name
= jvm_get_name(proc
);
1044 jvm_generate_function_header(p
, "public static", name
, signature
);
1048 jvm_generate_staticlinks(proc
);
1051 jvm_generate_procedure_frame(proc
);
1053 /* Создание параметров и переменных */
1054 var
= proc
-> scope
-> list
-> next
;
1057 jvm_generate_local_object(p
, var
);
1061 jvm_generate_frame_initialization(p
);
1063 /* Инициализация парамеров и переменных */
1064 var
= proc
-> scope
-> list
-> next
;
1067 jvm_generate_local_initialization(p
, var
);
1073 oberon_generate_end_proc(oberon_context_t
* ctx
)
1078 m
= ctx
-> mod
-> gen_mod
;
1079 p
= m
-> class -> p
;
1081 oberon_generate_trap(ctx
, -4);
1082 jvm_generate_function_end(p
);
1086 oberon_generator_reserve_label(oberon_context_t
* ctx
)
1092 m
= ctx
-> mod
-> gen_mod
;
1093 p
= m
-> class -> p
;
1095 l
= GC_MALLOC(sizeof *l
);
1096 memset(l
, 0, sizeof *l
);
1098 l
-> id
= jvm_new_label_id(p
);
1103 oberon_generate_label(oberon_context_t
* ctx
, gen_label_t
* l
)
1108 m
= ctx
-> mod
-> gen_mod
;
1109 p
= m
-> class -> p
;
1111 jvm_generate_label(p
, l
-> id
);
1115 oberon_generate_goto(oberon_context_t
* ctx
, gen_label_t
* l
)
1120 m
= ctx
-> mod
-> gen_mod
;
1121 p
= m
-> class -> p
;
1123 jvm_generate(p
, 0, 0, "goto L%i", l
-> id
);
1127 oberon_generate_branch(oberon_context_t
* ctx
, oberon_expr_t
* cond
, bool gotoif
, gen_label_t
* l
)
1132 m
= ctx
-> mod
-> gen_mod
;
1133 p
= m
-> class -> p
;
1139 /* переход если false */
1140 jvm_generate(p
, 1, 0, "ifeq L%i", l
-> id
);
1144 /* переход если true */
1145 jvm_generate(p
, 1, 0, "ifne L%i", l
-> id
);
1150 check_index(gen_proc_t
* p
, oberon_type_t
* index_type
)
1152 // TODO проверка валидности границ
1153 char prefix
= jvm_get_prefix(index_type
);
1154 jvm_generate_cast_prefix(p
, prefix
, 'i');
1158 push_varptr(gen_proc_t
* p
, oberon_expr_t
* expr
)
1160 assert(expr
-> is_item
);
1162 switch(expr
-> item
.mode
)
1165 jvm_generate_ldst_prepare(p
, expr
-> item
.var
-> gen_var
);
1168 push_item(p
, expr
-> item
.parent
);
1169 push_expr(p
, expr
-> item
.args
);
1170 check_index(p
, expr
-> item
.args
-> result
);
1173 push_item(p
, expr
-> item
.parent
);
1174 jvm_generate_ldst_prepare(p
, expr
-> item
.var
-> gen_var
);
1177 push_varptr(p
, (oberon_expr_t
*) expr
-> item
.parent
);
1180 gen_error("push_varptr: wat %i", expr
-> item
.mode
);
1186 jvm_generate_call_proc(gen_proc_t
* p
, oberon_item_t
* desig
)
1188 assert(desig
-> var
== NULL
);
1189 assert(desig
-> mode
== MODE_CALL
);
1191 bool direct_call
= false;
1192 if(desig
-> parent
-> mode
== MODE_VAR
)
1194 if(desig
-> parent
-> var
-> class == OBERON_CLASS_PROC
)
1200 oberon_type_t
* procsig
;
1201 procsig
= desig
-> parent
-> result
;
1203 if(direct_call
== false)
1205 /* Загружаем указатель на процедуру */
1206 push_item(p
, desig
-> parent
);
1211 jvm_generate_push_static_links(p
, desig
-> parent
-> var
);
1215 int result_cells
= jvm_cell_size_for_type(procsig
-> base
);
1217 int num
= desig
-> num_args
;
1218 oberon_expr_t
* arg
= desig
-> args
;
1219 oberon_object_t
* param
= procsig
-> decl
;
1220 for(int i
= 0; i
< num
; i
++)
1222 if(param
-> class == OBERON_CLASS_VAR_PARAM
)
1225 push_varptr(p
, arg
);
1229 args_cells
+= jvm_cell_size_for_type(arg
-> result
);
1233 param
= param
-> next
;
1238 char * full_name
= jvm_get_field_full_name(desig
-> parent
-> var
);
1239 char * signature
= jvm_get_local_procedure_signature(desig
-> parent
-> var
);
1240 jvm_generate(p
, args_cells
, result_cells
, "invokestatic %s%s", full_name
, signature
);
1244 char * cname
= jvm_get_class_full_name(procsig
);
1245 char * signature
= jvm_get_procedure_signature(procsig
);
1246 jvm_generate(p
, 1 + args_cells
, result_cells
, "invokevirtual %s/invoke%s", cname
, signature
);
1251 oberon_generate_call_proc(oberon_context_t
* ctx
, oberon_expr_t
* desig
)
1253 assert(desig
-> is_item
);
1254 jvm_generate_call_proc(ctx
-> mod
-> gen_mod
-> class -> p
, (oberon_item_t
*) desig
);
1258 oberon_generate_return(oberon_context_t
* ctx
, oberon_expr_t
* expr
)
1265 m
= ctx
-> mod
-> gen_mod
;
1266 p
= m
-> class -> p
;
1271 prefix
= jvm_get_prefix(expr
-> result
);
1272 cell_size
= jvm_cell_size_for_type(expr
-> result
);
1273 jvm_generate(p
, cell_size
, 0, "%creturn", prefix
);
1277 jvm_generate(p
, 0, 0, "return");
1282 jvm_generate_expr_new_pointer(gen_proc_t
* p
, oberon_type_t
* type
, int num
, oberon_expr_t
* arg
)
1284 assert(type
-> class == OBERON_TYPE_POINTER
);
1286 for(int i
= 0; i
< num
; i
++)
1292 jvm_generate_new(p
, type
-> base
, num
);
1296 push_item(gen_proc_t
* p
, oberon_item_t
* item
)
1298 switch(item
-> mode
)
1301 if(item
-> var
-> class == OBERON_CLASS_PROC
)
1303 jvm_generate_push_procedure_pointer(p
, item
-> var
);
1307 jvm_generate_load(p
, item
-> var
-> gen_var
);
1314 jvm_generate_push_int_size(p
, item
-> integer
, item
-> result
-> size
);
1317 jvm_generate_call_proc(p
, item
);
1321 char postfix
= jvm_get_postfix(item
-> result
);
1322 int cell_size
= jvm_cell_size_for_postfix(postfix
);
1323 push_item(p
, item
-> parent
);
1324 push_expr(p
, item
-> args
);
1325 check_index(p
, item
-> args
-> result
);
1326 jvm_generate(p
, 1 + 1, cell_size
, "%caload", postfix
);
1329 push_item(p
, item
-> parent
);
1330 jvm_generate_load(p
, item
-> var
-> gen_var
);
1333 /* Все объекты в jvm представляются как указатели */
1334 push_item(p
, item
-> parent
);
1337 jvm_generate(p
, 0, 1, "aconst_null");
1340 jvm_generate_expr_new_pointer(p
, item
-> result
, item
-> num_args
, item
-> args
);
1343 jvm_generate_push_float(p
, item
-> real
, item
-> result
-> size
);
1346 jvm_generate_push_string(p
, item
-> string
, item
-> result
-> size
);
1349 push_item(p
, item
-> parent
);
1350 jvm_generate_array_len(p
, item
-> integer
);
1351 jvm_generate_cast_prefix(p
, 'i', jvm_get_postfix(item
-> result
));
1354 gen_error("push_item: unk mode %i", item
-> mode
);
1360 jvm_generate_logical_not(gen_proc_t
* p
)
1362 int label_done
= jvm_new_label_id(p
);
1363 int label_false
= jvm_new_label_id(p
);
1365 jvm_generate(p
, 1, 0, "ifne L%i", label_false
);
1366 jvm_generate(p
, 0, 1, "iconst_1");
1367 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1368 jvm_generate_label(p
, label_false
);
1369 jvm_generate(p
, 0, 1, "iconst_0");
1370 jvm_generate_label(p
, label_done
);
1374 jvm_generate_abs(gen_proc_t
* p
, char prefix
)
1376 char t
= jvm_get_type_of_prefix(prefix
);
1377 int cell_size
= jvm_cell_size_for_postfix(prefix
);
1378 jvm_generate(p
, cell_size
, cell_size
, "invokestatic java/lang/Math/abs(%c)%c", t
, t
);
1382 jvm_get_compare_postfix(int op
)
1406 gen_error("jvm_generate_compare_op: wat");
1413 jvm_generate_compare_op(gen_proc_t
* p
, oberon_type_t
* t
, int op
)
1415 char prefix
= jvm_get_prefix(t
);
1416 int label_true
= jvm_new_label_id(p
);
1417 int label_done
= jvm_new_label_id(p
);
1418 int cell_size
= jvm_cell_size_for_type(t
);
1419 char * cmpop
= jvm_get_compare_postfix(op
);
1423 jvm_generate(p
, 2 * cell_size
, 1, "lcmp");
1424 jvm_generate(p
, 1, 1, "if%s L%i", cmpop
, label_true
);
1426 else if(prefix
== 'f' || prefix
== 'd')
1429 if(op
== OP_EQ
|| op
== OP_NEQ
|| op
== OP_GRT
|| op
== OP_GEQ
)
1437 jvm_generate(p
, 2 * cell_size
, 1, "%ccmp%c", prefix
, fop
);
1438 jvm_generate(p
, 1, 1, "if%s L%i", cmpop
, label_true
);
1440 else if(prefix
== 'a')
1442 if(t
-> class == OBERON_TYPE_STRING
1443 || (t
-> class == OBERON_TYPE_POINTER
&& t
-> base
-> class == OBERON_TYPE_CHAR
))
1445 jvm_generate(p
, 2, 1, "invokestatic SYSTEM/STRCMP([B[B)I");
1446 jvm_generate(p
, 1, 0, "if%s L%i", cmpop
, label_true
);
1450 jvm_generate(p
, 1, 0, "if_acmp%s L%i", cmpop
, label_true
);
1455 jvm_generate(p
, 2 * cell_size
, 0, "if_%ccmp%s L%i", prefix
, cmpop
, label_true
);
1458 jvm_generate(p
, 0, 1, "iconst_0");
1459 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1460 jvm_generate_label(p
, label_true
);
1461 jvm_generate(p
, 0, 1, "iconst_1");
1462 jvm_generate_label(p
, label_done
);
1466 jvm_generate_operator(gen_proc_t
* p
, oberon_type_t
* t
, int op
)
1468 char prefix
= jvm_get_prefix(t
);
1469 int cell_size
= jvm_cell_size_for_type(t
);
1472 case OP_UNARY_MINUS
:
1473 jvm_generate(p
, cell_size
, cell_size
, "%cneg", prefix
);
1475 case OP_COMPLEMENTATION
:
1476 jvm_generate_push_int_size(p
, -1, t
-> size
);
1477 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cxor", prefix
);
1480 jvm_generate_logical_not(p
);
1483 jvm_generate_abs(p
, prefix
);
1486 jvm_generate(p
, cell_size
, cell_size
, "invokestatic java/lang/Character/toUpperCase(I)I");
1490 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cadd", prefix
);
1493 jvm_generate(p
, 2 * cell_size
, cell_size
, "%csub", prefix
);
1496 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cmul", prefix
);
1499 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cdiv", prefix
);
1502 jvm_generate(p
, 2 * cell_size
, cell_size
, "%crem", prefix
);
1505 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cor", prefix
);
1507 case OP_INTERSECTION
:
1508 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cand", prefix
);
1511 /* (a - b) == a & ~b */
1512 jvm_generate_push_int_size(p
, -1, t
-> size
);
1513 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cxor", prefix
);
1514 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cand", prefix
);
1516 case OP_SYM_DIFFERENCE
:
1517 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cxor", prefix
);
1526 jvm_generate_compare_op(p
, t
, op
);
1529 gen_error("jvm_generate_operator: unk op %i", op
);
1535 jvm_generate_logical_or(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1537 int label_calc_b
= jvm_new_label_id(p
);
1538 int label_done
= jvm_new_label_id(p
);
1540 /* a OR b -- если a, то TRUE, иначе b */
1543 jvm_generate(p
, 1, 0, "ifeq L%i", label_calc_b
);
1544 jvm_generate(p
, 0, 1, "iconst_1");
1545 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1546 jvm_generate_label(p
, label_calc_b
);
1548 jvm_generate_label(p
, label_done
);
1552 jvm_generate_logical_and(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1554 int label_false
= jvm_new_label_id(p
);
1555 int label_done
= jvm_new_label_id(p
);
1557 /* a AND b -- если a, то b, иначе FALSE */
1560 jvm_generate(p
, 1, 0, "ifeq L%i", label_false
);
1562 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1563 jvm_generate_label(p
, label_false
);
1564 jvm_generate(p
, 0, 1, "iconst_0");
1565 jvm_generate_label(p
, label_done
);
1569 jvm_generate_range(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1571 /* { a } == 1 << a */
1572 /* { a..b } == (a <= b) ? ((2 << b) - (1 << a)) : (0); */
1576 oberon_type_t
* type
;
1583 cell_size
= jvm_cell_size_for_type(type
);
1584 prefix
= jvm_get_prefix(type
);
1588 jvm_generate_push_int_size(p
, 1, type
-> size
);
1590 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1594 ra
= jvm_create_function_temp_var(p
, type
-> gen_type
);
1595 rb
= jvm_create_function_temp_var(p
, type
-> gen_type
);
1596 jvm_generate_var(ra
);
1597 jvm_generate_var(rb
);
1598 jvm_generate_var_initialization(p
, ra
);
1599 jvm_generate_var_initialization(p
, rb
);
1600 label_else
= jvm_new_label_id(p
);
1601 label_end
= jvm_new_label_id(p
);
1604 jvm_generate_store(p
, ra
);
1606 jvm_generate_store(p
, rb
);
1608 jvm_generate_load(p
, ra
);
1609 jvm_generate_load(p
, rb
);
1610 jvm_generate(p
, 2 * cell_size
, 0, "if_%ccmpgt L%i", prefix
, label_else
);
1612 jvm_generate_push_int_size(p
, 2, type
-> size
);
1613 jvm_generate_load(p
, rb
);
1614 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1615 jvm_generate_push_int_size(p
, 2, type
-> size
);
1616 jvm_generate_load(p
, ra
);
1617 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1618 jvm_generate(p
, 2 * cell_size
, cell_size
, "%csub", prefix
);
1619 jvm_generate(p
, 0, 0, "goto L%i", label_end
);
1621 jvm_generate_label(p
, label_else
);
1622 jvm_generate_push_int_size(p
, 0, type
-> size
);
1623 jvm_generate_label(p
, label_end
);
1626 /* TODO free registers */
1630 jvm_generate_in(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1632 oberon_type_t
* t
= a
-> result
;
1633 int cell_size
= jvm_cell_size_for_type(t
);
1634 char prefix
= jvm_get_prefix(t
);
1635 int label_else
= jvm_new_label_id(p
);
1636 int label_end
= jvm_new_label_id(p
);
1638 /* (a IN b) == (1 << a) & b */
1639 jvm_generate_push_int_size(p
, 1, t
-> size
);
1641 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1643 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cand", prefix
);
1647 jvm_generate(p
, cell_size
, 0, "lcmp");
1650 jvm_generate(p
, 1, 0, "ifeq L%i", label_else
);
1651 jvm_generate(p
, 0, 1, "iconst_1");
1652 jvm_generate(p
, 0, 0, "goto L%i", label_end
);
1653 jvm_generate_label(p
, label_else
);
1654 jvm_generate(p
, 0, 1, "iconst_0");
1655 jvm_generate_label(p
, label_end
);
1659 jvm_generate_shift(gen_proc_t
* p
, int op
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1661 oberon_type_t
* t
= a
-> result
;
1662 int cell_size
= jvm_cell_size_for_type(t
);
1663 char prefix
= jvm_get_prefix(t
);
1664 char dt
= jvm_get_type_of_prefix(prefix
);
1667 jvm_generate_cast_type(p
, a
-> result
, t
);
1669 jvm_generate_cast_type(p
, b
-> result
, t
);
1684 gen_error("jvm_generate_shift: invalid op %i", op
);
1687 jvm_generate(p
, 2 * cell_size
, cell_size
, "invokestatic SYSTEM/%s(%c%c)%c", opname
, dt
, dt
, dt
);
1691 jvm_generate_entier(gen_proc_t
* p
, oberon_expr_t
* x
, oberon_type_t
* res
)
1693 char prefix
= jvm_get_prefix(x
-> result
);
1694 char postfix
= jvm_get_postfix(res
);
1697 jvm_generate_cast_prefix(p
, prefix
, 'd');
1698 jvm_generate(p
, 2, 2, "invokestatic java/lang/Math/floor(D)D");
1699 jvm_generate_cast_prefix(p
, 'd', postfix
);
1703 push_operator(gen_proc_t
* p
, oberon_oper_t
* oper
)
1705 oberon_type_t
* preq
= oper
-> left
-> result
;
1706 int op
= oper
-> op
;
1710 push_expr(p
, oper
-> left
);
1711 jvm_generate_cast_type(p
, oper
-> left
-> result
, oper
-> result
);
1714 push_expr(p
, oper
-> left
);
1715 jvm_generate_hard_cast_type(p
, oper
-> left
-> result
, oper
-> result
);
1717 case OP_COMPLEMENTATION
:
1718 case OP_UNARY_MINUS
:
1722 push_expr(p
, oper
-> left
);
1723 jvm_generate_operator(p
, preq
, op
);
1726 jvm_generate_entier(p
, oper
-> left
, oper
-> result
);
1736 case OP_INTERSECTION
:
1738 case OP_SYM_DIFFERENCE
:
1746 push_expr(p
, oper
-> left
);
1747 push_expr(p
, oper
-> right
);
1748 jvm_generate_operator(p
, preq
, op
);
1752 jvm_generate_logical_or(p
, oper
-> left
, oper
-> right
);
1755 jvm_generate_logical_and(p
, oper
-> left
, oper
-> right
);
1759 preq
= oper
-> right
-> result
;
1760 char * cname
= jvm_get_class_full_name(preq
);
1761 push_expr(p
, oper
-> left
);
1762 jvm_generate(p
, 1, 1, "instanceof %s", cname
);
1765 jvm_generate_range(p
, oper
-> left
, oper
-> right
);
1768 jvm_generate_in(p
, oper
-> left
, oper
-> right
);
1774 jvm_generate_shift(p
, op
, oper
-> left
, oper
-> right
);
1777 gen_error("push_oper: unk op %i", op
);
1783 push_expr(gen_proc_t
* p
, oberon_expr_t
* expr
)
1787 push_item(p
, (oberon_item_t
*) expr
);
1791 push_operator(p
, (oberon_oper_t
*) expr
);
1796 store_expr(gen_proc_t
* p
, oberon_expr_t
* dst
, oberon_expr_t
* src
)
1798 assert(dst
-> is_item
);
1799 oberon_item_t
* item
= (oberon_item_t
*) dst
;
1801 if(dst
-> result
-> class == OBERON_TYPE_ARRAY
1802 || src
-> result
-> class == OBERON_TYPE_ARRAY
)
1806 jvm_generate_copy_array(p
, dst
-> result
);
1808 else if(dst
-> result
-> class == OBERON_TYPE_RECORD
1809 || src
-> result
-> class == OBERON_TYPE_RECORD
)
1813 jvm_generate_copy_record(p
, dst
-> result
);
1815 else switch(item
-> mode
)
1818 jvm_generate_ldst_prepare(p
, item
-> var
-> gen_var
);
1820 jvm_generate_store(p
, item
-> var
-> gen_var
);
1824 char postfix
= jvm_get_postfix(src
-> result
);
1825 int cell_size
= jvm_cell_size_for_postfix(postfix
);
1826 assert(item
-> parent
-> is_item
);
1827 push_item(p
, (oberon_item_t
*) item
-> parent
);
1828 push_expr(p
, item
-> args
);
1829 check_index(p
, item
-> args
-> result
);
1831 jvm_generate(p
, 1 + 1 + cell_size
, 0, "%castore", postfix
);
1834 assert(item
-> parent
-> is_item
);
1835 push_item(p
, (oberon_item_t
*) item
-> parent
);
1836 jvm_generate_ldst_prepare(p
, item
-> var
-> gen_var
);
1838 jvm_generate_store(p
, item
-> var
-> gen_var
);
1841 gen_error("store_expr: unk mode %i", item
-> mode
);
1847 oberon_generate_assign(oberon_context_t
* ctx
, oberon_expr_t
* src
, oberon_expr_t
* dst
)
1852 m
= ctx
-> mod
-> gen_mod
;
1853 p
= m
-> class -> p
;
1855 store_expr(p
, dst
, src
);
1859 oberon_generate_copy(oberon_context_t
* ctx
, oberon_expr_t
* src
, oberon_expr_t
* dst
)
1865 m
= ctx
-> mod
-> gen_mod
;
1866 p
= m
-> class -> p
;
1871 desc
= jvm_get_descriptor(dst
-> result
);
1873 jvm_generate(p
, 2, 0, "invokestatic SYSTEM/COPY(%s%s)V", desc
, desc
);
1877 oberon_generate_assert(oberon_context_t
* ctx
, oberon_expr_t
* cond
)
1882 m
= ctx
-> mod
-> gen_mod
;
1883 p
= m
-> class -> p
;
1886 jvm_generate(p
, 1, 0, "invokestatic SYSTEM/ASSERT(Z)V");
1890 oberon_generate_assert_n(oberon_context_t
* ctx
, oberon_expr_t
* cond
, int64_t n
)
1895 m
= ctx
-> mod
-> gen_mod
;
1896 p
= m
-> class -> p
;
1899 jvm_generate_push_int_size(p
, n
, 8);
1900 jvm_generate(p
, 1 + 2, 0, "invokestatic SYSTEM/ASSERT(ZJ)V");
1904 oberon_generate_trap(oberon_context_t
* ctx
, int64_t n
)
1909 m
= ctx
-> mod
-> gen_mod
;
1910 p
= m
-> class -> p
;
1912 jvm_generate_push_int_size(p
, n
, 8);
1913 jvm_generate(p
, 2, 0, "invokestatic SYSTEM/TRAP(J)V");
1917 oberon_generate_halt(oberon_context_t
* ctx
, int64_t n
)
1922 m
= ctx
-> mod
-> gen_mod
;
1923 p
= m
-> class -> p
;
1925 jvm_generate_push_int_size(p
, n
, 8);
1926 jvm_generate(p
, 2, 0, "invokestatic SYSTEM/HALT(J)V");
1930 oberon_set_out_directory(oberon_context_t
* ctx
, const char * path
)
1934 c
= ctx
-> gen_context
;
1936 c
-> dir
= new_string(path
);