DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / dsw-obn.git / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Исправлено действие конструкции WITH
[dsw-obn.git] / src / backends / jvm / generator-jvm-abi.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <stdarg.h>
4 #include <stdint.h>
5 #include <stdbool.h>
6 #include <string.h>
7 #include <assert.h>
8
9 #include <gc.h>
10
11 #include "../../oberon-internals.h"
12 #include "generator-jvm.h"
13 #include "generator-jvm-abi.h"
14 #include "generator-jvm-asm.h"
15 #include "generator-jvm-basic.h"
16
17 void
18 jvm_generate_ldst_prepare(gen_proc_t * p, gen_var_t * v)
19 {
20 char * desc = v -> type -> desc;
21 char * full_name = v -> full_name;
22 switch(v -> storage)
23 {
24 case JVM_STORAGE_REGISTER:
25 case JVM_STORAGE_STATIC:
26 case JVM_STORAGE_FIELD:
27 case JVM_STORAGE_PARAM:
28 break;
29 case JVM_STORAGE_REGISTER_VAR:
30 case JVM_STORAGE_PARAM_VAR:
31 jvm_generate(p, 0, 1, "aload %i", v -> reg);
32 jvm_generate(p, 0, 1, "iconst_0");
33 break;
34 case JVM_STORAGE_STATIC_VAR:
35 jvm_generate(p, 0, 1, "getstatic %s [%s", full_name, desc);
36 jvm_generate(p, 0, 1, "iconst_0");
37 break;
38 case JVM_STORAGE_FIELD_VAR:
39 jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc);
40 jvm_generate(p, 0, 1, "iconst_0");
41 break;
42 case JVM_STORAGE_PARAM_VARPTR:
43 jvm_generate(p, 0, 1, "aload %i", v -> reg);
44 jvm_generate(p, 0, 1, "iload %i", v -> reg + 1);
45 break;
46 case JVM_STORAGE_FRAME:
47 case JVM_STORAGE_FRAME_PARAM:
48 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
49 break;
50 case JVM_STORAGE_FRAME_VAR:
51 case JVM_STORAGE_FRAME_PARAM_VAR:
52 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
53 jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc);
54 jvm_generate(p, 0, 1, "iconst_0");
55 break;
56 case JVM_STORAGE_FRAME_PARAM_VARPTR:
57 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
58 jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc);
59 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
60 jvm_generate(p, 1, 1, "getfield %s$offset I", full_name);
61 break;
62 default:
63 gen_error("jvm_abi_obn_generate_ldst_prepare: wat %i", v -> storage);
64 }
65 }
66
67 void
68 jvm_generate_load(gen_proc_t * p, gen_var_t * src)
69 {
70 char prefix = src -> type -> prefix;
71 char postfix = src -> type -> postfix;
72 int cell_size = src -> type -> cell_size;
73 char * full_name = src -> full_name;
74 char * desc = src -> type -> desc;
75
76 switch(src -> storage)
77 {
78 case JVM_STORAGE_REGISTER:
79 case JVM_STORAGE_PARAM:
80 jvm_generate(p, 0, cell_size, "%cload %i", prefix, src -> reg);
81 break;
82 case JVM_STORAGE_STATIC:
83 jvm_generate(p, 0, cell_size, "getstatic %s %s", full_name, desc);
84 break;
85 case JVM_STORAGE_FIELD:
86 jvm_generate(p, 0, cell_size, "getfield %s %s", full_name, desc);
87 break;
88 case JVM_STORAGE_REGISTER_VAR:
89 case JVM_STORAGE_STATIC_VAR:
90 case JVM_STORAGE_FIELD_VAR:
91 case JVM_STORAGE_PARAM_VAR:
92 case JVM_STORAGE_PARAM_VARPTR:
93 case JVM_STORAGE_FRAME_VAR:
94 case JVM_STORAGE_FRAME_PARAM_VAR:
95 case JVM_STORAGE_FRAME_PARAM_VARPTR:
96 jvm_generate_ldst_prepare(p, src);
97 jvm_generate(p, 1 + 1, cell_size, "%caload", postfix);
98 break;
99 case JVM_STORAGE_FRAME:
100 case JVM_STORAGE_FRAME_PARAM:
101 jvm_generate_ldst_prepare(p, src);
102 jvm_generate(p, 1, cell_size, "getfield %s %s", full_name, desc);
103 break;
104 default:
105 gen_error("jvm_generate_load: unknow storage type %i", src -> storage);
106 break;
107 }
108
109 if(src -> typecheck)
110 {
111 jvm_generate(p, 1, 1, "checkcast %s", src -> forcetype -> full_name);
112 }
113 }
114
115 void
116 jvm_generate_store(gen_proc_t * p, gen_var_t * dst)
117 {
118 char prefix = dst -> type -> prefix;
119 char postfix = dst -> type -> postfix;
120 int cell_size = dst -> type -> cell_size;
121 char * full_name = dst -> full_name;
122 char * desc = dst -> type -> desc;
123
124 switch(dst -> storage)
125 {
126 case JVM_STORAGE_REGISTER:
127 case JVM_STORAGE_PARAM:
128 jvm_generate(p, cell_size, 0, "%cstore %i", prefix, dst -> reg);
129 break;
130 case JVM_STORAGE_STATIC:
131 jvm_generate(p, 0, cell_size, "putstatic %s %s", full_name, desc);
132 break;
133 case JVM_STORAGE_FIELD:
134 jvm_generate(p, 0, cell_size, "putfield %s %s", full_name, desc);
135 break;
136 case JVM_STORAGE_REGISTER_VAR:
137 case JVM_STORAGE_STATIC_VAR:
138 case JVM_STORAGE_FIELD_VAR:
139 case JVM_STORAGE_PARAM_VAR:
140 case JVM_STORAGE_PARAM_VARPTR:
141 case JVM_STORAGE_FRAME_VAR:
142 case JVM_STORAGE_FRAME_PARAM_VAR:
143 case JVM_STORAGE_FRAME_PARAM_VARPTR:
144 jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix);
145 break;
146 case JVM_STORAGE_FRAME:
147 case JVM_STORAGE_FRAME_PARAM:
148 jvm_generate(p, 0, cell_size, "putfield %s %s", full_name, desc);
149 break;
150 default:
151 gen_error("jvm_generate_store: unknow storage type %i", dst -> storage);
152 break;
153 }
154 }
155
156 static gen_var_t *
157 jvm_new_var()
158 {
159 gen_var_t * v = GC_MALLOC(sizeof *v);
160 memset(v, 0, sizeof *v);
161 return v;
162 }
163
164 gen_var_t *
165 jvm_create_class_var(struct gen_class * class, enum gen_storage storage, char * name, gen_type_t * t)
166 {
167 gen_var_t * v = jvm_new_var();
168 v -> storage = storage;
169 v -> name = new_string(name);
170 v -> type = t;
171 v -> class = class;
172
173 assert(class -> p == NULL);
174 switch(storage)
175 {
176 case JVM_STORAGE_STATIC:
177 case JVM_STORAGE_FIELD:
178 case JVM_STORAGE_STATIC_VAR:
179 case JVM_STORAGE_FIELD_VAR:
180 v -> full_name = new_string("%s/%s", class -> full_name, name);
181 break;
182 default:
183 gen_error("jvm_create_class_var: invalid storage %i", storage);
184 break;
185 }
186
187 return v;
188 }
189
190 gen_var_t *
191 jvm_create_function_var(gen_proc_t * p, enum gen_storage storage, char * name, gen_type_t * t)
192 {
193 gen_var_t * v = jvm_new_var();
194 v -> storage = storage;
195 v -> name = new_string(name);
196 v -> type = t;
197 v -> p = p;
198 v -> level = p -> level;
199
200 switch(storage)
201 {
202 case JVM_STORAGE_REGISTER:
203 case JVM_STORAGE_PARAM:
204 case JVM_STORAGE_PARAM_VAR:
205 v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
206 break;
207 case JVM_STORAGE_PARAM_VARPTR:
208 /* Содержит пару массив+индекс */
209 v -> reg = jvm_alloc_register_untyped(p -> rf, true);
210 break;
211 case JVM_STORAGE_REGISTER_VAR:
212 /* Содержит массив */
213 v -> reg = jvm_alloc_register_untyped(p -> rf, false);
214 break;
215 case JVM_STORAGE_FRAME:
216 case JVM_STORAGE_FRAME_VAR:
217 v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
218 break;
219 case JVM_STORAGE_FRAME_PARAM:
220 case JVM_STORAGE_FRAME_PARAM_VAR:
221 v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
222 v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
223 break;
224 case JVM_STORAGE_FRAME_PARAM_VARPTR:
225 /* Содержит пару массив+индекс */
226 v -> reg = jvm_alloc_register_untyped(p -> rf, true);
227 v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
228 break;
229 default:
230 gen_error("jvm_create_class_var: invalid storage %i", storage);
231 break;
232 }
233
234 return v;
235 }
236
237 gen_var_t *
238 jvm_create_function_temp_var(gen_proc_t * p, gen_type_t * t)
239 {
240 gen_var_t * v = jvm_new_var();
241 v -> storage = JVM_STORAGE_REGISTER;
242 v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
243 v -> name = new_string("$TEMP_%i$", v -> reg);
244 v -> type = t;
245 v -> p = p;
246 v -> level = p -> level;
247 return v;
248 }
249
250 void
251 jvm_generate_var(gen_var_t * v)
252 {
253 enum gen_storage storage = v -> storage;
254 int reg = v -> reg;
255 char * name = v -> name;
256 char * desc = v -> type -> desc;
257 gen_proc_t * p = v -> p;
258
259 switch(v -> storage)
260 {
261 case JVM_STORAGE_REGISTER:
262 case JVM_STORAGE_PARAM:
263 case JVM_STORAGE_PARAM_VAR:
264 case JVM_STORAGE_FRAME_PARAM:
265 case JVM_STORAGE_FRAME_PARAM_VAR:
266 jvm_generate(p, 0, 0, ".var %i is '%s' %s from start to end", reg, name, desc);
267 break;
268 case JVM_STORAGE_FRAME:
269 case JVM_STORAGE_FRAME_VAR:
270 break;
271 case JVM_STORAGE_REGISTER_VAR:
272 jvm_generate(p, 0, 0, ".var %i is '%s' [%s from start to end", reg, name, desc);
273 break;
274 case JVM_STORAGE_PARAM_VARPTR:
275 case JVM_STORAGE_FRAME_PARAM_VARPTR:
276 jvm_generate(p, 0, 0, ".var %i is '%s' [%s from start to end", reg, name, desc);
277 jvm_generate(p, 0, 0, ".var %i is '%s$offset' I from start to end", reg + 1, name);
278 break;
279 case JVM_STORAGE_STATIC:
280 fprintf(v -> class -> fp, ".field public static '%s' %s\n\n", name, desc);
281 break;
282 case JVM_STORAGE_STATIC_VAR:
283 fprintf(v -> class -> fp, ".field public static '%s' [%s\n\n", name, desc);
284 break;
285 case JVM_STORAGE_FIELD:
286 fprintf(v -> class -> fp, ".field public '%s' %s\n\n", name, desc);
287 break;
288 case JVM_STORAGE_FIELD_VAR:
289 fprintf(v -> class -> fp, ".field public '%s' [%s\n\n", name, desc);
290 break;
291 default:
292 gen_error("jvm_generate_var: invalid storage %i", storage);
293 break;
294 }
295 }
296
297 static void
298 jvm_generate_param_initialization(gen_proc_t * p, gen_var_t * v)
299 {
300 int old_reg = v -> reg;
301 int cell_size = v -> type -> cell_size;
302 char prefix = v -> type -> prefix;
303 char postfix = v -> type -> postfix;
304 char * name = v -> name;
305 char * desc = v -> type -> desc;
306
307 v -> reg = jvm_alloc_register_untyped(p -> rf, false);
308 jvm_generate(p, 0, 0, ".var %i is $%s [%s from start to end", v -> reg, name, desc);
309
310 jvm_generate(p, 0, 1, "iconst_1");
311 jvm_generate(p, 1, 1, "multianewarray [%s 1", desc);
312 jvm_generate(p, 1, 2, "dup");
313 jvm_generate(p, 1, 0, "astore %i", v -> reg);
314
315 jvm_generate(p, 0, 1, "iconst_0");
316 jvm_generate(p, 0, cell_size, "%cload %i", prefix, old_reg);
317 jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix);
318 }
319
320 void
321 jvm_generate_var_initialization(gen_proc_t * p, gen_var_t * v)
322 {
323 if(v -> storage == JVM_STORAGE_REGISTER_VAR)
324 {
325 jvm_generate(p, 0, 1, "iconst_1");
326 jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc);
327 jvm_generate(p, 1, 0, "astore %i", v -> reg);
328 }
329 else if(v -> storage == JVM_STORAGE_STATIC_VAR)
330 {
331 jvm_generate(p, 0, 1, "iconst_1");
332 jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc);
333 jvm_generate(p, 1, 0, "putstatic %s [%s", v -> full_name, v -> type -> desc);
334 }
335 else if(v -> storage == JVM_STORAGE_FIELD_VAR)
336 {
337 jvm_generate(p, 0, 1, "iconst_1");
338 jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc);
339 jvm_generate(p, 1, 0, "putfield %s [%s", v -> full_name, v -> type -> desc);
340 }
341 else if(v -> storage == JVM_STORAGE_PARAM_VAR)
342 {
343 jvm_generate_param_initialization(p, v);
344 }
345 else if(v -> storage == JVM_STORAGE_FRAME_PARAM
346 || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
347 {
348 jvm_generate_ldst_prepare(p, v);
349 jvm_generate(p, 0, v -> type -> cell_size, "%cload %i", v -> type -> prefix, v -> reg);
350 jvm_generate_store(p, v);
351 }
352 else if(v -> storage == JVM_STORAGE_FRAME_PARAM_VARPTR)
353 {
354 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
355 jvm_generate(p, 0, 1, "aload %i", v -> reg);
356 jvm_generate(p, 1, 0, "putfield %s [%s", v -> full_name, v -> type -> desc);
357
358 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
359 jvm_generate(p, 0, 1, "iload %i", v -> reg + 1);
360 jvm_generate(p, 1, 0, "putfield %s$offset I", v -> full_name);
361 }
362 }
363
364 /*
365 static void
366 jvm_generate_abstract_frame_class()
367 {
368 FILE * fp;
369 char * cname;
370 struct gen_class * class;
371
372 cname = "SYSTEM$FRAME";
373 class = jvm_create_class(cname);
374 fp = class -> fp;
375
376 fprintf(fp, ".source SYSTEM\n");
377 fprintf(fp, ".class public abstract %s\n", cname);
378 fprintf(fp, ".super java/lang/Object\n\n");
379
380 fprintf(fp, ".field public $UP L%s;\n\n", cname);
381
382 fprintf(fp, ".method <init>()V\n");
383 fprintf(fp, " aload_0\n");
384 fprintf(fp, " invokespecial java/lang/Object/<init>()V\n");
385 fprintf(fp, " return\n");
386 fprintf(fp, ".end method\n\n");
387
388 jvm_destroy_class(class);
389 }
390 */
391
392 static struct gen_class *
393 jvm_generate_frame_class(oberon_object_t * proc)
394 {
395 FILE * fp;
396 char * cname;
397 char * abscname;
398 struct gen_class * class;
399 oberon_object_t * var;
400
401 abscname = "SYSTEM$FRAME";
402 cname = jvm_get_field_full_name_safe(proc);
403 cname = new_string("%s$FRAME", cname);
404 class = jvm_create_class(proc -> gen_proc -> class -> dir, cname);
405 fp = class -> fp;
406
407 class -> full_name = cname;
408
409 fprintf(fp, ".source %s\n", proc -> module -> name);
410 fprintf(fp, ".class public %s\n", cname);
411 fprintf(fp, ".super %s\n\n", abscname);
412
413 var = proc -> scope -> list -> next;
414 while(var)
415 {
416 if(var -> class == OBERON_CLASS_VAR
417 || var -> class == OBERON_CLASS_PARAM
418 || var -> class == OBERON_CLASS_VAR_PARAM)
419 {
420 gen_var_t * v = var -> gen_var;
421 if(v -> storage == JVM_STORAGE_FRAME
422 || v -> storage == JVM_STORAGE_FRAME_PARAM)
423 {
424 fprintf(fp, "; LEVEL %i\n", v -> level);
425 fprintf(fp, ".field public '%s' %s\n\n", v -> name, v -> type -> desc);
426 }
427 else if(v -> storage == JVM_STORAGE_FRAME_VAR
428 || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
429 {
430 fprintf(fp, "; LEVEL %i\n", v -> level);
431 fprintf(fp, ".field public '%s' [%s\n\n", v -> name, v -> type -> desc);
432 }
433 else if(v -> storage == JVM_STORAGE_FRAME_PARAM_VARPTR)
434 {
435 fprintf(fp, "; LEVEL %i\n", v -> level);
436 fprintf(fp, ".field public '%s' [%s\n", v -> name, v -> type -> desc);
437 fprintf(fp, ".field public '%s$offset' I\n\n", v -> name);
438 }
439 }
440 var = var -> next;
441 }
442
443 fprintf(fp, ".method <init>()V\n");
444 fprintf(fp, " .limit stack 2\n");
445 fprintf(fp, " aload_0\n");
446 fprintf(fp, " invokespecial %s/<init>()V\n", abscname);
447
448 var = proc -> scope -> list -> next;
449 while(var)
450 {
451 if(var -> class == OBERON_CLASS_VAR
452 || var -> class == OBERON_CLASS_PARAM
453 || var -> class == OBERON_CLASS_VAR_PARAM)
454 {
455 gen_var_t * v = var -> gen_var;
456 if(v -> storage == JVM_STORAGE_FRAME_VAR
457 || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
458 {
459 fprintf(fp, " aload_0\n");
460 fprintf(fp, " iconst_1\n");
461 fprintf(fp, " multianewarray [%s 1\n", v -> type -> desc);
462 fprintf(fp, " putfield %s [%s\n", v -> full_name, v -> type -> desc);
463 }
464 }
465 var = var -> next;
466 }
467
468 fprintf(fp, " return\n");
469 fprintf(fp, ".end method\n\n");
470
471 jvm_destroy_class(class);
472
473 return class;
474 }
475
476 void
477 jvm_generate_procedure_frame(oberon_object_t * proc)
478 {
479 gen_proc_t * p;
480 gen_type_t * t;
481 gen_var_t * v;
482 struct gen_class * class;
483
484 p = proc -> gen_proc;
485
486 // jvm_generate_abstract_frame_class();
487
488 class = jvm_generate_frame_class(proc);
489
490 t = GC_MALLOC(sizeof *t);
491 memset(t, 0, sizeof *t);
492 t -> class = class;
493 t -> wide = false;
494 t -> prefix = 'a';
495 t -> postfix = 'a';
496 t -> cell_size = 1;
497 t -> desc = new_string("L%s;", class -> full_name);
498
499 v = jvm_create_function_var(p, JVM_STORAGE_REGISTER, "$FP$", t);
500 p -> frame_v = v;
501 p -> reg_frame[p -> level] = v -> reg;
502 }
503
504 void
505 jvm_generate_frame_initialization(gen_proc_t * p)
506 {
507 jvm_generate_var(p -> frame_v);
508 jvm_generate_ldst_prepare(p, p -> frame_v);
509 jvm_generate(p, 0, 1, "new %s", p -> frame_v -> type -> class -> full_name);
510 jvm_generate(p, 1, 2, "dup");
511 jvm_generate(p, 1, 0, "invokespecial %s/<init>()V", p -> frame_v -> type -> class -> full_name);
512 jvm_generate_store(p, p -> frame_v);
513 }
514
515 char *
516 jvm_get_procedure_signature(oberon_type_t * ps)
517 {
518 char * signature;
519 char * desc;
520 int num;
521 oberon_object_t * arg;
522
523 signature = new_string("(");
524
525 num = ps -> num_decl;
526 arg = ps -> decl;
527 for(int i = 0; i < num; i++)
528 {
529 desc = jvm_get_descriptor(arg -> type);
530 if(arg -> class == OBERON_CLASS_VAR_PARAM)
531 {
532 signature = new_string("%s[%sI", signature, desc);
533 }
534 else
535 {
536 signature = new_string("%s%s", signature, desc);
537 }
538 arg = arg -> next;
539 }
540
541 desc = jvm_get_descriptor(ps -> base);
542 signature = new_string("%s)%s", signature, desc);
543
544 return signature;
545 }
546
547 static char *
548 jvm_get_frame_descriptor(oberon_object_t * proc)
549 {
550 char * full_name = jvm_get_field_full_name_safe(proc);
551 return new_string("L%s$FRAME;", full_name);
552 }
553
554 static char *
555 jvm_get_oberon_signature_static_links(oberon_object_t * parent)
556 {
557 if(parent == NULL)
558 {
559 return "";
560 }
561
562 char * up = jvm_get_oberon_signature_static_links(parent -> parent);
563 char * desc = jvm_get_frame_descriptor(parent);
564 return new_string("%s%s", up, desc);
565 }
566
567 char *
568 jvm_get_local_procedure_signature(oberon_object_t * proc)
569 {
570 char * stlinks;
571 char * signature;
572 char * desc;
573 int num;
574 oberon_object_t * arg;
575 oberon_type_t * ps;
576
577 ps = proc -> type;
578
579 signature = new_string("(");
580
581 if(proc -> local)
582 {
583 stlinks = jvm_get_oberon_signature_static_links(proc -> parent);
584 signature = new_string("%s%s", signature, stlinks);
585 }
586
587 num = ps -> num_decl;
588 arg = ps -> decl;
589 for(int i = 0; i < num; i++)
590 {
591 desc = jvm_get_descriptor(arg -> type);
592 if(arg -> class == OBERON_CLASS_VAR_PARAM)
593 {
594 signature = new_string("%s[%sI", signature, desc);
595 }
596 else
597 {
598 signature = new_string("%s%s", signature, desc);
599 }
600 arg = arg -> next;
601 }
602
603 desc = jvm_get_descriptor(ps -> base);
604 signature = new_string("%s)%s", signature, desc);
605
606 return signature;
607 }
608
609
610 static void
611 jvm_generate_staticlinks_recursive(gen_proc_t * p, oberon_object_t * parent, int level)
612 {
613 if(parent == NULL)
614 {
615 return;
616 }
617
618 jvm_generate_staticlinks_recursive(p, parent -> parent, level - 1);
619 int reg = p -> reg_frame[level];
620 char * desc = jvm_get_frame_descriptor(parent);
621 jvm_generate(p, 0, 0, ".var %i is SL$%i %s from start to end", reg, level, desc);
622 }
623
624 void
625 jvm_generate_staticlinks(oberon_object_t * proc)
626 {
627 gen_proc_t * p;
628
629 p = proc -> gen_proc;
630
631 jvm_generate_staticlinks_recursive(p, proc -> parent, p -> level - 1);
632 }
633
634 static void
635 jvm_create_staticlinks_recursive(gen_proc_t * p, oberon_object_t * parent, int level)
636 {
637 if(parent == NULL)
638 {
639 return;
640 }
641
642 jvm_create_staticlinks_recursive(p, parent -> parent, level - 1);
643 p -> reg_frame[level] = jvm_alloc_register_untyped(p -> rf, false);
644 }
645
646 void
647 jvm_create_static_links(oberon_object_t * proc)
648 {
649 gen_proc_t * p;
650 p = proc -> gen_proc;
651
652 int max_frames = 0;
653 oberon_object_t * prc = proc;
654 while(prc)
655 {
656 max_frames += 1;
657 prc = prc -> parent;
658 }
659
660 size_t sz = sizeof(*p -> reg_frame) * max_frames;
661 p -> max_frames = max_frames;
662 p -> reg_frame = GC_MALLOC(sz);
663 memset(p -> reg_frame, 255, sz);
664
665 p -> level = max_frames - 1;
666
667 jvm_create_staticlinks_recursive(p, proc -> parent, p -> level - 1);
668 }
669
670 static void
671 jvm_generate_push_static_links_recursive(gen_proc_t * p, oberon_object_t * parent)
672 {
673 if(parent == NULL)
674 {
675 return;
676 }
677
678 jvm_generate_push_static_links_recursive(p, parent -> parent);
679 int level = parent -> gen_proc -> level;
680 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[level]);
681 }
682
683 void
684 jvm_generate_push_static_links(gen_proc_t * p, oberon_object_t * proc)
685 {
686 jvm_generate_push_static_links_recursive(p, proc -> parent);
687 }
Another attempt to make Oberon compiler
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024