b17711bd5627d68a54b5dd06c4a475023a1a204a
11 #include "../../../include/oberon.h"
12 #include "../../oberon-internals.h"
13 #include "generator-jvm.h"
14 #include "generator-jvm-basic.h"
16 // ==========================================
17 // ==========================================
18 // ==========================================
21 jvm_create_proc(struct gen_class
* class)
23 gen_proc_t
* p
= GC_MALLOC(sizeof *p
);
24 memset(p
, 0, sizeof *p
);
26 struct gen_register_file
* rf
= GC_MALLOC(sizeof *rf
);
27 memset(rf
, 0, sizeof *rf
);
29 struct gen_stack
* stack
= GC_MALLOC(sizeof *stack
);
30 memset(rf
, 0, sizeof *stack
);
41 jvm_generate_function_header(gen_proc_t
* p
, char * access
, char * name
, char * signature
)
43 struct gen_class
* class;
46 /* Делаем процедуру текущей в этом классе */
47 assert(class -> p
== NULL
);
50 fprintf(class -> fp
, ".method %s %s%s\n", access
, name
, signature
);
51 fprintf(class -> fp
, " start:\n");
55 jvm_generate_function_end(gen_proc_t
* p
)
57 struct gen_class
* class;
63 int pointer
= p
-> stack
-> pointer
;
64 int max_pointer
= p
-> stack
-> max_pointer
;
65 int locals
= p
-> rf
-> num_used
;
66 int max_locals
= p
-> rf
-> max_used
;
68 fprintf(class -> fp
, " .limit stack %i \t; current(%i)\n", max_pointer
, pointer
);
69 fprintf(class -> fp
, " .limit locals %i \t; current(%i)\n", max_locals
, locals
);
70 fprintf(class -> fp
, " end:\n");
71 fprintf(class -> fp
, ".end method\n\n");
75 jvm_create_class(char * full_name
)
77 struct gen_class
* class = GC_MALLOC(sizeof *class);
78 memset(class, 0, sizeof *class);
80 char * fname
= new_string("%s.j", full_name
);
81 class -> full_name
= new_string(full_name
);
82 class -> fp
= fopen(fname
, "w");
89 jvm_destroy_class(struct gen_class
* class)
91 assert(class -> p
== NULL
);
96 jvm_stack_push(gen_proc_t
* p
, unsigned size
)
98 p
-> stack
-> pointer
+= size
;
99 if(p
-> stack
-> pointer
> p
-> stack
-> max_pointer
)
101 p
-> stack
-> max_pointer
= p
-> stack
-> pointer
;
106 jvm_stack_pop(gen_proc_t
* p
, unsigned size
)
108 p
-> stack
-> pointer
-= size
;
110 if(p
-> stack
-> pointer
< 0)
112 printf("WARING: stack pointer %i\n", p
-> stack
-> pointer
);
117 jvm_generate(gen_proc_t
* p
, unsigned get
, unsigned push
, char * format
, ...)
120 va_start(ptr
, format
);
122 jvm_stack_pop(p
, get
);
123 fprintf(p
-> class -> fp
, " ");
124 vfprintf(p
-> class -> fp
, format
, ptr
);
125 jvm_stack_push(p
, push
);
126 fprintf(p
-> class -> fp
, " \t ;>>>> %i -- %i : current_stack(%i)\n", get
, push
, p
-> stack
-> pointer
);
132 jvm_generate_comment(gen_proc_t
* p
, char * format
, ...)
135 va_start(ptr
, format
);
137 fprintf(p
-> class -> fp
, " ;;;; ");
138 vfprintf(p
-> class -> fp
, format
, ptr
);
139 fprintf(p
-> class -> fp
, "\n");
145 jvm_generate_push_int(gen_proc_t
* p
, int64_t i
)
149 jvm_generate(p
, 0, 1, "iconst_m1");
151 else if(i
>= 0 && i
<= 5)
153 jvm_generate(p
, 0, 1, "iconst_%li", i
);
155 else if(i
>= -128 && i
<= 127)
157 jvm_generate(p
, 0, 1, "bipush %li", i
);
159 else if(i
>= -32768 && i
<= 32767)
161 jvm_generate(p
, 0, 1, "sipush %li", i
);
163 else if(i
>= -2147483648 && i
<= 2147483647)
165 jvm_generate(p
, 0, 1, "ldc %li", i
);
169 jvm_generate(p
, 0, 2, "ldc2_w %li", i
);
174 jvm_generate_push_int_size(gen_proc_t
* p
, int64_t i
, int size
)
180 jvm_generate(p
, 0, 1, "iconst_m1");
182 else if(i
>= 0 && i
<= 5)
184 jvm_generate(p
, 0, 1, "iconst_%li", i
);
186 else if(i
>= -128 && i
<= 127)
188 jvm_generate(p
, 0, 1, "bipush %li", i
);
190 else if(i
>= -32768 && i
<= 32767)
192 jvm_generate(p
, 0, 1, "sipush %li", i
);
194 else if(i
>= -2147483648 && i
<= 2147483647)
196 jvm_generate(p
, 0, 1, "ldc %li", i
);
201 jvm_generate(p
, 0, 2, "ldc2_w %li", i
);
205 if(size
> 4 && pushed_cell
== 1)
207 jvm_generate(p
, pushed_cell
, 2, "i2l");
213 jvm_generate(p
, 2, 1, "l2i");
218 jvm_generate(p
, 1, 1, "i2s");
222 jvm_generate(p
, 1, 1, "i2b");
228 jvm_generate_push_float(gen_proc_t
* p
, double f
, int size
)
234 jvm_generate(p
, 0, 1, "fconst_0");
238 jvm_generate(p
, 0, 1, "fconst_1");
242 jvm_generate(p
, 0, 1, "fconst_2");
246 jvm_generate(p
, 0, 1, "ldc %lf", f
);
253 jvm_generate(p
, 0, 2, "dconst_0");
257 jvm_generate(p
, 0, 2, "dconst_1");
261 jvm_generate(p
, 0, 2, "ldc2_w %lf", f
);
267 jvm_generate_push_string(gen_proc_t
* p
, char * str
, int char_size
)
269 assert(char_size
== 1);
270 int len
= strlen(str
);
272 jvm_generate_push_int(p
, len
+ 1);
273 jvm_generate(p
, 1, 1, "newarray byte");
275 for(int i
= 0; i
< len
; i
++)
277 jvm_generate(p
, 1, 2, "dup");
278 jvm_generate_push_int(p
, i
);
279 jvm_generate_push_int(p
, str
[i
]);
280 jvm_generate(p
, 3, 0, "bastore");
285 oberon_generator_new_var()
287 gen_var_t
* v
= GC_MALLOC(sizeof *v
);
288 memset(v
, 0, sizeof *v
);
293 jvm_generate_and_init_global_var(gen_var_t
* v
, struct gen_class
* class, char * access
, char * name
, char * desc
)
295 assert(class -> p
== NULL
);
296 fprintf(class -> fp
, ".field %s static %s %s\n\n", access
, name
, desc
);
298 v
-> storage
= JVM_STORAGE_STATIC
;
299 v
-> full_name
= new_string("%s/%s", class -> full_name
, name
);
300 v
-> desc
= new_string(desc
);
304 jvm_generate_and_init_field(gen_var_t
* v
, struct gen_class
* class, char * access
, char * name
, char * desc
)
306 assert(class -> p
== NULL
);
307 fprintf(class -> fp
, ".field %s %s %s\n\n", access
, name
, desc
);
309 v
-> storage
= JVM_STORAGE_FIELD
;
310 v
-> full_name
= new_string("%s/%s", class -> full_name
, name
);
311 v
-> desc
= new_string(desc
);
315 jvm_generate_and_init_local_var(gen_var_t
* v
, gen_proc_t
* p
, bool wide
)
317 v
-> storage
= JVM_STORAGE_REGISTER
;
318 v
-> reg
= jvm_alloc_register_untyped(p
-> rf
, wide
);
322 jvm_generate_and_init_named_local_var(gen_var_t
* v
, gen_proc_t
* p
, bool wide
, char * name
, char * desc
)
324 jvm_generate_and_init_local_var(v
, p
, wide
);
325 v
-> desc
= new_string(desc
);
326 jvm_generate(p
, 0, 0, ".var %i is %s %s from start to end", v
-> reg
, name
, desc
);
330 jvm_new_label_id(gen_proc_t
* p
)
332 int label_id
= p
-> label_id
;
338 jvm_get_label_name(int label_id
)
340 return new_string("L%i", label_id
);
344 jvm_generate_label(gen_proc_t
* p
, int label_id
)
346 jvm_generate(p
, 0, 0, "L%i:", label_id
);
350 jvm_generate_load(gen_proc_t
* p
, oberon_type_t
* src_type
, gen_var_t
* src
)
355 cell_size
= jvm_cell_size_for_type(src_type
);
357 switch(src
-> storage
)
359 case JVM_STORAGE_REGISTER
:
360 prefix
= jvm_get_prefix(src_type
);
361 jvm_generate(p
, 0, cell_size
, "%cload %i", prefix
, src
-> reg
);
363 case JVM_STORAGE_STATIC
:
364 jvm_generate(p
, 0, cell_size
, "getstatic %s %s", src
-> full_name
, src
-> desc
);
366 case JVM_STORAGE_FIELD
:
367 jvm_generate(p
, 1, cell_size
, "getfield %s %s", src
-> full_name
, src
-> desc
);
370 gen_error("jvm_generate_load: unknow storage type %i", src
-> storage
);
376 jvm_generate_store(gen_proc_t
* p
, oberon_type_t
* src_type
, gen_var_t
* dst
)
381 cell_size
= jvm_cell_size_for_type(src_type
);
383 switch(dst
-> storage
)
385 case JVM_STORAGE_REGISTER
:
386 prefix
= jvm_get_prefix(src_type
);
387 jvm_generate(p
, cell_size
, 0, "%cstore %i", prefix
, dst
-> reg
);
389 case JVM_STORAGE_STATIC
:
390 jvm_generate(p
, cell_size
, 0, "putstatic %s %s", dst
-> full_name
, dst
-> desc
);
392 case JVM_STORAGE_FIELD
:
393 jvm_generate(p
, 1 + cell_size
, 0, "putfield %s %s", dst
-> full_name
, dst
-> desc
);
396 gen_error("jvm_generate_store: unknow storage type %i", dst
-> storage
);
402 jvm_generate_new(gen_proc_t
* p
, oberon_type_t
* type
, int num
);
405 * Генерирует код для инициализации массива со статическим базовым типом
410 jvm_generate_array_initialization(gen_proc_t
* p
, oberon_type_t
* arr
)
413 oberon_type_t
* base
= arr
;
414 while(base
-> class == OBERON_TYPE_ARRAY
)
420 if(base
-> class != OBERON_TYPE_RECORD
)
422 jvm_generate(p
, 1, 0, "pop");
433 gen_var_t
* dst
= oberon_generator_new_var();
434 jvm_generate_and_init_local_var(dst
, p
, false);
435 jvm_generate_store(p
, arr
, dst
);
438 * Входящие параметры заграблены.
439 * Теперь генерируем эквивалентный код:
441 * int len = dst.length
446 * dst[i, ...] = new record;
451 * Где "..." такой же код (начало и конец) для следующей размерности.
454 for(int i
= 0; i
< dim
; i
++)
456 loop
[i
].index
= oberon_generator_new_var();
457 loop
[i
].length
= oberon_generator_new_var();
458 loop
[i
].start
= jvm_new_label_id(p
);
459 loop
[i
].end
= jvm_new_label_id(p
);
460 jvm_generate_and_init_local_var(loop
[i
].index
, p
, false);
461 jvm_generate_and_init_local_var(loop
[i
].length
, p
, false);
463 /* TODO преределать через jvm_generate_load{{store}} */
465 jvm_generate(p
, 0, 1, "iconst_0");
466 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].index
-> reg
);
468 jvm_generate_load(p
, arr
, dst
);
469 jvm_generate(p
, 1, 1, "arraylength");
470 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].length
-> reg
);
472 /* if(i >= len) goto end; */
473 jvm_generate_label(p
, loop
[i
].start
);
474 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].index
-> reg
);
475 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].length
-> reg
);
476 jvm_generate(p
, 2, 0, "if_icmpge L%i", loop
[i
].end
);
479 jvm_generate_load(p
, arr
, dst
);
480 jvm_generate(p
, 0, 1, "iload %i", loop
[0].index
-> reg
);
481 for(int i
= 1; i
< dim
; i
++)
483 jvm_generate(p
, 2, 1, "aaload");
484 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].index
-> reg
);
486 jvm_generate_new(p
, base
, 0);
487 jvm_generate(p
, 3, 0, "aastore");
489 for(int i
= dim
- 1; i
>= 0; i
--)
491 jvm_generate(p
, 0, 0, "iinc %i 1", loop
[i
].index
-> reg
);
492 jvm_generate(p
, 0, 0, "goto L%i", loop
[i
].start
);
493 jvm_generate_label(p
, loop
[i
].end
);
498 jvm_generate_new(gen_proc_t
* p
, oberon_type_t
* type
, int num
)
503 oberon_type_t
* base
;
505 switch(type
-> class)
507 case OBERON_TYPE_INTEGER
:
508 case OBERON_TYPE_BOOLEAN
:
509 case OBERON_TYPE_PROCEDURE
:
510 case OBERON_TYPE_REAL
:
511 case OBERON_TYPE_POINTER
:
512 gen_error("jvm_generate_new_static: static alocation not allowed");
514 case OBERON_TYPE_RECORD
:
516 cname
= jvm_get_class_full_name(type
);
517 jvm_generate(p
, 0, 1, "new %s", cname
);
518 jvm_generate(p
, 1, 2, "dup");
519 jvm_generate(p
, 1, 0, "invokespecial %s/<init>()V", cname
);
521 case OBERON_TYPE_ARRAY
:
524 desc
= jvm_get_descriptor(type
);
525 while(base
-> class == OBERON_TYPE_ARRAY
)
529 assert(base
-> size
== 0);
534 assert(base
-> size
> 0);
535 jvm_generate_push_int(p
, base
-> size
);
542 jvm_generate(p
, dim
, 1, "multianewarray %s %i", desc
, dim
);
543 jvm_generate(p
, 1, 2, "dup");
544 jvm_generate_array_initialization(p
, type
);
547 gen_error("jvm_generate_new_static: unk type class %i", type
-> class);
553 * Генерирует код для копирования полей из первой записи во вторую.
554 * ( aref_dst aref_src -- )
559 jvm_generate_copy_record(gen_proc_t
* p
, oberon_type_t
* rec
)
561 assert(rec
-> class == OBERON_TYPE_RECORD
);
562 char * desc
= jvm_get_descriptor(rec
);
563 char * cname
= jvm_get_class_full_name(rec
);
564 jvm_generate(p
, 1 + 1, 0, "invokestatic %s/$COPY$(%s%s)V", cname
, desc
, desc
);
568 * Генерирует кода для копирования массивов.
569 * ( aref_dst aref_src -- )
574 jvm_generate_copy_array(gen_proc_t
* p
, oberon_type_t
* arr
)
577 oberon_type_t
* base
= arr
;
578 while(base
-> class == OBERON_TYPE_ARRAY
)
591 gen_var_t
* dst
= oberon_generator_new_var();
592 gen_var_t
* src
= oberon_generator_new_var();
593 jvm_generate_and_init_local_var(dst
, p
, false);
594 jvm_generate_and_init_local_var(src
, p
, false);
596 jvm_generate_store(p
, arr
, src
);
597 jvm_generate_store(p
, arr
, dst
);
600 * Входящие параметры заграблены.
601 * Теперь генерируем эквивалентный код:
603 * int len = src.length
608 * copy from src[i, ...] to dst[i, ...];
613 * Где "..." такой же код (начало и конец) для следующей размерности.
616 for(int i
= 0; i
< dim
; i
++)
618 loop
[i
].index
= oberon_generator_new_var();
619 loop
[i
].length
= oberon_generator_new_var();
620 loop
[i
].start
= jvm_new_label_id(p
);
621 loop
[i
].end
= jvm_new_label_id(p
);
622 jvm_generate_and_init_local_var(loop
[i
].index
, p
, false);
623 jvm_generate_and_init_local_var(loop
[i
].length
, p
, false);
625 /* TODO преределать через jvm_generate_load{{store}} */
627 jvm_generate(p
, 0, 1, "iconst_0");
628 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].index
-> reg
);
630 jvm_generate_load(p
, arr
, src
);
631 jvm_generate(p
, 1, 1, "arraylength");
632 jvm_generate(p
, 1, 0, "istore %i", loop
[i
].length
-> reg
);
634 /* if(i >= len) goto end; */
635 jvm_generate_label(p
, loop
[i
].start
);
636 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].index
-> reg
);
637 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].length
-> reg
);
638 jvm_generate(p
, 2, 0, "if_icmpge L%i", loop
[i
].end
);
641 if(base
-> class == OBERON_TYPE_RECORD
)
643 /* Получаем записи по индексам ( -- dst src ) */
645 jvm_generate_load(p
, arr
, dst
);
646 for(int i
= 0; i
< dim
; i
++)
648 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].index
-> reg
);
649 jvm_generate(p
, 2, 1, "aaload");
652 jvm_generate_load(p
, arr
, src
);
653 for(int i
= 0; i
< dim
; i
++)
655 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].index
-> reg
);
656 jvm_generate(p
, 2, 1, "aaload");
659 /* Копируем записи ( dst src -- ) */
660 jvm_generate_copy_record(p
, base
);
664 char postfix
= jvm_get_postfix(base
);
665 int cell_size
= jvm_cell_size_for_postfix(postfix
);
667 /* Получаем массивы и индексы ( -- dst i src i ) */
669 jvm_generate_load(p
, arr
, dst
);
670 jvm_generate(p
, 0, 1, "iload %i", loop
[0].index
-> reg
);
671 for(int i
= 1; i
< dim
; i
++)
673 jvm_generate(p
, 2, 1, "aaload");
674 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].index
-> reg
);
677 jvm_generate_load(p
, arr
, src
);
678 jvm_generate(p
, 0, 1, "iload %i", loop
[0].index
-> reg
);
679 for(int i
= 1; i
< dim
; i
++)
681 jvm_generate(p
, 2, 1, "aaload");
682 jvm_generate(p
, 0, 1, "iload %i", loop
[i
].index
-> reg
);
685 /* Копируем значения ( dst i src i -- ) */
686 jvm_generate(p
, 2, cell_size
, "%caload", postfix
);
687 jvm_generate(p
, 2 + cell_size
, 0, "%castore", postfix
);
690 for(int i
= dim
- 1; i
>= 0; i
--)
692 jvm_generate(p
, 0, 0, "iinc %i 1", loop
[i
].index
-> reg
);
693 jvm_generate(p
, 0, 0, "goto L%i", loop
[i
].start
);
694 jvm_generate_label(p
, loop
[i
].end
);
699 jvm_generate_push_procedure_pointer(gen_proc_t
* p
, oberon_object_t
* proc
)
701 char * full_name
= jvm_get_field_full_name_safe(proc
);
702 char * desc
= jvm_get_descriptor(proc
-> type
);
703 jvm_generate(p
, 0, 1, "getstatic %s/pointer %s", full_name
, desc
);
706 // ==========================================
707 // ==========================================
708 // ==========================================
711 push_item(gen_proc_t
* p
, oberon_item_t
* item
);
714 oberon_generator_init_context(oberon_context_t
* ctx
)
716 gen_context_t
* gen_context
= GC_MALLOC(sizeof *gen_context
);
717 memset(gen_context
, 0, sizeof *gen_context
);
719 ctx
-> gen_context
= gen_context
;
723 oberon_generator_destroy_context(oberon_context_t
* ctx
)
728 oberon_generate_procedure_class(oberon_type_t
* proc
)
733 struct gen_class
* class;
735 cname
= jvm_get_class_full_name(proc
);
736 class = jvm_create_class(cname
);
739 fprintf(fp
, ".source SYSTEM\n");
740 fprintf(fp
, ".class public abstract %s\n", cname
);
741 fprintf(fp
, ".super java/lang/Object\n\n");
743 fprintf(fp
, ".method <init>()V\n");
744 fprintf(fp
, " aload_0\n");
745 fprintf(fp
, " invokespecial java/lang/Object/<init>()V\n");
746 fprintf(fp
, " return\n");
747 fprintf(fp
, ".end method\n\n");
749 signature
= jvm_get_procedure_signature(proc
);
751 fprintf(fp
, ".method public abstract invoke%s\n", signature
);
752 fprintf(fp
, ".end method\n\n");
754 jvm_destroy_class(class);
758 oberon_generate_procedure_pointer_class(oberon_object_t
* proc
)
765 struct gen_class
* class;
767 cname
= jvm_get_field_full_name_safe(proc
);
768 class = jvm_create_class(cname
);
769 abscname
= jvm_get_class_full_name(proc
-> type
);
770 absdesc
= jvm_get_descriptor(proc
-> type
);
773 fprintf(fp
, ".source %s\n", proc
-> module
-> name
);
774 fprintf(fp
, ".class public %s\n", cname
);
775 fprintf(fp
, ".super %s\n\n", abscname
);
777 fprintf(fp
, ".field public static pointer %s\n\n", absdesc
);
779 fprintf(fp
, ".method <init>()V\n");
780 fprintf(fp
, " aload_0\n");
781 fprintf(fp
, " invokespecial %s/<init>()V\n", abscname
);
782 fprintf(fp
, " return\n");
783 fprintf(fp
, ".end method\n\n");
785 fprintf(fp
, ".method static <clinit>()V\n");
786 fprintf(fp
, " .limit stack 2\n");
787 fprintf(fp
, " new %s\n", cname
);
788 fprintf(fp
, " dup\n");
789 fprintf(fp
, " invokespecial %s/<init>()V\n", cname
);
790 fprintf(fp
, " putstatic %s/pointer %s\n", cname
, absdesc
);
791 fprintf(fp
, " return\n");
792 fprintf(fp
, ".end method\n\n");
794 signature
= jvm_get_procedure_signature(proc
-> type
);
799 p
= jvm_create_proc(class);
800 jvm_generate_function_header(p
, "public", "invoke", signature
);
802 this_v
= oberon_generator_new_var();
803 jvm_generate_and_init_local_var(this_v
, p
, false);
807 int num
= proc
-> type
-> num_decl
;
808 oberon_object_t
* arg
= proc
-> type
-> decl
;
809 for(int i
= 0; i
< num
; i
++)
811 v
= oberon_generator_new_var();
812 bool wide
= jvm_is_wide_type(arg
-> type
);
813 char * desc
= jvm_get_descriptor(arg
-> type
);
814 jvm_generate_and_init_named_local_var(v
, p
, wide
, arg
-> name
, desc
);
816 jvm_generate_load(p
, arg
-> type
, v
);
818 use_size
+= (wide
) ? (2) : (1);
823 char * full_name
= jvm_get_field_full_name(proc
);
824 int cell_size
= jvm_cell_size_for_type(proc
-> type
-> base
);
826 jvm_generate(p
, use_size
, cell_size
, "invokestatic %s%s", full_name
, signature
);
828 if(proc
-> type
-> base
-> class == OBERON_TYPE_VOID
)
830 jvm_generate(p
, 0, 0, "return");
834 char prefix
= jvm_get_prefix(proc
-> type
-> base
);
835 jvm_generate(p
, cell_size
, 0, "%creturn", prefix
);
838 jvm_generate_function_end(p
);
840 jvm_destroy_class(class);
844 oberon_generate_record_class(gen_module_t
* m
, oberon_type_t
* rec
)
847 struct gen_class
* class;
849 /* Устанавливаем новоый id */
850 rec
-> gen_type
-> rec_id
= m
-> rec_id
;
853 cname
= jvm_get_class_full_name(rec
);
854 class = jvm_create_class(cname
);
856 fprintf(class -> fp
, ".source %s\n", rec
-> module
-> name
);
857 fprintf(class -> fp
, ".class public %s\n", cname
);
859 if(rec
-> base
== NULL
)
861 fprintf(class -> fp
, ".super java/lang/Object\n\n");
865 class -> base
= rec
-> base
-> gen_type
-> class;
866 fprintf(class -> fp
, ".super %s\n\n", class -> base
-> full_name
);
869 rec
-> gen_type
-> class = class;
873 oberon_generator_init_type(oberon_context_t
* ctx
, oberon_type_t
* type
)
875 gen_type_t
* t
= GC_MALLOC(sizeof *t
);
876 memset(t
, 0, sizeof *t
);
877 type
-> gen_type
= t
;
879 switch(type
-> class)
881 case OBERON_TYPE_VOID
:
882 case OBERON_TYPE_INTEGER
:
883 case OBERON_TYPE_BOOLEAN
:
884 case OBERON_TYPE_ARRAY
:
885 case OBERON_TYPE_REAL
:
886 case OBERON_TYPE_CHAR
:
887 case OBERON_TYPE_STRING
:
889 case OBERON_TYPE_RECORD
:
892 m
= type
-> module
-> gen_mod
;
893 oberon_generate_record_class(m
, type
);
895 case OBERON_TYPE_PROCEDURE
:
896 oberon_generate_procedure_class(type
);
898 case OBERON_TYPE_POINTER
:
901 gen_error("oberon_generator_init_type: unk calss %i", type
-> class);
907 oberon_generator_init_record(oberon_context_t
* ctx
, oberon_type_t
* rec
)
909 struct gen_class
* class;
910 class = rec
-> gen_type
-> class;
912 int num
= rec
-> num_decl
;
913 oberon_object_t
* field
= rec
-> decl
;
914 for(int i
= 0; i
< num
; i
++)
916 gen_var_t
* v
= field
-> gen_var
;
917 char * name
= field
-> name
;
918 char * desc
= jvm_get_descriptor(field
-> type
);
919 jvm_generate_and_init_field(v
, class, "public", name
, desc
);
920 field
= field
-> next
;
923 /* Стандартный конструктор класса */
924 /* Инициализирует внутренние статические записи и массивы */
925 gen_proc_t
* p
= jvm_create_proc(class);
926 jvm_generate_function_header(p
, "public", "<init>", "()V");
927 jvm_alloc_register_untyped(p
-> rf
, false);
928 jvm_generate(p
, 0, 1, "aload_0");
931 jvm_generate(p
, 1, 0, "invokespecial %s/<init>()V", class -> base
-> full_name
);
935 jvm_generate(p
, 1, 0, "invokespecial java/lang/Object/<init>()V");
937 num
= rec
-> num_decl
;
939 for(int i
= 0; i
< num
; i
++)
941 if(field
-> type
-> class == OBERON_TYPE_RECORD
942 || field
-> type
-> class == OBERON_TYPE_ARRAY
)
944 jvm_generate(p
, 0, 1, "aload_0");
945 jvm_generate_new(p
, field
-> type
, 0);
946 jvm_generate_store(p
, field
-> type
, field
-> gen_var
);
948 field
= field
-> next
;
950 jvm_generate(p
, 0, 0, "return");
951 jvm_generate_function_end(p
);
953 /* Метод для копирования полей класса */
954 /* reg0 == src -> reg1 == dst */
955 p
= jvm_create_proc(class);
956 gen_var_t
* copy_dst
= oberon_generator_new_var();
957 gen_var_t
* copy_src
= oberon_generator_new_var();
958 char * desc
= jvm_get_descriptor(rec
);
959 char * signature
= new_string("(%s%s)V", desc
, desc
);
960 jvm_generate_function_header(p
, "public static", "$COPY$", signature
);
961 jvm_generate_and_init_named_local_var(copy_dst
, p
, false, "dst", desc
);
962 jvm_generate_and_init_named_local_var(copy_src
, p
, false, "src", desc
);
963 num
= rec
-> num_decl
;
965 for(int i
= 0; i
< num
; i
++)
967 if(field
-> type
-> class == OBERON_TYPE_RECORD
)
969 jvm_generate_load(p
, rec
, copy_dst
);
970 jvm_generate_load(p
, field
-> type
, field
-> gen_var
);
971 jvm_generate_load(p
, rec
, copy_src
);
972 jvm_generate_load(p
, field
-> type
, field
-> gen_var
);
973 jvm_generate_copy_record(p
, field
-> type
);
975 else if(field
-> type
-> class == OBERON_TYPE_ARRAY
)
977 jvm_generate_load(p
, rec
, copy_dst
);
978 jvm_generate_load(p
, field
-> type
, field
-> gen_var
);
979 jvm_generate_load(p
, rec
, copy_src
);
980 jvm_generate_load(p
, field
-> type
, field
-> gen_var
);
981 jvm_generate_copy_array(p
, field
-> type
);
985 jvm_generate_load(p
, rec
, copy_dst
);
986 jvm_generate_load(p
, rec
, copy_src
);
987 jvm_generate_load(p
, field
-> type
, field
-> gen_var
);
988 jvm_generate_store(p
, field
-> type
, field
-> gen_var
);
990 field
= field
-> next
;
992 jvm_generate(p
, 0, 0, "return");
993 jvm_generate_function_end(p
);
995 jvm_destroy_class(class);
999 oberon_generator_init_var(oberon_context_t
* ctx
, oberon_object_t
* var
)
1001 gen_var_t
* v
= oberon_generator_new_var();
1005 m
= ctx
-> mod
-> gen_mod
;
1007 struct gen_class
* class;
1011 switch(var
-> class)
1013 case OBERON_CLASS_VAR_PARAM
:
1014 gen_error("generator: VAR-parameters not implemented");
1016 case OBERON_CLASS_PARAM
:
1017 /* Заполняется при генерации функции */
1018 /* смотри jvm_init_local_object() */
1020 case OBERON_CLASS_FIELD
:
1021 /* Заполняются при инициализации структуры */
1022 /* смотри oberon_generator_init_record() */
1024 case OBERON_CLASS_VAR
:
1025 /* Локальные заполняются при генерации функции */
1026 /* смотри jvm_init_local_object() */
1027 if(var
-> local
== 0)
1029 desc
= jvm_get_descriptor(var
-> type
);
1030 jvm_generate_and_init_global_var(v
, class, "public", var
-> name
, desc
);
1034 gen_error("oberon_generator_init_var: unk var class %i", var
-> class);
1040 oberon_generator_init_proc(oberon_context_t
* ctx
, oberon_object_t
* proc
)
1042 struct gen_class
* class = proc
-> module
-> gen_mod
-> class;
1043 proc
-> gen_proc
= jvm_create_proc(class);
1047 gen_error("generator: local procedures not implemented");
1050 oberon_generate_procedure_pointer_class(proc
);
1054 oberon_generator_init_module(oberon_context_t
* ctx
, oberon_module_t
* mod
)
1056 gen_module_t
* m
= GC_MALLOC(sizeof *m
);
1057 memset(m
, 0, sizeof *m
);
1060 struct gen_class
* class;
1061 class = jvm_create_class(mod
-> name
);
1063 fprintf(class -> fp
, ".source %s\n", mod
-> name
);
1064 fprintf(class -> fp
, ".class %s\n", mod
-> name
);
1065 fprintf(class -> fp
, ".super java/lang/Object\n\n");
1069 ctx
-> gen_context
-> current_m
= m
;
1073 oberon_generator_fini_module(oberon_module_t
* mod
)
1075 jvm_destroy_class(mod
-> gen_mod
-> class);
1079 push_expr(gen_proc_t
* p
, oberon_expr_t
* expr
);
1082 oberon_generate_begin_module(oberon_context_t
* ctx
)
1084 struct gen_class
* class = ctx
-> mod
-> gen_mod
-> class;
1085 gen_proc_t
* p
= jvm_create_proc(class);
1087 jvm_generate_function_header(p
, "public", "<init>", "()V");
1088 jvm_alloc_register_untyped(p
-> rf
, false);
1089 jvm_generate(p
, 0, 1, "aload_0");
1090 jvm_generate(p
, 1, 0, "invokespecial java/lang/Object/<init>()V");
1092 /* Инициализация переменных объявленных в модуле */
1093 oberon_object_t
* x
= ctx
-> mod
-> decl
-> list
-> next
;
1096 if(x
-> class == OBERON_CLASS_VAR
)
1098 if(x
-> type
-> class == OBERON_TYPE_ARRAY
1099 || x
-> type
-> class == OBERON_TYPE_RECORD
)
1101 jvm_generate_new(p
, x
-> type
, 0);
1102 jvm_generate_store(p
, x
-> type
, x
-> gen_var
);
1111 oberon_generate_end_module(oberon_context_t
* ctx
)
1113 struct gen_class
* class = ctx
-> mod
-> gen_mod
-> class;
1114 gen_proc_t
* p
= class -> p
;
1116 jvm_generate(p
, 0, 0, "return");
1117 jvm_generate_function_end(class -> p
);
1121 jvm_init_local_object(gen_proc_t
* p
, oberon_object_t
* x
)
1126 struct gen_class
* class;
1130 wide
= jvm_is_wide_type(x
-> type
);
1131 desc
= jvm_get_descriptor(x
-> type
);
1133 // Убеждаемся что сейчас находимся в функции
1139 case OBERON_CLASS_VAR
:
1140 case OBERON_CLASS_PARAM
:
1141 jvm_generate_and_init_named_local_var(v
, p
, wide
, x
-> name
, desc
);
1144 gen_error("jvm_init_local_object: wat");
1150 * Генерирует код для получения размера измерения массива
1151 * Аналог Обероновского LEN(v, n); где n = 0 - первое измерение.
1156 jvm_generate_array_len(gen_proc_t
* p
, int dim
)
1160 jvm_generate(p
, 0, 1, "iconst_0");
1161 jvm_generate(p
, 2, 1, "aaload");
1164 jvm_generate(p
, 1, 1, "arraylength");
1168 jvm_generate_array_duplicate_and_replace(gen_proc_t
* p
, gen_var_t
* v
, oberon_type_t
* arr
)
1171 oberon_type_t
* base
= arr
;
1172 while(base
-> class == OBERON_TYPE_ARRAY
)
1174 if(base
-> size
== 0)
1176 jvm_generate_load(p
, arr
, v
);
1177 jvm_generate_array_len(p
, dim
);
1180 base
= base
-> base
;
1183 jvm_generate_new(p
, arr
, dim
);
1184 jvm_generate(p
, 1, 2, "dup");
1185 jvm_generate_load(p
, arr
, v
);
1186 jvm_generate_copy_array(p
, arr
);
1187 jvm_generate_store(p
, arr
, v
);
1191 jvm_generate_record_duplicate_and_replace(gen_proc_t
* p
, gen_var_t
* v
, oberon_type_t
* rec
)
1193 jvm_generate_new(p
, rec
, 0);
1194 jvm_generate(p
, 1, 2, "dup");
1195 jvm_generate_load(p
, rec
, v
);
1196 jvm_generate_copy_record(p
, rec
);
1197 jvm_generate_store(p
, rec
, v
);
1201 oberon_generate_begin_proc(oberon_context_t
* ctx
, oberon_object_t
* proc
)
1206 p
= proc
-> gen_proc
;
1208 signature
= jvm_get_procedure_signature(proc
-> type
);
1209 jvm_generate_function_header(p
, "public static", proc
-> name
, signature
);
1211 /* Выделение регистров под параметры и переменные */
1212 oberon_object_t
* var
= proc
-> type
-> decl
;
1215 jvm_init_local_object(p
, var
);
1219 /* Копирование статических/открытых массивов и записей */
1220 var
= proc
-> type
-> decl
;
1223 if(var
-> class == OBERON_CLASS_PARAM
|| var
-> class == OBERON_CLASS_VAR_PARAM
)
1225 if(var
-> type
-> class == OBERON_TYPE_ARRAY
)
1227 jvm_generate_array_duplicate_and_replace(p
, var
-> gen_var
, var
-> type
);
1229 else if(var
-> type
-> class == OBERON_TYPE_RECORD
)
1231 jvm_generate_record_duplicate_and_replace(p
, var
-> gen_var
, var
-> type
);
1239 oberon_generate_end_proc(oberon_context_t
* ctx
)
1244 m
= ctx
-> mod
-> gen_mod
;
1245 p
= m
-> class -> p
;
1247 jvm_generate_function_end(p
);
1251 oberon_generator_reserve_label(oberon_context_t
* ctx
)
1257 m
= ctx
-> mod
-> gen_mod
;
1258 p
= m
-> class -> p
;
1260 l
= GC_MALLOC(sizeof *l
);
1261 memset(l
, 0, sizeof *l
);
1263 l
-> id
= jvm_new_label_id(p
);
1268 oberon_generate_label(oberon_context_t
* ctx
, gen_label_t
* l
)
1273 m
= ctx
-> mod
-> gen_mod
;
1274 p
= m
-> class -> p
;
1276 jvm_generate_label(p
, l
-> id
);
1280 oberon_generate_goto(oberon_context_t
* ctx
, gen_label_t
* l
)
1285 m
= ctx
-> mod
-> gen_mod
;
1286 p
= m
-> class -> p
;
1288 jvm_generate(p
, 0, 0, "goto L%i", l
-> id
);
1292 oberon_generate_branch(oberon_context_t
* ctx
, oberon_expr_t
* cond
, bool gotoif
, gen_label_t
* l
)
1297 m
= ctx
-> mod
-> gen_mod
;
1298 p
= m
-> class -> p
;
1304 /* переход если false */
1305 jvm_generate(p
, 1, 0, "ifeq L%i", l
-> id
);
1309 /* переход если true */
1310 jvm_generate(p
, 1, 0, "ifne L%i", l
-> id
);
1315 jvm_generate_call_proc(gen_proc_t
* p
, oberon_item_t
* desig
)
1317 assert(desig
-> var
== NULL
);
1318 assert(desig
-> mode
== MODE_CALL
);
1320 char * signature
= NULL
;
1322 bool direct_call
= false;
1323 if(desig
-> parent
-> mode
== MODE_VAR
)
1325 if(desig
-> parent
-> var
-> class == OBERON_CLASS_PROC
)
1331 printf("direct_call == %i\n", direct_call
);
1333 oberon_type_t
* procsig
;
1334 procsig
= desig
-> parent
-> result
;
1335 signature
= jvm_get_procedure_signature(procsig
);
1337 if(direct_call
== false)
1339 /* Загружаем указатель на процедуру */
1340 push_item(p
, desig
-> parent
);
1344 int result_cells
= jvm_cell_size_for_type(procsig
-> base
);
1346 int num
= desig
-> num_args
;
1347 oberon_expr_t
* arg
= desig
-> args
;
1348 for(int i
= 0; i
< num
; i
++)
1350 args_cells
+= jvm_cell_size_for_type(arg
-> result
);
1357 char * full_name
= jvm_get_field_full_name(desig
-> parent
-> var
);
1358 jvm_generate(p
, args_cells
, result_cells
, "invokestatic %s%s", full_name
, signature
);
1362 char * cname
= jvm_get_class_full_name(procsig
);
1363 jvm_generate(p
, 1 + args_cells
, result_cells
, "invokevirtual %s/invoke%s", cname
, signature
);
1368 oberon_generate_call_proc(oberon_context_t
* ctx
, oberon_expr_t
* desig
)
1370 assert(desig
-> is_item
);
1371 jvm_generate_call_proc(ctx
-> mod
-> gen_mod
-> class -> p
, (oberon_item_t
*) desig
);
1375 oberon_generate_return(oberon_context_t
* ctx
, oberon_expr_t
* expr
)
1382 m
= ctx
-> mod
-> gen_mod
;
1383 p
= m
-> class -> p
;
1388 prefix
= jvm_get_prefix(expr
-> result
);
1389 cell_size
= jvm_cell_size_for_type(expr
-> result
);
1390 jvm_generate(p
, cell_size
, 0, "%creturn", prefix
);
1394 jvm_generate(p
, 0, 0, "return");
1399 jvm_generate_expr_new_pointer(gen_proc_t
* p
, oberon_type_t
* type
, int num
, oberon_expr_t
* arg
)
1401 assert(type
-> class == OBERON_TYPE_POINTER
);
1403 for(int i
= 0; i
< num
; i
++)
1409 jvm_generate_new(p
, type
-> base
, num
);
1413 jvm_generate_cast_type(gen_proc_t
* p
, oberon_type_t
* from
, oberon_type_t
* to
)
1415 if(to
-> class == OBERON_TYPE_RECORD
|| to
-> class == OBERON_TYPE_POINTER
)
1417 char * full_name
= jvm_get_class_full_name(to
);
1418 jvm_generate(p
, 1, 1, "checkcast %s", full_name
);
1422 char prefix
= jvm_get_prefix(from
);
1423 char postfix
= jvm_get_postfix(to
);
1424 int from_cell_size
= jvm_cell_size_for_type(from
);
1425 int to_cell_size
= jvm_cell_size_for_type(to
);
1427 jvm_generate_comment(p
, "cast type class from %i(%i) to %i(%i)", from
-> class, from
-> size
, to
-> class, to
-> size
);
1429 if(prefix
== postfix
)
1434 jvm_generate(p
, from_cell_size
, to_cell_size
, "%c2%c", prefix
, postfix
);
1439 push_item(gen_proc_t
* p
, oberon_item_t
* item
)
1441 switch(item
-> mode
)
1444 if(item
-> var
-> class == OBERON_CLASS_PROC
)
1446 jvm_generate_push_procedure_pointer(p
, item
-> var
);
1450 jvm_generate_load(p
, item
-> result
, item
-> var
-> gen_var
);
1455 jvm_generate_push_int_size(p
, item
-> integer
, item
-> result
-> size
);
1458 jvm_generate_push_int_size(p
, item
-> boolean
, item
-> result
-> size
);
1461 jvm_generate_call_proc(p
, item
);
1465 char postfix
= jvm_get_postfix(item
-> result
);
1466 int cell_size
= jvm_cell_size_for_postfix(postfix
);
1467 assert(item
-> parent
-> is_item
);
1468 push_item(p
, (oberon_item_t
*) item
-> parent
);
1469 push_expr(p
, item
-> args
);
1470 jvm_generate(p
, 1 + 1, cell_size
, "%caload", postfix
);
1473 assert(item
-> parent
-> is_item
);
1474 push_item(p
, (oberon_item_t
*) item
-> parent
);
1475 jvm_generate_load(p
, item
-> result
, item
-> var
-> gen_var
);
1478 /* Все объекты в jvm представляются как указатели */
1479 assert(item
-> parent
-> is_item
);
1480 push_item(p
, (oberon_item_t
*) item
-> parent
);
1483 jvm_generate(p
, 0, 1, "aconst_null");
1486 jvm_generate_expr_new_pointer(p
, item
-> result
, item
-> num_args
, item
-> args
);
1489 jvm_generate_push_float(p
, item
-> real
, item
-> result
-> size
);
1492 jvm_generate_push_string(p
, item
-> string
, item
-> result
-> size
);
1495 gen_error("push_item: unk mode %i", item
-> mode
);
1501 jvm_generate_logical_not(gen_proc_t
* p
)
1503 int label_done
= jvm_new_label_id(p
);
1504 int label_false
= jvm_new_label_id(p
);
1505 char * label_name_done
= jvm_get_label_name(label_done
);
1506 char * label_name_false
= jvm_get_label_name(label_false
);
1508 jvm_generate(p
, 1, 0, "ifne %s", label_name_false
);
1509 jvm_generate(p
, 0, 1, "iconst_1");
1510 jvm_generate(p
, 0, 0, "goto %s", label_name_done
);
1511 jvm_generate_label(p
, label_false
);
1512 jvm_generate(p
, 0, 1, "iconst_0");
1513 jvm_generate_label(p
, label_done
);
1517 jvm_generate_abs(gen_proc_t
* p
, char prefix
)
1519 char t
= jvm_get_type_of_prefix(prefix
);
1520 int cell_size
= jvm_cell_size_for_postfix(prefix
);
1521 jvm_generate(p
, cell_size
, cell_size
, "invokestatic java/lang/Math/abs(%c)%c", t
, t
);
1525 jvm_generate_compare_op(gen_proc_t
* p
, oberon_type_t
* t
, char prefix
, int op
)
1527 int label_true
= jvm_new_label_id(p
);
1528 int label_done
= jvm_new_label_id(p
);
1529 char * label_name_true
= jvm_get_label_name(label_true
);
1530 char * label_name_done
= jvm_get_label_name(label_done
);
1531 int cell_size
= 2 * jvm_cell_size_for_postfix(prefix
);
1533 assert(prefix
== 'i' || prefix
== 'a');
1535 const char * cmpop
= "";
1557 gen_error("jvm_generate_compare_op: wat");
1561 jvm_generate(p
, cell_size
, 0, "if_%ccmp%s %s", prefix
, cmpop
, label_name_true
);
1562 jvm_generate(p
, 0, 1, "iconst_0");
1563 jvm_generate(p
, 0, 0, "goto %s", label_name_done
);
1564 jvm_generate_label(p
, label_true
);
1565 jvm_generate(p
, 0, 1, "iconst_1");
1566 jvm_generate_label(p
, label_done
);
1570 jvm_generate_operator(gen_proc_t
* p
, oberon_type_t
* t
, char prefix
, int op
)
1572 int cell_size
= jvm_cell_size_for_postfix(prefix
);
1575 case OP_UNARY_MINUS
:
1576 jvm_generate(p
, cell_size
, cell_size
, "%cneg", prefix
);
1578 case OP_BITWISE_NOT
:
1579 jvm_generate_push_int(p
, -1);
1580 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cxor", prefix
);
1583 jvm_generate_logical_not(p
);
1586 jvm_generate_abs(p
, prefix
);
1590 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cadd", prefix
);
1593 jvm_generate(p
, 2 * cell_size
, cell_size
, "%csub", prefix
);
1596 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cmul", prefix
);
1599 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cdiv", prefix
);
1602 jvm_generate(p
, 2 * cell_size
, cell_size
, "%crem", prefix
);
1604 case OP_BITWISE_AND
:
1605 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cand", prefix
);
1607 case OP_BITWISE_XOR
:
1608 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cxor", prefix
);
1611 jvm_generate(p
, 2 * cell_size
, cell_size
, "%cor", prefix
);
1620 jvm_generate_compare_op(p
, t
, prefix
, op
);
1623 gen_error("jvm_generate_operator: unk op %i", op
);
1629 jvm_generate_logical_or(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1631 int label_calc_b
= jvm_new_label_id(p
);
1632 int label_done
= jvm_new_label_id(p
);
1633 char * label_name_calc_b
= jvm_get_label_name(label_calc_b
);
1634 char * label_name_done
= jvm_get_label_name(label_done
);
1636 /* a OR b -- если a, то TRUE, иначе b */
1639 jvm_generate(p
, 1, 0, "ifne %s", label_name_calc_b
);
1640 jvm_generate(p
, 0, 1, "iconst_1");
1641 jvm_generate(p
, 0, 0, "goto %s", label_name_done
);
1642 jvm_generate_label(p
, label_calc_b
);
1644 jvm_generate_label(p
, label_done
);
1648 jvm_generate_logical_and(gen_proc_t
* p
, oberon_expr_t
* a
, oberon_expr_t
* b
)
1650 int label_false
= jvm_new_label_id(p
);
1651 int label_done
= jvm_new_label_id(p
);
1652 char * label_name_false
= jvm_get_label_name(label_false
);
1653 char * label_name_done
= jvm_get_label_name(label_done
);
1655 /* a AND b -- если a, то b, иначе FALSE */
1658 jvm_generate(p
, 1, 0, "ifne %s", label_name_false
);
1660 jvm_generate(p
, 0, 0, "goto %s", label_name_done
);
1661 jvm_generate_label(p
, label_false
);
1662 jvm_generate(p
, 0, 1, "iconst_0");
1663 jvm_generate_label(p
, label_done
);
1667 push_operator(gen_proc_t
* p
, oberon_oper_t
* oper
)
1669 oberon_type_t
* preq
= oper
-> left
-> result
;
1670 char prefix
= jvm_get_prefix(oper
-> result
);
1671 int op
= oper
-> op
;
1675 push_expr(p
, oper
-> left
);
1676 jvm_generate_cast_type(p
, oper
-> left
-> result
, oper
-> result
);
1678 case OP_UNARY_MINUS
:
1679 case OP_BITWISE_NOT
:
1682 push_expr(p
, oper
-> left
);
1683 jvm_generate_operator(p
, preq
, prefix
, op
);
1691 case OP_BITWISE_AND
:
1692 case OP_BITWISE_XOR
:
1701 push_expr(p
, oper
-> left
);
1702 push_expr(p
, oper
-> right
);
1703 jvm_generate_operator(p
, preq
, prefix
, op
);
1707 jvm_generate_logical_or(p
, oper
-> left
, oper
-> right
);
1710 jvm_generate_logical_and(p
, oper
-> left
, oper
-> right
);
1713 gen_error("push_oper: unk op %i", op
);
1719 push_expr(gen_proc_t
* p
, oberon_expr_t
* expr
)
1723 push_item(p
, (oberon_item_t
*) expr
);
1727 push_operator(p
, (oberon_oper_t
*) expr
);
1732 store_expr(gen_proc_t
* p
, oberon_expr_t
* dst
, oberon_expr_t
* src
)
1734 assert(dst
-> is_item
);
1735 oberon_item_t
* item
= (oberon_item_t
*) dst
;
1737 if(dst
-> result
-> class == OBERON_TYPE_ARRAY
1738 || src
-> result
-> class == OBERON_TYPE_ARRAY
)
1742 jvm_generate_copy_array(p
, dst
-> result
);
1744 else if(dst
-> result
-> class == OBERON_TYPE_RECORD
1745 || src
-> result
-> class == OBERON_TYPE_RECORD
)
1749 jvm_generate_copy_record(p
, dst
-> result
);
1751 else switch(item
-> mode
)
1755 jvm_generate_store(p
, src
-> result
, item
-> var
-> gen_var
);
1759 char postfix
= jvm_get_postfix(src
-> result
);
1760 int cell_size
= jvm_cell_size_for_postfix(postfix
);
1761 assert(item
-> parent
-> is_item
);
1762 push_item(p
, (oberon_item_t
*) item
-> parent
);
1763 push_expr(p
, item
-> args
);
1765 jvm_generate(p
, 1 + 1 + cell_size
, 0, "%castore", postfix
);
1768 assert(item
-> parent
-> is_item
);
1769 push_item(p
, (oberon_item_t
*) item
-> parent
);
1771 jvm_generate_store(p
, src
-> result
, item
-> var
-> gen_var
);
1774 gen_error("store_expr: unk mode %i", item
-> mode
);
1780 oberon_generate_assign(oberon_context_t
* ctx
, oberon_expr_t
* src
, oberon_expr_t
* dst
)
1785 m
= ctx
-> mod
-> gen_mod
;
1786 p
= m
-> class -> p
;
1788 store_expr(p
, dst
, src
);
1792 oberon_generate_code(oberon_context_t
* ctx
)
1794 printf("generate code\n");
1798 oberon_generator_dump(oberon_context_t
* ctx
, char * path
)
1800 printf("jit: dump code\n");
1804 oberon_generator_get_procedure(oberon_context_t
* ctx
, const char * name
)
1806 printf("jit: get pointer to procedure %s\n", name
);
1811 oberon_generator_get_var(oberon_context_t
* ctx
, const char * name
)
1813 printf("jit: get pointer to var %s\n", name
);