11 #include "../../../include/oberon.h"
12 #include "../../oberon-internals.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 * Генерирует код для инициализации массива со статическим базовым типом
30 jvm_generate_array_initialization(gen_proc_t
* p
, oberon_type_t
* arr
)
33 oberon_type_t
* base
= arr
;
34 while(base
-> class == OBERON_TYPE_ARRAY
)
40 if(base
-> class != OBERON_TYPE_RECORD
)
42 jvm_generate(p
, 1, 0, "pop");
54 reg_dst
= jvm_alloc_register_untyped(p
-> rf
, false);
55 jvm_generate(p
, 1, 0, "astore %i", reg_dst
);
58 * Входящие параметры заграблены.
59 * Теперь генерируем эквивалентный код:
61 * int len = dst.length
66 * dst[i, ...] = new record;
71 * Где "..." такой же код (начало и конец) для следующей размерности.
74 for(int i
= 0; i
< dim
; i
++)
76 loop
[i
].reg_index
= jvm_alloc_register_untyped(p
-> rf
, false);
77 loop
[i
].reg_length
= jvm_alloc_register_untyped(p
-> rf
, false);
78 loop
[i
].start
= jvm_new_label_id(p
);
79 loop
[i
].end
= jvm_new_label_id(p
);
81 jvm_generate(p
, 0, 1, "iconst_0");
82 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_index
);
84 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
85 jvm_generate(p
, 1, 1, "arraylength");
86 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_length
);
88 /* if(i >= len) goto end; */
89 jvm_generate_label(p
, loop
[i
].start
);
90 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
91 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_length
);
92 jvm_generate(p
, 2, 0, "if_icmpge L%i", loop
[i
].end
);
95 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
96 jvm_generate(p
, 0, 1, "iload %i", loop
[0].reg_index
);
97 for(int i
= 1; i
< dim
; i
++)
99 jvm_generate(p
, 2, 1, "aaload");
100 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
102 jvm_generate_new(p
, base
, 0);
103 jvm_generate(p
, 3, 0, "aastore");
105 for(int i
= dim
- 1; i
>= 0; i
--)
107 jvm_generate(p
, 0, 0, "iinc %i 1", loop
[i
].reg_index
);
108 jvm_generate(p
, 0, 0, "goto L%i", loop
[i
].start
);
109 jvm_generate_label(p
, loop
[i
].end
);
114 jvm_generate_new(gen_proc_t
* p
, oberon_type_t
* type
, int num
)
119 oberon_type_t
* base
;
121 switch(type
-> class)
123 case OBERON_TYPE_INTEGER
:
124 case OBERON_TYPE_BOOLEAN
:
125 case OBERON_TYPE_PROCEDURE
:
126 case OBERON_TYPE_REAL
:
127 case OBERON_TYPE_POINTER
:
128 gen_error("jvm_generate_new_static: static alocation not allowed");
130 case OBERON_TYPE_RECORD
:
132 cname
= jvm_get_class_full_name(type
);
133 jvm_generate(p
, 0, 1, "new %s", cname
);
134 jvm_generate(p
, 1, 2, "dup");
135 jvm_generate(p
, 1, 0, "invokespecial %s/<init>()V", cname
);
137 case OBERON_TYPE_ARRAY
:
140 desc
= jvm_get_descriptor(type
);
141 while(base
-> class == OBERON_TYPE_ARRAY
)
145 assert(base
-> size
== 0);
150 assert(base
-> size
> 0);
151 jvm_generate_push_int(p
, base
-> size
);
158 jvm_generate(p
, dim
, 1, "multianewarray %s %i", desc
, dim
);
159 jvm_generate(p
, 1, 2, "dup");
160 jvm_generate_array_initialization(p
, type
);
163 gen_error("jvm_generate_new_static: unk type class %i", type
-> class);
169 * Генерирует код для копирования полей из первой записи во вторую.
170 * ( aref_dst aref_src -- )
175 jvm_generate_copy_record(gen_proc_t
* p
, oberon_type_t
* rec
)
177 assert(rec
-> class == OBERON_TYPE_RECORD
);
178 char * desc
= jvm_get_descriptor(rec
);
179 char * cname
= jvm_get_class_full_name(rec
);
180 jvm_generate(p
, 1 + 1, 0, "invokestatic %s/$COPY$(%s%s)V", cname
, desc
, desc
);
184 * Генерирует кода для копирования массивов.
185 * ( aref_dst aref_src -- )
190 jvm_generate_copy_array(gen_proc_t
* p
, oberon_type_t
* arr
)
193 oberon_type_t
* base
= arr
;
194 while(base
-> class == OBERON_TYPE_ARRAY
)
207 int reg_dst
= jvm_alloc_register_untyped(p
-> rf
, false);
208 int reg_src
= jvm_alloc_register_untyped(p
-> rf
, false);
209 jvm_generate(p
, 1, 0, "astore %i", reg_src
);
210 jvm_generate(p
, 1, 0, "astore %i", reg_dst
);
213 * Входящие параметры заграблены.
214 * Теперь генерируем эквивалентный код:
216 * int len = src.length
221 * copy from src[i, ...] to dst[i, ...];
226 * Где "..." такой же код (начало и конец) для следующей размерности.
229 for(int i
= 0; i
< dim
; i
++)
231 loop
[i
].reg_index
= jvm_alloc_register_untyped(p
-> rf
, false);
232 loop
[i
].reg_length
= jvm_alloc_register_untyped(p
-> rf
, false);
233 loop
[i
].start
= jvm_new_label_id(p
);
234 loop
[i
].end
= jvm_new_label_id(p
);
236 jvm_generate(p
, 0, 1, "iconst_0");
237 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_index
);
239 jvm_generate(p
, 0, 1, "aload %i", reg_src
);
240 jvm_generate(p
, 1, 1, "arraylength");
241 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].reg_length
);
243 /* if(i >= len) goto end; */
244 jvm_generate_label(p
, loop
[i
].start
);
245 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
246 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_length
);
247 jvm_generate(p
, 2, 0, "if_icmpge L%i", loop
[i
].end
);
250 if(base
-> class == OBERON_TYPE_RECORD
)
252 /* Получаем записи по индексам ( -- dst src ) */
254 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
255 for(int i
= 0; i
< dim
; i
++)
257 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
258 jvm_generate(p
, 2, 1, "aaload");
261 jvm_generate(p
, 0, 1, "aload %i", reg_src
);
262 for(int i
= 0; i
< dim
; i
++)
264 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
265 jvm_generate(p
, 2, 1, "aaload");
268 /* Копируем записи ( dst src -- ) */
269 jvm_generate_copy_record(p
, base
);
273 char postfix
= jvm_get_postfix(base
);
274 int cell_size
= jvm_cell_size_for_postfix(postfix
);
276 /* Получаем массивы и индексы ( -- dst i src i ) */
278 jvm_generate(p
, 0, 1, "aload %i", reg_dst
);
279 jvm_generate(p
, 0, 1, "iload %i", loop
[0].reg_index
);
280 for(int i
= 1; i
< dim
; i
++)
282 jvm_generate(p
, 2, 1, "aaload");
283 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
286 jvm_generate(p
, 0, 1, "aload %i", reg_src
);
287 jvm_generate(p
, 0, 1, "iload %i", loop
[0].reg_index
);
288 for(int i
= 1; i
< dim
; i
++)
290 jvm_generate(p
, 2, 1, "aaload");
291 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].reg_index
);
294 /* Копируем значения ( dst i src i -- ) */
295 jvm_generate(p
, 2, cell_size
, "%caload", postfix
);
296 jvm_generate(p
, 2 + cell_size
, 0, "%castore", postfix
);
299 for(int i
= dim
- 1; i
>= 0; i
--)
301 jvm_generate(p
, 0, 0, "iinc %i 1", loop
[i
].reg_index
);
302 jvm_generate(p
, 0, 0, "goto L%i", loop
[i
].start
);
303 jvm_generate_label(p
, loop
[i
].end
);
308 jvm_generate_push_procedure_pointer(gen_proc_t
* p
, oberon_object_t
* proc
)
310 char * full_name
= jvm_get_field_full_name_safe(proc
);
311 char * desc
= jvm_get_descriptor(proc
-> type
);
312 jvm_generate(p
, 0, 1, "getstatic %s/pointer %s", full_name
, desc
);
316 oberon_generator_init_context(oberon_context_t
* ctx
)
318 gen_context_t
* gen_context
= GC_MALLOC(sizeof *gen_context
);
319 memset(gen_context
, 0, sizeof *gen_context
);
321 ctx
-> gen_context
= gen_context
;
322 gen_context
-> dir
= ".";
326 oberon_generator_destroy_context(oberon_context_t
* ctx
)
331 oberon_generate_procedure_class(const char * dir
, oberon_type_t
* proc
)
336 struct gen_class
* class;
338 cname
= jvm_get_class_full_name(proc
);
339 class = jvm_create_class(dir
, cname
);
342 fprintf(fp
, ".source SYSTEM\n");
343 fprintf(fp
, ".class public abstract %s\n", cname
);
344 fprintf(fp
, ".super java/lang/Object\n\n");
346 fprintf(fp
, ".method <init>()V\n");
347 fprintf(fp
, " aload_0\n");
348 fprintf(fp
, " invokespecial java/lang/Object/<init>()V\n");
349 fprintf(fp
, " return\n");
350 fprintf(fp
, ".end method\n\n");
352 signature
= jvm_get_procedure_signature(proc
);
354 fprintf(fp
, ".method public abstract invoke%s\n", signature
);
355 fprintf(fp
, ".end method\n\n");
357 jvm_destroy_class(class);
361 oberon_generate_procedure_pointer_class(const char * dir
, oberon_object_t
* proc
)
368 struct gen_class
* class;
370 cname
= jvm_get_field_full_name_safe(proc
);
371 class = jvm_create_class(dir
, cname
);
372 abscname
= jvm_get_class_full_name(proc
-> type
);
373 absdesc
= jvm_get_descriptor(proc
-> type
);
376 fprintf(fp
, ".source %s\n", proc
-> module
-> name
);
377 fprintf(fp
, ".class public %s\n", cname
);
378 fprintf(fp
, ".super %s\n\n", abscname
);
380 fprintf(fp
, ".field public static pointer %s\n\n", absdesc
);
382 fprintf(fp
, ".method private <init>()V\n");
383 fprintf(fp
, " aload_0\n");
384 fprintf(fp
, " invokespecial %s/<init>()V\n", abscname
);
385 fprintf(fp
, " return\n");
386 fprintf(fp
, ".end method\n\n");
388 fprintf(fp
, ".method static <clinit>()V\n");
389 fprintf(fp
, " .limit stack 2\n");
390 fprintf(fp
, " new %s\n", cname
);
391 fprintf(fp
, " dup\n");
392 fprintf(fp
, " invokespecial %s/<init>()V\n", cname
);
393 fprintf(fp
, " putstatic %s/pointer %s\n", cname
, absdesc
);
394 fprintf(fp
, " return\n");
395 fprintf(fp
, ".end method\n\n");
397 signature
= jvm_get_procedure_signature(proc
-> type
);
399 gen_proc_t
* p
= jvm_create_proc(class);
400 jvm_generate_function_header(p
, "public", "invoke", signature
);
401 jvm_alloc_register_untyped(p
-> rf
, false);
404 int num
= proc
-> type
-> num_decl
;
405 oberon_object_t
* param
= proc
-> type
-> decl
;
406 for(int i
= 0; i
< num
; i
++)
408 gen_type_t
* t
= param
-> type
-> gen_type
;
409 if(param
-> class == OBERON_CLASS_VAR_PARAM
)
411 int reg
= jvm_alloc_register_untyped(p
-> rf
, true);
412 jvm_generate(p
, 0, 1, "aload %i", reg
);
413 jvm_generate(p
, 0, 1, "iload %i", reg
+ 1);
417 int reg
= jvm_alloc_register_untyped(p
-> rf
, t
-> wide
);
418 jvm_generate(p
, 0, t
-> cell_size
, "%cload %i", t
-> prefix
, reg
);
420 use_size
+= t
-> cell_size
;
421 param
= param
-> next
;
424 char * full_name
= jvm_get_field_full_name(proc
);
425 int cell_size
= jvm_cell_size_for_type(proc
-> type
-> base
);
426 jvm_generate(p
, use_size
, cell_size
, "invokestatic %s%s", full_name
, signature
);
428 if(proc
-> type
-> base
-> class == OBERON_TYPE_NOTYPE
)
430 jvm_generate(p
, 0, 0, "return");
434 char prefix
= jvm_get_prefix(proc
-> type
-> base
);
435 jvm_generate(p
, cell_size
, 0, "%creturn", prefix
);
438 jvm_generate_function_end(p
);
440 jvm_destroy_class(class);
444 oberon_generate_record_class(const char * dir
, gen_module_t
* m
, oberon_type_t
* rec
)
447 struct gen_class
* class;
449 /* Устанавливаем новоый id */
450 rec
-> gen_type
-> rec_id
= m
-> rec_id
;
453 cname
= jvm_get_class_full_name(rec
);
454 class = jvm_create_class(dir
, cname
);
456 fprintf(class -> fp
, ".source %s\n", rec
-> module
-> name
);
457 fprintf(class -> fp
, ".class public %s\n", cname
);
459 if(rec
-> base
== NULL
)
461 fprintf(class -> fp
, ".super java/lang/Object\n\n");
465 class -> base
= rec
-> base
-> gen_type
-> class;
466 fprintf(class -> fp
, ".super %s\n\n", class -> base
-> full_name
);
469 rec
-> gen_type
-> class = class;
473 oberon_generator_init_type(oberon_context_t
* ctx
, oberon_type_t
* type
)
475 gen_type_t
* t
= GC_MALLOC(sizeof *t
);
476 memset(t
, 0, sizeof *t
);
477 type
-> gen_type
= t
;
480 c
= ctx
-> gen_context
;
483 switch(type
-> class)
485 case OBERON_TYPE_NOTYPE
:
486 case OBERON_TYPE_INTEGER
:
487 case OBERON_TYPE_BOOLEAN
:
488 case OBERON_TYPE_ARRAY
:
489 case OBERON_TYPE_POINTER
:
490 case OBERON_TYPE_REAL
:
491 case OBERON_TYPE_CHAR
:
492 case OBERON_TYPE_STRING
:
493 case OBERON_TYPE_SET
:
494 case OBERON_TYPE_NIL
:
496 case OBERON_TYPE_RECORD
:
497 m
= type
-> module
-> gen_mod
;
498 oberon_generate_record_class(c
-> dir
, m
, type
);
500 case OBERON_TYPE_PROCEDURE
:
501 oberon_generate_procedure_class(c
-> dir
, type
);
504 gen_error("oberon_generator_init_type: unk calss %i", type
-> class);
508 if(type
-> class != OBERON_TYPE_NOTYPE
)
510 t
-> wide
= jvm_is_wide_type(type
);
511 t
-> prefix
= jvm_get_prefix(type
);
512 t
-> postfix
= jvm_get_postfix(type
);
515 t
-> cell_size
= jvm_cell_size_for_type(type
);
517 if(type
-> class != OBERON_TYPE_NIL
)
519 t
-> desc
= jvm_get_descriptor(type
);
524 oberon_generator_init_record(oberon_context_t
* ctx
, oberon_type_t
* rec
)
526 struct gen_class
* class;
527 class = rec
-> gen_type
-> class;
529 int num
= rec
-> num_decl
;
530 oberon_object_t
* field
= rec
-> decl
;
531 for(int i
= 0; i
< num
; i
++)
533 jvm_generate_var(field
-> gen_var
);
534 field
= field
-> next
;
537 /* Стандартный конструктор класса */
538 /* Инициализирует внутренние статические записи и массивы */
539 gen_proc_t
* p
= jvm_create_proc(class);
540 jvm_generate_function_header(p
, "public", "<init>", "()V");
541 jvm_alloc_register_untyped(p
-> rf
, false);
542 jvm_generate(p
, 0, 1, "aload_0");
545 jvm_generate(p
, 1, 0, "invokespecial %s/<init>()V", class -> base
-> full_name
);
549 jvm_generate(p
, 1, 0, "invokespecial java/lang/Object/<init>()V");
551 num
= rec
-> num_decl
;
553 for(int i
= 0; i
< num
; i
++)
555 jvm_generate(p
, 0, 1, "aload_0");
556 jvm_generate_var_initialization(p
, field
-> gen_var
);
558 if(field
-> type
-> class == OBERON_TYPE_RECORD
559 || field
-> type
-> class == OBERON_TYPE_ARRAY
)
561 jvm_generate(p
, 0, 1, "aload_0");
562 jvm_generate_ldst_prepare(p
, field
-> gen_var
);
563 jvm_generate_new(p
, field
-> type
, 0);
564 jvm_generate_store(p
, field
-> gen_var
);
566 field
= field
-> next
;
568 jvm_generate(p
, 0, 0, "return");
569 jvm_generate_function_end(p
);
571 /* Метод для копирования полей класса */
572 /* reg0 == src -> reg1 == dst */
573 p
= jvm_create_proc(class);
574 char * signature
= new_string("(%s%s)V", rec
-> gen_type
-> desc
, rec
-> gen_type
-> desc
);
575 jvm_generate_function_header(p
, "public static", "$COPY$", signature
);
577 gen_var_t
* copy_dst
= jvm_create_function_var(p
, JVM_STORAGE_REGISTER
, "dst", rec
-> gen_type
);
578 gen_var_t
* copy_src
= jvm_create_function_var(p
, JVM_STORAGE_REGISTER
, "src", rec
-> gen_type
);
579 jvm_generate_var(copy_dst
);
580 jvm_generate_var(copy_src
);
581 jvm_generate_var_initialization(p
, copy_dst
);
582 jvm_generate_var_initialization(p
, copy_src
);
584 num
= rec
-> num_decl
;
586 for(int i
= 0; i
< num
; i
++)
588 if(field
-> type
-> class == OBERON_TYPE_RECORD
)
590 jvm_generate_load(p
, copy_dst
);
591 jvm_generate_load(p
, field
-> gen_var
);
592 jvm_generate_load(p
, copy_src
);
593 jvm_generate_load(p
, field
-> gen_var
);
594 jvm_generate_copy_record(p
, field
-> type
);
596 else if(field
-> type
-> class == OBERON_TYPE_ARRAY
)
598 jvm_generate_load(p
, copy_dst
);
599 jvm_generate_load(p
, field
-> gen_var
);
600 jvm_generate_load(p
, copy_src
);
601 jvm_generate_load(p
, field
-> gen_var
);
602 jvm_generate_copy_array(p
, field
-> type
);
606 jvm_generate_load(p
, copy_dst
);
607 jvm_generate_ldst_prepare(p
, field
-> gen_var
);
608 jvm_generate_load(p
, copy_src
);
609 jvm_generate_load(p
, field
-> gen_var
);
610 jvm_generate_store(p
, field
-> gen_var
);
612 field
= field
-> next
;
614 jvm_generate(p
, 0, 0, "return");
615 jvm_generate_function_end(p
);
617 jvm_destroy_class(class);
621 oberon_generator_init_var(oberon_context_t
* ctx
, oberon_object_t
* var
)
624 m
= ctx
-> mod
-> gen_mod
;
626 struct gen_class
* class;
630 struct gen_class
* c
;
631 char * name
= var
-> name
;
632 gen_type_t
* t
= var
-> type
-> gen_type
;
635 case OBERON_CLASS_VAR_PARAM
:
636 p
= var
-> parent
-> gen_proc
;
637 var
-> gen_var
= jvm_create_function_var(p
, JVM_STORAGE_FRAME_PARAM_VARPTR
, name
, t
);
639 case OBERON_CLASS_PARAM
:
640 p
= var
-> parent
-> gen_proc
;
641 var
-> gen_var
= jvm_create_function_var(p
, JVM_STORAGE_FRAME_PARAM_VAR
, name
, t
);
643 case OBERON_CLASS_FIELD
:
644 c
= var
-> parent_type
-> gen_type
-> class;
645 var
-> gen_var
= jvm_create_class_var(c
, JVM_STORAGE_FIELD_VAR
, name
, t
);
647 case OBERON_CLASS_VAR
:
650 p
= var
-> parent
-> gen_proc
;
651 var
-> gen_var
= jvm_create_function_var(p
, JVM_STORAGE_FRAME_VAR
, name
, t
);
655 var
-> gen_var
= jvm_create_class_var(class, JVM_STORAGE_STATIC_VAR
, name
, t
);
656 jvm_generate_var(var
-> gen_var
);
660 gen_error("oberon_generator_init_var: unk var class %i", var
-> class);
666 oberon_generator_init_temp_var(oberon_context_t
* ctx
, oberon_object_t
* var
)
668 assert(var
-> class == OBERON_CLASS_VAR
);
671 m
= ctx
-> mod
-> gen_mod
;
677 t
= var
-> type
-> gen_type
;
679 var
-> gen_var
= jvm_create_function_temp_var(p
, t
);
680 jvm_generate_var(var
-> gen_var
);
681 jvm_generate_var_initialization(p
, var
-> gen_var
);
685 oberon_generator_init_proc(oberon_context_t
* ctx
, oberon_object_t
* proc
)
687 struct gen_class
* class = proc
-> module
-> gen_mod
-> class;
688 proc
-> gen_proc
= jvm_create_proc(class);
689 proc
-> gen_proc
-> full_name
= jvm_get_field_full_name_safe(proc
);
690 jvm_create_static_links(proc
);
694 oberon_generator_init_module(oberon_context_t
* ctx
, oberon_module_t
* mod
)
696 gen_module_t
* m
= GC_MALLOC(sizeof *m
);
697 memset(m
, 0, sizeof *m
);
701 c
= ctx
-> gen_context
;
703 struct gen_class
* class;
704 class = jvm_create_class(c
-> dir
, mod
-> name
);
706 fprintf(class -> fp
, ".source %s\n", mod
-> name
);
707 fprintf(class -> fp
, ".class %s\n", mod
-> name
);
708 fprintf(class -> fp
, ".super java/lang/Object\n\n");
716 oberon_generator_fini_module(oberon_module_t
* mod
)
718 jvm_destroy_class(mod
-> gen_mod
-> class);
722 push_expr(gen_proc_t
* p
, oberon_expr_t
* expr
);
725 oberon_generate_begin_module(oberon_context_t
* ctx
)
727 struct gen_class
* class = ctx
-> mod
-> gen_mod
-> class;
728 gen_proc_t
* p
= jvm_create_proc(class);
730 jvm_generate_function_header(p
, "public", "<init>", "()V");
731 jvm_alloc_register_untyped(p
-> rf
, false);
732 jvm_generate(p
, 0, 1, "aload_0");
733 jvm_generate(p
, 1, 0, "invokespecial java/lang/Object/<init>()V");
735 /* Инициализация переменных объявленных в модуле */
736 oberon_object_t
* x
= ctx
-> mod
-> decl
-> list
-> next
;
739 if(x
-> class == OBERON_CLASS_VAR
)
741 jvm_generate_var_initialization(p
, x
-> gen_var
);
742 if(x
-> type
-> class == OBERON_TYPE_ARRAY
743 || x
-> type
-> class == OBERON_TYPE_RECORD
)
745 jvm_generate_ldst_prepare(p
, x
-> gen_var
);
746 jvm_generate_new(p
, x
-> type
, 0);
747 jvm_generate_store(p
, x
-> gen_var
);
756 oberon_generate_end_module(oberon_context_t
* ctx
)
758 struct gen_class
* class = ctx
-> mod
-> gen_mod
-> class;
759 gen_proc_t
* p
= class -> p
;
761 jvm_generate(p
, 0, 0, "return");
762 jvm_generate_function_end(class -> p
);
766 * Генерирует код для получения размера измерения массива
767 * Аналог Обероновского LEN(v, n); где n = 0 - первое измерение.
772 jvm_generate_array_len(gen_proc_t
* p
, int dim
)
776 jvm_generate(p
, 0, 1, "iconst_0");
777 jvm_generate(p
, 2, 1, "aaload");
780 jvm_generate(p
, 1, 1, "arraylength");
784 jvm_generate_array_duplicate_and_replace(gen_proc_t
* p
, gen_var_t
* v
, oberon_type_t
* arr
)
786 jvm_generate_ldst_prepare(p
, v
);
789 oberon_type_t
* base
= arr
;
790 while(base
-> class == OBERON_TYPE_ARRAY
)
792 if(base
-> size
== 0)
794 jvm_generate_load(p
, v
);
795 jvm_generate_array_len(p
, dim
);
801 jvm_generate_new(p
, arr
, dim
);
802 jvm_generate(p
, 1, 2, "dup");
803 jvm_generate_load(p
, v
);
804 jvm_generate_copy_array(p
, arr
);
805 jvm_generate_store(p
, v
);
809 jvm_generate_record_duplicate_and_replace(gen_proc_t
* p
, gen_var_t
* v
, oberon_type_t
* rec
)
811 jvm_generate_ldst_prepare(p
, v
);
812 jvm_generate_new(p
, rec
, 0);
813 jvm_generate(p
, 1, 2, "dup");
814 jvm_generate_load(p
, v
);
815 jvm_generate_copy_record(p
, rec
);
816 jvm_generate_store(p
, v
);
820 jvm_generate_local_object(gen_proc_t
* p
, oberon_object_t
* x
)
823 struct gen_class
* class;
828 // Убеждаемся что сейчас находимся в функции
834 case OBERON_CLASS_VAR_PARAM
:
835 case OBERON_CLASS_PARAM
:
836 case OBERON_CLASS_VAR
:
839 case OBERON_CLASS_PROC
:
842 gen_error("jvm_generate_local_initialization: wat");
848 jvm_generate_local_initialization(gen_proc_t
* p
, oberon_object_t
* x
)
851 struct gen_class
* class;
856 // Убеждаемся что сейчас находимся в функции
862 case OBERON_CLASS_VAR_PARAM
:
863 case OBERON_CLASS_PARAM
:
864 case OBERON_CLASS_VAR
:
865 jvm_generate_var_initialization(p
, v
);
867 case OBERON_CLASS_PROC
:
870 gen_error("jvm_generate_local_initialization: wat");
874 if(x
-> class == OBERON_CLASS_PARAM
)
876 if(x
-> type
-> class == OBERON_TYPE_ARRAY
)
878 jvm_generate_array_duplicate_and_replace(p
, v
, x
-> type
);
880 else if(x
-> type
-> class == OBERON_TYPE_RECORD
)
882 jvm_generate_record_duplicate_and_replace(p
, v
, x
-> type
);
888 oberon_generate_begin_proc(oberon_context_t
* ctx
, oberon_object_t
* proc
)
893 oberon_object_t
* var
;
895 p
= proc
-> gen_proc
;
899 signature
= jvm_get_local_procedure_signature(proc
);
903 oberon_generate_procedure_pointer_class(p
-> class -> dir
, proc
);
904 signature
= jvm_get_procedure_signature(proc
-> type
);
907 name
= jvm_get_name(proc
);
908 jvm_generate_function_header(p
, "public static", name
, signature
);
912 jvm_generate_staticlinks(proc
);
915 jvm_generate_procedure_frame(proc
);
917 /* Создание парамеров и переменных */
918 var
= proc
-> scope
-> list
-> next
;
921 jvm_generate_local_object(p
, var
);
925 jvm_generate_frame_initialization(p
);
927 /* Инициализация парамеров и переменных */
928 var
= proc
-> scope
-> list
-> next
;
931 jvm_generate_local_initialization(p
, var
);
937 oberon_generate_end_proc(oberon_context_t
* ctx
)
942 m
= ctx
-> mod
-> gen_mod
;
945 jvm_generate_function_end(p
);
949 oberon_generator_reserve_label(oberon_context_t
* ctx
)
955 m
= ctx
-> mod
-> gen_mod
;
958 l
= GC_MALLOC(sizeof *l
);
959 memset(l
, 0, sizeof *l
);
961 l
-> id
= jvm_new_label_id(p
);
966 oberon_generate_label(oberon_context_t
* ctx
, gen_label_t
* l
)
971 m
= ctx
-> mod
-> gen_mod
;
974 jvm_generate_label(p
, l
-> id
);
978 oberon_generate_goto(oberon_context_t
* ctx
, gen_label_t
* l
)
983 m
= ctx
-> mod
-> gen_mod
;
986 jvm_generate(p
, 0, 0, "goto L%i", l
-> id
);
990 oberon_generate_branch(oberon_context_t
* ctx
, oberon_expr_t
* cond
, bool gotoif
, gen_label_t
* l
)
995 m
= ctx
-> mod
-> gen_mod
;
1002 /* переход если false */
1003 jvm_generate(p
, 1, 0, "ifeq L%i", l
-> id
);
1007 /* переход если true */
1008 jvm_generate(p
, 1, 0, "ifne L%i", l
-> id
);
1013 push_varptr(gen_proc_t
* p
, oberon_expr_t
* expr
)
1015 assert(expr
-> is_item
);
1017 switch(expr
-> item
.mode
)
1020 jvm_generate_ldst_prepare(p
, expr
-> item
.var
-> gen_var
);
1023 push_item(p
, (oberon_item_t
*) expr
-> item
.parent
);
1024 push_expr(p
, expr
-> item
.args
);
1027 push_item(p
, (oberon_item_t
*) expr
-> item
.parent
);
1028 jvm_generate_ldst_prepare(p
, expr
-> item
.var
-> gen_var
);
1031 gen_error("push_varptr: wat %i", expr
-> item
.mode
);
1037 jvm_generate_call_proc(gen_proc_t
* p
, oberon_item_t
* desig
)
1039 assert(desig
-> var
== NULL
);
1040 assert(desig
-> mode
== MODE_CALL
);
1042 bool direct_call
= false;
1043 if(desig
-> parent
-> mode
== MODE_VAR
)
1045 if(desig
-> parent
-> var
-> class == OBERON_CLASS_PROC
)
1051 oberon_type_t
* procsig
;
1052 procsig
= desig
-> parent
-> result
;
1054 if(direct_call
== false)
1056 /* Загружаем указатель на процедуру */
1057 push_item(p
, desig
-> parent
);
1062 jvm_generate_push_static_links(p
, desig
-> parent
-> var
);
1066 int result_cells
= jvm_cell_size_for_type(procsig
-> base
);
1068 int num
= desig
-> num_args
;
1069 oberon_expr_t
* arg
= desig
-> args
;
1070 oberon_object_t
* param
= procsig
-> decl
;
1071 for(int i
= 0; i
< num
; i
++)
1073 if(param
-> class == OBERON_CLASS_VAR_PARAM
)
1076 push_varptr(p
, arg
);
1080 args_cells
+= jvm_cell_size_for_type(arg
-> result
);
1084 param
= param
-> next
;
1089 char * full_name
= jvm_get_field_full_name(desig
-> parent
-> var
);
1090 char * signature
= jvm_get_local_procedure_signature(desig
-> parent
-> var
);
1091 jvm_generate(p
, args_cells
, result_cells
, "invokestatic %s%s", full_name
, signature
);
1095 char * cname
= jvm_get_class_full_name(procsig
);
1096 char * signature
= jvm_get_procedure_signature(procsig
);
1097 jvm_generate(p
, 1 + args_cells
, result_cells
, "invokevirtual %s/invoke%s", cname
, signature
);
1102 oberon_generate_call_proc(oberon_context_t
* ctx
, oberon_expr_t
* desig
)
1104 assert(desig
-> is_item
);
1105 jvm_generate_call_proc(ctx
-> mod
-> gen_mod
-> class -> p
, (oberon_item_t
*) desig
);
1109 oberon_generate_return(oberon_context_t
* ctx
, oberon_expr_t
* expr
)
1116 m
= ctx
-> mod
-> gen_mod
;
1117 p
= m
-> class -> p
;
1122 prefix
= jvm_get_prefix(expr
-> result
);
1123 cell_size
= jvm_cell_size_for_type(expr
-> result
);
1124 jvm_generate(p
, cell_size
, 0, "%creturn", prefix
);
1128 jvm_generate(p
, 0, 0, "return");
1133 jvm_generate_expr_new_pointer(gen_proc_t
* p
, oberon_type_t
* type
, int num
, oberon_expr_t
* arg
)
1135 assert(type
-> class == OBERON_TYPE_POINTER
);
1137 for(int i
= 0; i
< num
; i
++)
1143 jvm_generate_new(p
, type
-> base
, num
);
1147 jvm_generate_cast_prefix(gen_proc_t
* p
, char prefix
, char postfix
)
1149 if(prefix
== postfix
)
1154 int from_cell_size
= jvm_cell_size_for_postfix(prefix
);
1155 int to_cell_size
= jvm_cell_size_for_postfix(postfix
);
1156 jvm_generate(p
, from_cell_size
, to_cell_size
, "%c2%c", prefix
, postfix
);
1160 jvm_generate_cast_type(gen_proc_t
* p
, oberon_type_t
* from
, oberon_type_t
* to
)
1162 if(to
-> class == OBERON_TYPE_RECORD
|| to
-> class == OBERON_TYPE_POINTER
)
1164 if(to
-> class == OBERON_TYPE_POINTER
&& to
-> base
-> class == OBERON_TYPE_RECORD
)
1166 char * full_name
= jvm_get_class_full_name(to
);
1167 jvm_generate(p
, 1, 1, "checkcast %s", full_name
);
1172 char prefix
= jvm_get_prefix(from
);
1173 char postfix
= jvm_get_postfix(to
);
1174 jvm_generate_cast_prefix(p
, prefix
, postfix
);
1179 push_item(gen_proc_t
* p
, oberon_item_t
* item
)
1181 switch(item
-> mode
)
1184 if(item
-> var
-> class == OBERON_CLASS_PROC
)
1186 jvm_generate_push_procedure_pointer(p
, item
-> var
);
1190 jvm_generate_load(p
, item
-> var
-> gen_var
);
1197 jvm_generate_push_int_size(p
, item
-> integer
, item
-> result
-> size
);
1200 jvm_generate_call_proc(p
, item
);
1204 char postfix
= jvm_get_postfix(item
-> result
);
1205 int cell_size
= jvm_cell_size_for_postfix(postfix
);
1206 push_item(p
, item
-> parent
);
1207 push_expr(p
, item
-> args
);
1208 jvm_generate(p
, 1 + 1, cell_size
, "%caload", postfix
);
1211 push_item(p
, item
-> parent
);
1212 jvm_generate_load(p
, item
-> var
-> gen_var
);
1215 /* Все объекты в jvm представляются как указатели */
1216 push_item(p
, item
-> parent
);
1219 jvm_generate(p
, 0, 1, "aconst_null");
1222 jvm_generate_expr_new_pointer(p
, item
-> result
, item
-> num_args
, item
-> args
);
1225 jvm_generate_push_float(p
, item
-> real
, item
-> result
-> size
);
1228 jvm_generate_push_string(p
, item
-> string
, item
-> result
-> size
);
1231 push_item(p
, item
-> parent
);
1232 jvm_generate_array_len(p
, item
-> integer
);
1233 jvm_generate_cast_prefix(p
, 'i', jvm_get_postfix(item
-> result
));
1236 gen_error("push_item: unk mode %i", item
-> mode
);
1242 jvm_generate_logical_not(gen_proc_t
* p
)
1244 int label_done
= jvm_new_label_id(p
);
1245 int label_false
= jvm_new_label_id(p
);
1247 jvm_generate(p
, 1, 0, "ifne L%i", label_false
);
1248 jvm_generate(p
, 0, 1, "iconst_1");
1249 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1250 jvm_generate_label(p
, label_false
);
1251 jvm_generate(p
, 0, 1, "iconst_0");
1252 jvm_generate_label(p
, label_done
);
1256 jvm_generate_abs(gen_proc_t
* p
, char prefix
)
1258 char t
= jvm_get_type_of_prefix(prefix
);
1259 int cell_size
= jvm_cell_size_for_postfix(prefix
);
1260 jvm_generate(p
, cell_size
, cell_size
, "invokestatic java/lang/Math/abs(%c)%c", t
, t
);
1264 jvm_get_compare_postfix(int op
)
1288 gen_error("jvm_generate_compare_op: wat");
1295 jvm_generate_compare_op(gen_proc_t
* p
, oberon_type_t
* t
, int op
)
1297 char prefix
= jvm_get_prefix(t
);
1298 int label_true
= jvm_new_label_id(p
);
1299 int label_done
= jvm_new_label_id(p
);
1300 int cell_size
= jvm_cell_size_for_type(t
);
1301 char * cmpop
= jvm_get_compare_postfix(op
);
1305 jvm_generate(p
, 2 * cell_size
, 1, "lcmp");
1306 jvm_generate(p
, 1, 1, "if%s L%i", cmpop
, label_true
);
1308 else if(prefix
== 'f' || prefix
== 'd')
1311 if(op
== OP_EQ
|| op
== OP_NEQ
|| op
== OP_GRT
|| op
== OP_GEQ
)
1319 jvm_generate(p
, 2 * cell_size
, 1, "%ccmp%c", prefix
, fop
);
1320 jvm_generate(p
, 1, 1, "if%s L%i", cmpop
, label_true
);
1322 else if(prefix
== 'a')
1324 if(t
-> class == OBERON_TYPE_STRING
1325 || (t
-> class == OBERON_TYPE_POINTER
&& t
-> base
-> class == OBERON_TYPE_CHAR
))
1327 jvm_generate(p
, 2, 1, "invokestatic SYSTEM/STRCMP([B[B)I");
1328 jvm_generate(p
, 1, 0, "if%s L%i", cmpop
, label_true
);
1332 jvm_generate(p
, 1, 0, "if_acmp%s L%i", cmpop
, label_true
);
1337 jvm_generate(p
, 2 * cell_size
, 0, "if_%ccmp%s L%i", prefix
, cmpop
, label_true
);
1340 jvm_generate(p
, 0, 1, "iconst_0");
1341 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1342 jvm_generate_label(p
, label_true
);
1343 jvm_generate(p
, 0, 1, "iconst_1");
1344 jvm_generate_label(p
, label_done
);
1348 jvm_generate_operator(gen_proc_t
* p
, oberon_type_t
* t
, int op
)
1350 char prefix
= jvm_get_prefix(t
);
1351 int cell_size
= jvm_cell_size_for_type(t
);
1354 case OP_UNARY_MINUS
:
1355 jvm_generate(p
, cell_size
, cell_size
, "%cneg", prefix
);
1357 case OP_COMPLEMENTATION
:
1358 jvm_generate_push_int_size(p
, -1, t
-> size
);
1359 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cxor", prefix
);
1362 jvm_generate_logical_not(p
);
1365 jvm_generate_abs(p
, prefix
);
1368 jvm_generate(p
, cell_size
, cell_size
, "invokestatic java/lang/Character/toUpperCase(I)I");
1372 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cadd", prefix
);
1375 jvm_generate(p
, 2 * cell_size
, cell_size
, "%csub", prefix
);
1378 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cmul", prefix
);
1381 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cdiv", prefix
);
1384 jvm_generate(p
, 2 * cell_size
, cell_size
, "%crem", prefix
);
1387 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cor", prefix
);
1389 case OP_INTERSECTION
:
1390 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cand", prefix
);
1393 /* (a - b) == a & ~b */
1394 jvm_generate_push_int_size(p
, -1, t
-> size
);
1395 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cxor", prefix
);
1396 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cand", prefix
);
1398 case OP_SYM_DIFFERENCE
:
1399 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cxor", prefix
);
1408 jvm_generate_compare_op(p
, t
, op
);
1411 gen_error("jvm_generate_operator: unk op %i", op
);
1417 jvm_generate_logical_or(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1419 int label_calc_b
= jvm_new_label_id(p
);
1420 int label_done
= jvm_new_label_id(p
);
1422 /* a OR b -- если a, то TRUE, иначе b */
1425 jvm_generate(p
, 1, 0, "ifeq L%i", label_calc_b
);
1426 jvm_generate(p
, 0, 1, "iconst_1");
1427 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1428 jvm_generate_label(p
, label_calc_b
);
1430 jvm_generate_label(p
, label_done
);
1434 jvm_generate_logical_and(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1436 int label_false
= jvm_new_label_id(p
);
1437 int label_done
= jvm_new_label_id(p
);
1439 /* a AND b -- если a, то b, иначе FALSE */
1442 jvm_generate(p
, 1, 0, "ifeq L%i", label_false
);
1444 jvm_generate(p
, 0, 0, "goto L%i", label_done
);
1445 jvm_generate_label(p
, label_false
);
1446 jvm_generate(p
, 0, 1, "iconst_0");
1447 jvm_generate_label(p
, label_done
);
1451 jvm_generate_range(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1453 /* { a } == 1 << a */
1454 /* { a..b } == (a <= b) ? ((2 << b) - (1 << a)) : (0); */
1458 oberon_type_t
* type
;
1465 cell_size
= jvm_cell_size_for_type(type
);
1466 prefix
= jvm_get_prefix(type
);
1470 jvm_generate_push_int_size(p
, 1, type
-> size
);
1472 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1476 ra
= jvm_create_function_temp_var(p
, type
-> gen_type
);
1477 rb
= jvm_create_function_temp_var(p
, type
-> gen_type
);
1478 jvm_generate_var(ra
);
1479 jvm_generate_var(rb
);
1480 jvm_generate_var_initialization(p
, ra
);
1481 jvm_generate_var_initialization(p
, rb
);
1482 label_else
= jvm_new_label_id(p
);
1483 label_end
= jvm_new_label_id(p
);
1486 jvm_generate_store(p
, ra
);
1488 jvm_generate_store(p
, rb
);
1490 jvm_generate_load(p
, ra
);
1491 jvm_generate_load(p
, rb
);
1492 jvm_generate(p
, 2 * cell_size
, 0, "if_%ccmpgt L%i", prefix
, label_else
);
1494 jvm_generate_push_int_size(p
, 2, type
-> size
);
1495 jvm_generate_load(p
, rb
);
1496 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1497 jvm_generate_push_int_size(p
, 2, type
-> size
);
1498 jvm_generate_load(p
, ra
);
1499 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1500 jvm_generate(p
, 2 * cell_size
, cell_size
, "%csub", prefix
);
1501 jvm_generate(p
, 0, 0, "goto L%i", label_end
);
1503 jvm_generate_label(p
, label_else
);
1504 jvm_generate_push_int_size(p
, 0, type
-> size
);
1505 jvm_generate_label(p
, label_end
);
1508 /* TODO free registers */
1512 jvm_generate_in(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1514 oberon_type_t
* t
= a
-> result
;
1515 int cell_size
= jvm_cell_size_for_type(t
);
1516 char prefix
= jvm_get_prefix(t
);
1517 int label_else
= jvm_new_label_id(p
);
1518 int label_end
= jvm_new_label_id(p
);
1520 /* (a IN b) == (1 << a) & b */
1521 jvm_generate_push_int_size(p
, 1, t
-> size
);
1523 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1525 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cand", prefix
);
1529 jvm_generate(p
, cell_size
, 0, "lcmp");
1532 jvm_generate(p
, 1, 0, "ifeq L%i", label_else
);
1533 jvm_generate(p
, 0, 1, "iconst_1");
1534 jvm_generate(p
, 0, 0, "goto L%i", label_end
);
1535 jvm_generate_label(p
, label_else
);
1536 jvm_generate(p
, 0, 1, "iconst_0");
1537 jvm_generate_label(p
, label_end
);
1541 jvm_generate_ash(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1543 oberon_type_t
* t
= a
-> result
;
1544 int cell_size
= jvm_cell_size_for_type(t
);
1545 char prefix
= jvm_get_prefix(t
);
1546 int label_else
= jvm_new_label_id(p
);
1547 int label_end
= jvm_new_label_id(p
);
1549 /* if b < 0 then a << b else a >> b end */
1555 jvm_generate(p
, cell_size
, 2 * cell_size
, "dup");
1559 jvm_generate(p
, cell_size
, 2 * cell_size
, "dup2");
1561 jvm_generate_push_int_size(p
, 0, t
-> size
);
1562 jvm_generate_compare_op(p
, t
, OP_LSS
);
1564 jvm_generate(p
, cell_size
, 0, "ifne L%i", label_else
);
1565 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshl", prefix
);
1566 jvm_generate(p
, 0, 0, "goto L%i", label_end
);
1567 jvm_generate_label(p
, label_else
);
1568 jvm_generate_abs(p
, prefix
);
1569 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cshr", prefix
);
1570 jvm_generate_label(p
, label_end
);
1574 jvm_generate_entier(gen_proc_t
* p
, oberon_expr_t
* x
, oberon_type_t
* res
)
1576 char prefix
= jvm_get_prefix(x
-> result
);
1577 char postfix
= jvm_get_postfix(res
);
1580 jvm_generate_cast_prefix(p
, prefix
, 'd');
1581 jvm_generate(p
, 2, 2, "invokestatic java/lang/Math/floor(D)D");
1582 jvm_generate_cast_prefix(p
, 'd', postfix
);
1586 push_operator(gen_proc_t
* p
, oberon_oper_t
* oper
)
1588 oberon_type_t
* preq
= oper
-> left
-> result
;
1589 int op
= oper
-> op
;
1593 push_expr(p
, oper
-> left
);
1594 jvm_generate_cast_type(p
, oper
-> left
-> result
, oper
-> result
);
1596 case OP_COMPLEMENTATION
:
1597 case OP_UNARY_MINUS
:
1601 push_expr(p
, oper
-> left
);
1602 jvm_generate_operator(p
, preq
, op
);
1605 jvm_generate_entier(p
, oper
-> left
, oper
-> result
);
1615 case OP_INTERSECTION
:
1617 case OP_SYM_DIFFERENCE
:
1625 push_expr(p
, oper
-> left
);
1626 push_expr(p
, oper
-> right
);
1627 jvm_generate_operator(p
, preq
, op
);
1631 jvm_generate_logical_or(p
, oper
-> left
, oper
-> right
);
1634 jvm_generate_logical_and(p
, oper
-> left
, oper
-> right
);
1638 preq
= oper
-> right
-> result
;
1639 char * cname
= jvm_get_class_full_name(preq
);
1640 push_expr(p
, oper
-> left
);
1641 jvm_generate(p
, 1, 1, "instanceof %s", cname
);
1644 jvm_generate_range(p
, oper
-> left
, oper
-> right
);
1647 jvm_generate_in(p
, oper
-> left
, oper
-> right
);
1651 jvm_generate_ash(p
, oper
-> left
, oper
-> right
);
1654 gen_error("push_oper: unk op %i", op
);
1660 push_expr(gen_proc_t
* p
, oberon_expr_t
* expr
)
1664 push_item(p
, (oberon_item_t
*) expr
);
1668 push_operator(p
, (oberon_oper_t
*) expr
);
1673 store_expr(gen_proc_t
* p
, oberon_expr_t
* dst
, oberon_expr_t
* src
)
1675 assert(dst
-> is_item
);
1676 oberon_item_t
* item
= (oberon_item_t
*) dst
;
1678 if(dst
-> result
-> class == OBERON_TYPE_ARRAY
1679 || src
-> result
-> class == OBERON_TYPE_ARRAY
)
1683 jvm_generate_copy_array(p
, dst
-> result
);
1685 else if(dst
-> result
-> class == OBERON_TYPE_RECORD
1686 || src
-> result
-> class == OBERON_TYPE_RECORD
)
1690 jvm_generate_copy_record(p
, dst
-> result
);
1692 else switch(item
-> mode
)
1695 jvm_generate_ldst_prepare(p
, item
-> var
-> gen_var
);
1697 jvm_generate_store(p
, item
-> var
-> gen_var
);
1701 char postfix
= jvm_get_postfix(src
-> result
);
1702 int cell_size
= jvm_cell_size_for_postfix(postfix
);
1703 assert(item
-> parent
-> is_item
);
1704 push_item(p
, (oberon_item_t
*) item
-> parent
);
1705 push_expr(p
, item
-> args
);
1707 jvm_generate(p
, 1 + 1 + cell_size
, 0, "%castore", postfix
);
1710 assert(item
-> parent
-> is_item
);
1711 push_item(p
, (oberon_item_t
*) item
-> parent
);
1712 jvm_generate_ldst_prepare(p
, item
-> var
-> gen_var
);
1714 jvm_generate_store(p
, item
-> var
-> gen_var
);
1717 gen_error("store_expr: unk mode %i", item
-> mode
);
1723 oberon_generate_assign(oberon_context_t
* ctx
, oberon_expr_t
* src
, oberon_expr_t
* dst
)
1728 m
= ctx
-> mod
-> gen_mod
;
1729 p
= m
-> class -> p
;
1731 store_expr(p
, dst
, src
);
1735 oberon_generate_copy(oberon_context_t
* ctx
, oberon_expr_t
* src
, oberon_expr_t
* dst
)
1741 m
= ctx
-> mod
-> gen_mod
;
1742 p
= m
-> class -> p
;
1747 desc
= jvm_get_descriptor(dst
-> result
);
1749 jvm_generate(p
, 2, 0, "invokestatic SYSTEM/COPY(%s%s)V", desc
, desc
);
1753 oberon_generate_assert(oberon_context_t
* ctx
, oberon_expr_t
* cond
)
1758 m
= ctx
-> mod
-> gen_mod
;
1759 p
= m
-> class -> p
;
1762 jvm_generate(p
, 1, 0, "invokestatic SYSTEM/ASSERT(Z)V");
1766 oberon_generate_assert_n(oberon_context_t
* ctx
, oberon_expr_t
* cond
, int64_t n
)
1771 m
= ctx
-> mod
-> gen_mod
;
1772 p
= m
-> class -> p
;
1775 jvm_generate_push_int_size(p
, n
, 8);
1776 jvm_generate(p
, 1 + 2, 0, "invokestatic SYSTEM/ASSERT(ZJ)V");
1780 oberon_generate_trap(oberon_context_t
* ctx
, int64_t n
)
1785 m
= ctx
-> mod
-> gen_mod
;
1786 p
= m
-> class -> p
;
1788 jvm_generate_push_int_size(p
, n
, 8);
1789 jvm_generate(p
, 2, 0, "invokestatic SYSTEM/TRAP(J)V");
1793 oberon_generate_halt(oberon_context_t
* ctx
, int64_t n
)
1798 m
= ctx
-> mod
-> gen_mod
;
1799 p
= m
-> class -> p
;
1801 jvm_generate_push_int_size(p
, n
, 8);
1802 jvm_generate(p
, 2, 0, "invokestatic SYSTEM/HALT(J)V");
1806 oberon_set_out_directory(oberon_context_t
* ctx
, const char * path
)
1810 c
= ctx
-> gen_context
;
1812 c
-> dir
= new_string(path
);