src/backends/jvm/generator-jvm.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 "../../../include/oberon.h"
  12 #include "../../oberon-internals.h"
  13 #include "generator-jvm.h"
  14 #include "generator-jvm-basic.h"
  15
  16 // ==========================================
  17 // ==========================================
  18 // ==========================================
  19
  20 gen_proc_t *
  21 jvm_create_proc(struct gen_class * class)
  22 {
  23         gen_proc_t * p = GC_MALLOC(sizeof *p);
  24         memset(p, 0, sizeof *p);
  25
  26         struct gen_register_file * rf = GC_MALLOC(sizeof *rf);
  27         memset(rf, 0, sizeof *rf);
  28
  29         struct gen_stack * stack = GC_MALLOC(sizeof *stack);
  30         memset(rf, 0, sizeof *stack);
  31
  32         p -> rf = rf;
  33         p -> stack = stack;
  34         p -> class = class;
  35         p -> label_id = 0;
  36
  37         return p;
  38 }
  39
  40 void
  41 jvm_generate_function_header(gen_proc_t * p, char * access, char * name, char * signature)
  42 {
  43         struct gen_class * class;
  44         class = p -> class;
  45
  46         /* Делаем процедуру текущей в этом классе */
  47         assert(class -> p == NULL);
  48         class -> p = p;
  49
  50         fprintf(class -> fp, ".method %s %s%s\n", access, name, signature);
  51 }
  52
  53 void
  54 jvm_generate_function_end(gen_proc_t * p)
  55 {
  56         struct gen_class * class;
  57         class = p -> class;
  58
  59         assert(class -> p);
  60         class -> p = NULL;
  61
  62         int pointer = p -> stack -> pointer;
  63         int max_pointer = p -> stack -> max_pointer;
  64         int locals = p -> rf -> num_used;
  65         int max_locals = p -> rf -> max_used;
  66
  67         fprintf(class -> fp, "  .limit stack %i \t; current(%i)\n", max_pointer, pointer);
  68         fprintf(class -> fp, "  .limit locals %i \t; current(%i)\n", max_locals, locals);
  69         fprintf(class -> fp, ".end method\n\n");
  70 }
  71
  72 struct gen_class *
  73 jvm_create_class(char * full_name)
  74 {
  75         struct gen_class * class = GC_MALLOC(sizeof *class);
  76         memset(class, 0, sizeof *class);
  77
  78         char * fname = new_string("%s.j", full_name);
  79         class -> full_name = new_string(full_name);
  80         class -> fp = fopen(fname, "w");
  81         assert(class -> fp);
  82
  83         return class;
  84 }
  85
  86 static void
  87 jvm_destroy_class(struct gen_class * class)
  88 {
  89         assert(class -> p == NULL);
  90         fclose(class -> fp);
  91 }
  92
  93 static void
  94 jvm_stack_push(gen_proc_t * p, unsigned size)
  95 {
  96         p -> stack -> pointer += size;
  97         if(p -> stack -> pointer > p -> stack -> max_pointer)
  98         {
  99                 p -> stack -> max_pointer = p -> stack -> pointer;
 100         }
 101 }
 102
 103 static void
 104 jvm_stack_pop(gen_proc_t * p, unsigned size)
 105 {
 106         p -> stack -> pointer -= size;
 107         assert(p -> stack -> pointer >= 0);
 108 }
 109
 110 static void
 111 jvm_generate(gen_proc_t * p, unsigned get, unsigned push, char * format, ...)
 112 {
 113         va_list ptr;
 114         va_start(ptr, format);
 115
 116         jvm_stack_pop(p, get);
 117         fprintf(p -> class -> fp, "  ");
 118         vfprintf(p -> class -> fp, format, ptr);
 119         jvm_stack_push(p, push);
 120         fprintf(p -> class -> fp, " \t ;>>>> %i -- %i : current_stack(%i)\n", get, push, p -> stack -> pointer);
 121
 122         va_end(ptr);
 123 }
 124
 125 static void
 126 jvm_generate_push_int(gen_proc_t * p, int64_t i)
 127 {
 128         if(i == -1)
 129         {
 130                 jvm_generate(p, 0, 1, "iconst_m1");
 131         }
 132         else if(i >= 0 && i <= 5)
 133         {
 134                 jvm_generate(p, 0, 1, "iconst_%li", i);
 135         }
 136         else if(i >= -128 && i <= 127)
 137         {
 138                 jvm_generate(p, 0, 1, "bipush %li", i);
 139         }
 140         else if(i >= -32768 && i <= 32767)
 141         {
 142                 jvm_generate(p, 0, 1, "sipush %li", i);
 143         }
 144         else if(i >= -2147483648 && i <= 2147483647)
 145         {
 146                 jvm_generate(p, 0, 1, "ldc %li", i);
 147         }
 148         else
 149         {
 150                 jvm_generate(p, 0, 2, "ldc2 %li", i);
 151         }
 152 }
 153
 154 static void
 155 jvm_generate_push_float(gen_proc_t * p, double f, int size)
 156 {
 157         if(size <= 4)
 158         {
 159                 if(f == 0.0)
 160                 {
 161                         jvm_generate(p, 0, 1, "fconst_0");
 162                 }
 163                 if(f == 1.0)
 164                 {
 165                         jvm_generate(p, 0, 1, "fconst_1");
 166                 }
 167                 if(f == 2.0)
 168                 {
 169                         jvm_generate(p, 0, 1, "fconst_2");
 170                 }
 171                 else
 172                 {
 173                         jvm_generate(p, 0, 1, "ldc %lf", f);
 174                 }
 175         }
 176         else
 177         {
 178                 if(f == 0.0)
 179                 {
 180                         jvm_generate(p, 0, 2, "dconst_0");
 181                 }
 182                 if(f == 1.0)
 183                 {
 184                         jvm_generate(p, 0, 2, "dconst_1");
 185                 }
 186                 else
 187                 {
 188                         jvm_generate(p, 0, 2, "ldc2 %lf", f);
 189                 }
 190         }
 191 }
 192
 193 static gen_var_t *
 194 oberon_generator_new_var()
 195 {
 196         gen_var_t * v = GC_MALLOC(sizeof *v);
 197         memset(v, 0, sizeof *v);
 198         return v;
 199 }
 200
 201 static void
 202 jvm_generate_and_init_global_var(gen_var_t * v, struct gen_class * class, char * access, char * name, char * desc)
 203 {
 204         assert(class -> p == NULL);
 205         fprintf(class -> fp, ".field %s static %s %s\n\n", access, name, desc);
 206
 207         v -> storage = JVM_STORAGE_STATIC;
 208         v -> full_name = new_string("%s/%s", class -> full_name, name);
 209         v -> desc = new_string(desc);
 210 }
 211
 212 static void
 213 jvm_generate_and_init_field(gen_var_t * v, struct gen_class * class, char * access, char * name, char * desc)
 214 {
 215         assert(class -> p == NULL);
 216         fprintf(class -> fp, ".field %s %s %s\n\n", access, name, desc);
 217
 218         v -> storage = JVM_STORAGE_FIELD;
 219         v -> full_name = new_string("%s/%s", class -> full_name, name);
 220         v -> desc = new_string(desc);
 221 }
 222
 223 static void
 224 jvm_generate_and_init_local_var(gen_var_t * v, gen_proc_t * p, bool wide)
 225 {
 226         v -> storage = JVM_STORAGE_REGISTER;
 227         v -> reg = jvm_alloc_register_untyped(p -> rf, wide);
 228 }
 229
 230 static void
 231 jvm_generate_and_init_named_local_var(gen_var_t * v, gen_proc_t * p, bool wide, char * name, char * desc)
 232 {
 233         jvm_generate_and_init_local_var(v, p, wide);
 234         v -> desc = new_string(desc);
 235         jvm_generate(p, 0, 0, ".var %i is %s %s from start to end", v -> reg, name, desc);
 236 }
 237
 238 static int
 239 jvm_new_label_id(gen_proc_t * p)
 240 {
 241         int label_id = p -> label_id;
 242         p -> label_id += 1;
 243         return label_id;
 244 }
 245
 246 static char *
 247 jvm_get_label_name(int label_id)
 248 {
 249         return new_string("L%i", label_id);
 250 }
 251
 252 static void
 253 jvm_generate_label(gen_proc_t * p, int label_id)
 254 {
 255         jvm_generate(p, 0, 0, "L%i:", label_id);
 256 }
 257
 258 static void
 259 jvm_generate_new(gen_proc_t * p, oberon_type_t * type, int num);
 260
 261 /*
 262  * Функция jvm_generate_static_array_initialization генерирует код для
 263  * статической инициализации массива. На входе массив, на выходе тот же массив.
 264  * arrayref -- arrayref
 265  */
 266
 267 static void
 268 jvm_generate_static_array_initialization(gen_proc_t * p, oberon_type_t * type)
 269 {
 270         /* for(int i = 0; i < a.length; i++) */
 271         /*   a[i] := new(base); */
 272         /*   init(a[i]) */
 273
 274         /* a := pop(array) */
 275         gen_var_t * va = oberon_generator_new_var();
 276         jvm_generate_and_init_local_var(va, p, false);
 277         int reg_a = va -> reg;
 278         /* ссылка уже на стеке */
 279         jvm_generate(p, 1, 0, "astore %i", reg_a);
 280
 281         /* int i = 0; */
 282         gen_var_t * vi = oberon_generator_new_var();
 283         jvm_generate_and_init_local_var(vi, p, false);
 284         int reg_i = vi -> reg;
 285         jvm_generate(p, 0, 1, "iconst_0");
 286         jvm_generate(p, 1, 0, "istore %i", reg_i);
 287
 288         /* int l := a.length */
 289         gen_var_t * vl = oberon_generator_new_var();
 290         jvm_generate_and_init_local_var(vl, p, false);
 291         int reg_l = vl -> reg;
 292         jvm_generate(p, 0, 1, "aload %i", reg_a);
 293         jvm_generate(p, 1, 1, "arraylength");
 294         jvm_generate(p, 1, 0, "istore %i", reg_l);
 295
 296         int label_start = jvm_new_label_id(p);
 297         int label_end = jvm_new_label_id(p);
 298
 299         /* start: */
 300         /* if (i >= l) goto end; */
 301         /*   body*/
 302         /*   i += 1;*/
 303         /*   goto start;*/
 304         /* end: */
 305         /* push a */
 306
 307         jvm_generate_label(p, label_start);
 308         jvm_generate(p, 0, 1, "iload %i", reg_i);
 309         jvm_generate(p, 0, 1, "iload %i", reg_l);
 310         jvm_generate(p, 2, 0, "if_icmpge L%i", label_end);
 311
 312         if(type -> base -> class == OBERON_TYPE_ARRAY)
 313         {
 314                 /* Инициализируем следующую размерность */
 315                 jvm_generate(p, 0, 1, "aload %i", reg_a);
 316                 jvm_generate(p, 0, 1, "iload %i", reg_i);
 317                 jvm_generate(p, 0, 1, "aaload");
 318                 jvm_generate_static_array_initialization(p, type -> base);
 319                 jvm_generate(p, 1, 0, "pop");
 320         }
 321         else if(type -> base -> class == OBERON_TYPE_RECORD)
 322         {
 323                 jvm_generate(p, 0, 1, "aload %i", reg_a);
 324                 jvm_generate(p, 0, 1, "iload %i", reg_i);
 325                 jvm_generate_new(p, type -> base, 0);
 326                 jvm_generate(p, 3, 0, "aastore");
 327         }
 328         else
 329         {
 330                 assert(0);
 331         }
 332
 333         /* i += 1; */
 334         /* goto start */
 335
 336         jvm_generate(p, 0, 0, "iinc %i %i", reg_i, 1);
 337         jvm_generate(p, 0, 0, "goto L%i", label_start);
 338         jvm_generate_label(p, label_end);
 339
 340         /* push(a) */
 341         jvm_generate(p, 0, 1, "aload %i", reg_a);
 342
 343         /* TODO освобождение регистров */
 344 }
 345
 346 static void
 347 jvm_generate_new(gen_proc_t * p, oberon_type_t * type, int num)
 348 {
 349         int dim;
 350         char * cname;
 351         char * desc;
 352         oberon_type_t * base;
 353
 354         switch(type -> class)
 355         {
 356                 case OBERON_TYPE_INTEGER:
 357                 case OBERON_TYPE_BOOLEAN:
 358                 case OBERON_TYPE_PROCEDURE:
 359                 case OBERON_TYPE_REAL:
 360                 case OBERON_TYPE_POINTER:
 361                         gen_error("jvm_generate_new_static: static alocation not allowed");
 362                         break;
 363                 case OBERON_TYPE_RECORD:
 364                         cname = jvm_get_class_full_name(type);
 365                         jvm_generate(p, 0, 1, "new %s", cname);
 366                         jvm_generate(p, 1, 2, "dup");
 367                         jvm_generate(p, 1, 0, "invokespecial %s/<init>()V", cname);
 368                         break;
 369                 case OBERON_TYPE_ARRAY:
 370                         dim = 0;
 371                         base = type;
 372                         desc = jvm_get_descriptor(type);
 373                         while(base -> class == OBERON_TYPE_ARRAY)
 374                         {
 375                                 if(num > 0)
 376                                 {
 377                                         assert(base -> size == 0);
 378                                         num -= 1;
 379                                 }
 380                                 else
 381                                 {
 382                                         assert(base -> size > 0);
 383                                         jvm_generate_push_int(p, base -> size);
 384                                 }
 385                                 dim += 1;
 386                                 base = base -> base;
 387                         }
 388
 389                         assert(num == 0);
 390                         jvm_generate(p, dim, 1, "multianewarray %s %i", desc, dim);
 391
 392                         if(base -> class == OBERON_TYPE_RECORD)
 393                         {
 394                                 jvm_generate_static_array_initialization(p, type);
 395                         }
 396                         break;
 397                 default:
 398                         gen_error("jvm_generate_new_static: unk type class %i", type -> class);
 399                         break;
 400         }
 401 }
 402
 403 static void
 404 jvm_generate_store(gen_proc_t * p, oberon_type_t * src_type, gen_var_t * dst)
 405 {
 406         char prefix;
 407         int cell_size;
 408
 409         cell_size = jvm_cell_size_for_type(src_type);
 410
 411         switch(dst -> storage)
 412         {
 413                 case JVM_STORAGE_REGISTER:
 414                         prefix = jvm_get_prefix(src_type);
 415                         jvm_generate(p, cell_size, 0, "%cstore %i", prefix, dst -> reg);
 416                         break;
 417                 case JVM_STORAGE_STATIC:
 418                         jvm_generate(p, cell_size, 0, "putstatic %s %s", dst -> full_name, dst -> desc);
 419                         break;
 420                 case JVM_STORAGE_FIELD:
 421                         jvm_generate(p, 1 + cell_size, 0, "putfield %s %s", dst -> full_name, dst -> desc);
 422                         break;
 423                 default:
 424                         gen_error("jvm_generate_store: unknow storage type %i", dst -> storage);
 425                         break;
 426         }
 427 }
 428
 429 // ==========================================
 430 // ==========================================
 431 // ==========================================
 432
 433 void
 434 oberon_generator_init_context(oberon_context_t * ctx)
 435 {
 436         gen_context_t * gen_context = GC_MALLOC(sizeof *gen_context);
 437         memset(gen_context, 0, sizeof *gen_context);
 438
 439         ctx -> gen_context = gen_context;
 440 }
 441
 442 void
 443 oberon_generator_destroy_context(oberon_context_t * ctx)
 444 {
 445 }
 446
 447 static void
 448 oberon_generate_procedure_class(oberon_type_t * proc)
 449 {
 450         FILE * fp;
 451         char * cname;
 452         char * signature;
 453         struct gen_class * class;
 454
 455         cname = jvm_get_class_full_name(proc);
 456         class = jvm_create_class(cname);
 457         fp = class -> fp;
 458
 459         fprintf(fp, ".source SYSTEM\n");
 460         fprintf(fp, ".class  public abstract %s\n", cname);
 461         fprintf(fp, ".super  java/lang/Object\n\n");
 462
 463         fprintf(fp, ".method public <init>()V\n");
 464         fprintf(fp, "  aload_0\n");
 465         fprintf(fp, "  invokespecial java/lang/Object/<init>()V\n");
 466         fprintf(fp, "  return\n");
 467         fprintf(fp, ".end method\n\n");
 468
 469         signature = jvm_get_procedure_signature(proc);
 470
 471         fprintf(fp, ".method public abstract invoke%s\n", signature);
 472         fprintf(fp, ".end method\n\n");
 473
 474         jvm_destroy_class(class);
 475 }
 476
 477 static void
 478 oberon_generate_record_class(gen_module_t * m, oberon_type_t * rec)
 479 {
 480         char * cname;
 481         struct gen_class * class;
 482
 483         /* Устанавливаем новоый id */
 484         rec -> gen_type -> rec_id = m -> rec_id;
 485         m -> rec_id += 1;
 486
 487         cname = jvm_get_class_full_name(rec);
 488         class = jvm_create_class(cname);
 489
 490         fprintf(class -> fp, ".source %s\n", rec -> module -> name);
 491         fprintf(class -> fp, ".class  public %s\n", cname);
 492         fprintf(class -> fp, ".super  java/lang/Object\n\n");
 493
 494         rec -> gen_type -> class = class;
 495 }
 496
 497 void
 498 oberon_generator_init_type(oberon_context_t * ctx, oberon_type_t * type)
 499 {
 500         gen_type_t * t = GC_MALLOC(sizeof *t);
 501         memset(t, 0, sizeof *t);
 502         type -> gen_type = t;
 503
 504         switch(type -> class)
 505         {
 506                 case OBERON_TYPE_VOID:
 507                 case OBERON_TYPE_INTEGER:
 508                 case OBERON_TYPE_BOOLEAN:
 509                 case OBERON_TYPE_ARRAY:
 510                 case OBERON_TYPE_REAL:
 511                         break;
 512                 case OBERON_TYPE_RECORD:
 513                         ;
 514                         gen_module_t * m;
 515                         m = type -> module -> gen_mod;
 516                         oberon_generate_record_class(m, type);
 517                         break;
 518                 case OBERON_TYPE_PROCEDURE:
 519                         oberon_generate_procedure_class(type);
 520                         break;
 521                 case OBERON_TYPE_POINTER:
 522                         break;
 523                 default:
 524                         gen_error("oberon_generator_init_type: unk calss %i", type -> class);
 525                         break;
 526         }
 527 }
 528
 529 void
 530 oberon_generator_init_record(oberon_context_t * ctx, oberon_type_t * rec)
 531 {
 532         struct gen_class * class;
 533         class = rec -> gen_type -> class;
 534
 535         int num = rec -> num_decl;
 536         oberon_object_t * field = rec -> decl;
 537         for(int i = 0; i < num; i++)
 538         {
 539                 gen_var_t * v = field -> gen_var;
 540                 char * name = field -> name;
 541                 char * desc = jvm_get_descriptor(field -> type);
 542                 jvm_generate_and_init_field(v, class, "public", name, desc);
 543                 field = field -> next;
 544         }
 545
 546         gen_proc_t * p = jvm_create_proc(class);
 547
 548         jvm_generate_function_header(p, "public", "<init>", "()V");
 549         jvm_alloc_register_untyped(p -> rf, false);
 550         jvm_generate(p, 0, 1, "aload_0");
 551         jvm_generate(p, 1, 0, "invokespecial java/lang/Object/<init>()V");
 552
 553         num = rec -> num_decl;
 554         field = rec -> decl;
 555         for(int i = 0; i < num; i++)
 556         {
 557                 if(field -> type -> class == OBERON_TYPE_RECORD
 558                         || field -> type -> class == OBERON_TYPE_ARRAY)
 559                 {
 560                         jvm_generate(p, 0, 1, "aload_0");
 561                         jvm_generate_new(p, field -> type, 0);
 562                         jvm_generate_store(p, field -> type, field -> gen_var);
 563                 }
 564                 field = field -> next;
 565         }
 566
 567         jvm_generate(p, 0, 0, "return");
 568         jvm_generate_function_end(p);
 569
 570         jvm_destroy_class(class);
 571 }
 572
 573 void
 574 oberon_generator_init_var(oberon_context_t * ctx, oberon_object_t * var)
 575 {
 576         gen_var_t * v = oberon_generator_new_var();
 577         var -> gen_var = v;
 578
 579         gen_module_t * m;
 580         m = ctx -> mod -> gen_mod;
 581
 582         struct gen_class * class;
 583         class = m -> class;
 584
 585         char * desc;
 586         switch(var -> class)
 587         {
 588                 case OBERON_CLASS_VAR_PARAM:
 589                         gen_error("generator: VAR-parameters not implemented");
 590                         break;
 591                 case OBERON_CLASS_PARAM:
 592                         /* Заполняется при генерации функции */
 593                         /* смотри jvm_init_local_object() */
 594                         break;
 595                 case OBERON_CLASS_FIELD:
 596                         /* Заполняются при инициализации структуры */
 597                         /* смотри oberon_generator_init_record() */
 598                         break;
 599                 case OBERON_CLASS_VAR:
 600                         /* Локальные заполняются при генерации функции */
 601                         /* смотри jvm_init_local_object() */
 602                         if(var -> local == 0)
 603                         {
 604                                 desc = jvm_get_descriptor(var -> type);
 605                                 jvm_generate_and_init_global_var(v, class, "public", var -> name, desc);
 606                         }
 607                         break;
 608                 default:
 609                         gen_error("oberon_generator_init_var: unk var class %i", var -> class);
 610                         break;
 611         }
 612 }
 613
 614 void
 615 oberon_generator_init_proc(oberon_context_t * ctx, oberon_object_t * proc)
 616 {
 617         struct gen_class * class = proc -> module -> gen_mod -> class;
 618         proc -> gen_proc = jvm_create_proc(class);
 619
 620         if(proc -> local)
 621         {
 622                 gen_error("generator: local procedures not implemented");
 623         }
 624 }
 625
 626 void
 627 oberon_generator_init_module(oberon_context_t * ctx, oberon_module_t * mod)
 628 {
 629         gen_module_t * m = GC_MALLOC(sizeof *m);
 630         memset(m, 0, sizeof *m);
 631         mod -> gen_mod = m;
 632
 633         struct gen_class * class;
 634         class = jvm_create_class(mod -> name);
 635
 636         fprintf(class -> fp, ".source %s\n", mod -> name);
 637         fprintf(class -> fp, ".class %s\n", mod -> name);
 638         fprintf(class -> fp, ".super java/lang/Object\n\n");
 639
 640         m -> class = class;
 641
 642         ctx -> gen_context -> current_m = m;
 643 }
 644
 645 void
 646 oberon_generator_fini_module(oberon_module_t * mod)
 647 {
 648         jvm_destroy_class(mod -> gen_mod -> class);
 649 }
 650
 651 static void
 652 push_expr(gen_proc_t * p, oberon_expr_t * expr);
 653
 654 void
 655 oberon_generate_begin_module(oberon_context_t * ctx)
 656 {
 657         struct gen_class * class = ctx -> mod -> gen_mod -> class;
 658         gen_proc_t * p = jvm_create_proc(class);
 659
 660         jvm_generate_function_header(p, "public", "<init>", "()V");
 661         jvm_alloc_register_untyped(p -> rf, false);
 662         jvm_generate(p, 0, 1, "aload_0");
 663         jvm_generate(p, 1, 0, "invokespecial java/lang/Object/<init>()V");
 664
 665         /* Инициализация переменных объявленных в модуле */
 666         oberon_object_t * x = ctx -> mod -> decl -> list -> next;
 667         while(x != NULL)
 668         {
 669                 if(x -> class == OBERON_CLASS_VAR)
 670                 {
 671                         if(x -> type -> class == OBERON_TYPE_ARRAY
 672                                 || x -> type -> class == OBERON_TYPE_RECORD)
 673                         {
 674                                 jvm_generate_new(p, x -> type, 0);
 675                                 jvm_generate_store(p, x -> type, x -> gen_var);
 676                         }
 677                 }
 678                 x = x -> next;
 679         }
 680 }
 681
 682 void
 683 oberon_generate_end_module(oberon_context_t * ctx)
 684 {
 685         struct gen_class * class = ctx -> mod -> gen_mod -> class;
 686         gen_proc_t * p = class -> p;
 687
 688         jvm_generate(p, 0, 0, "return");
 689         jvm_generate_function_end(class -> p);
 690 }
 691
 692 static void
 693 jvm_init_local_object(gen_proc_t * p, oberon_object_t * x)
 694 {
 695         gen_var_t * v;
 696         bool wide;
 697         char * desc;
 698         struct gen_class * class;
 699
 700         v = x -> gen_var;
 701         class = p -> class;
 702         wide = jvm_is_wide_type(x -> type);
 703         desc = jvm_get_descriptor(x -> type);
 704
 705         // Убеждаемся что сейчас находимся в функции
 706         assert(class -> p);
 707         assert(x -> local);
 708
 709         switch(x -> class)
 710         {
 711                 case OBERON_CLASS_VAR:
 712                 case OBERON_CLASS_PARAM:
 713                         jvm_generate_and_init_named_local_var(v, p, wide, x -> name, desc);
 714                         break;
 715                 default:
 716                         gen_error("jvm_init_local_object: wat");
 717                         break;
 718         }
 719 }
 720
 721 void
 722 oberon_generate_begin_proc(oberon_context_t * ctx, oberon_object_t * proc)
 723 {
 724         gen_proc_t * p;
 725         char * signature;
 726
 727         p = proc -> gen_proc;
 728
 729         signature = jvm_get_procedure_signature(proc -> type);
 730
 731         jvm_generate_function_header(p, "public static", proc -> name, signature);
 732
 733         oberon_object_t * var = proc -> type -> decl;
 734         while(var)
 735         {
 736                 jvm_init_local_object(p, var);
 737                 var = var -> next;
 738         }
 739 }
 740
 741 void
 742 oberon_generate_end_proc(oberon_context_t * ctx)
 743 {
 744         gen_module_t * m;
 745         gen_proc_t * p;
 746
 747         m = ctx -> mod -> gen_mod;
 748         p = m -> class -> p;
 749
 750         jvm_generate_function_end(p);
 751 }
 752
 753 static void
 754 jvm_generate_call_proc(gen_proc_t * p, oberon_expr_t * desig)
 755 {
 756         assert(desig -> is_item);
 757         assert(desig -> item.mode == MODE_CALL);
 758
 759         oberon_object_t * proc;
 760         char * fullname;
 761         char * signature;
 762
 763         proc = desig -> item.var;
 764         fullname = jvm_get_field_full_name(proc);
 765         signature = jvm_get_procedure_signature(proc -> type);
 766
 767         int args_cells = 0;
 768         int result_cells = jvm_cell_size_for_type(proc -> type -> base);
 769
 770         int num = desig -> item.num_args;
 771         oberon_expr_t * arg = desig -> item.args;
 772         for(int i = 0; i < num; i++)
 773         {
 774                 args_cells += jvm_cell_size_for_type(arg -> result);
 775                 push_expr(p, arg);
 776                 arg = arg -> next;
 777         }
 778
 779         jvm_generate(p, args_cells, result_cells, "invokestatic %s%s", fullname, signature);
 780 }
 781
 782 void
 783 oberon_generate_call_proc(oberon_context_t * ctx, oberon_expr_t * desig)
 784 {
 785         jvm_generate_call_proc(ctx -> gen_context -> current_m -> class -> p, desig);
 786 }
 787
 788 void
 789 oberon_generate_return(oberon_context_t * ctx, oberon_expr_t * expr)
 790 {
 791         gen_module_t * m;
 792         gen_proc_t * p;
 793         char prefix;
 794         int cell_size;
 795
 796         m = ctx -> mod -> gen_mod;
 797         p = m -> class -> p;
 798
 799         if(expr)
 800         {
 801                 push_expr(p, expr);
 802                 prefix = jvm_get_prefix(expr -> result);
 803                 cell_size = jvm_cell_size_for_type(expr -> result);
 804                 jvm_generate(p, cell_size, 0, "%creturn", prefix);
 805         }
 806         else
 807         {
 808                 jvm_generate(p, 0, 0, "return");
 809         }
 810 }
 811
 812 static void
 813 jvm_push_var(gen_proc_t * p, oberon_object_t * var)
 814 {
 815         int cell_size = jvm_cell_size_for_type(var -> type);
 816
 817         if(var -> local)
 818         {
 819                 int reg = var -> gen_var -> reg;
 820                 char prefix = jvm_get_prefix(var -> type);
 821                 jvm_generate(p, 0, cell_size, "%cload %i", prefix, reg);
 822         }
 823         else
 824         {
 825                 char * fullname = jvm_get_field_full_name(var);
 826                 char * desc = jvm_get_descriptor(var -> type);
 827                 jvm_generate(p, 0, cell_size, "getstatic %s %s", fullname, desc);
 828         }
 829 }
 830
 831 static void
 832 jvm_generate_expr_new_pointer(gen_proc_t * p, oberon_type_t * type, int num, oberon_expr_t * arg)
 833 {
 834         assert(type -> class == OBERON_TYPE_POINTER);
 835
 836         for(int i = 0; i < num; i++)
 837         {
 838                 push_expr(p, arg);
 839                 arg = arg -> next;
 840         }
 841
 842         jvm_generate_new(p, type -> base, num);
 843 }
 844
 845 static void
 846 push_item(gen_proc_t * p, oberon_item_t * item)
 847 {
 848         switch(item -> mode)
 849         {
 850                 case MODE_VAR:
 851                         jvm_push_var(p, item -> var);
 852                         break;
 853                 case MODE_INTEGER:
 854                         jvm_generate_push_int(p, item -> integer);
 855                         break;
 856                 case MODE_BOOLEAN:
 857                         jvm_generate_push_int(p, item -> boolean);
 858                         break;
 859                 case MODE_CALL:
 860                         jvm_generate_call_proc(p, (oberon_expr_t *) item);
 861                         break;
 862                 case MODE_INDEX:
 863                         ;
 864                         char postfix = jvm_get_postfix(item -> result);
 865                         int cell_size = jvm_cell_size_for_postfix(postfix);
 866                         push_item(p, item -> parent);
 867                         push_expr(p, item -> args);
 868                         jvm_generate(p, 1 + 1, cell_size, "%caload", postfix);
 869                         break;
 870                 case MODE_FIELD:
 871                         push_item(p, item -> parent);
 872                         char * field = jvm_get_field_full_name(item -> var);
 873                         char * desc = jvm_get_descriptor(item -> var -> type);
 874                         jvm_generate(p, 1, 1, "getfield %s %s", field, desc);
 875                         break;
 876                 case MODE_DEREF:
 877                         /* Все объекты представляются как увказатели */
 878                         push_item(p, item -> parent);
 879                         break;
 880                 case MODE_NIL:
 881                         jvm_generate(p, 0, 1, "aconst_null");
 882                         break;
 883                 case MODE_NEW:
 884                         jvm_generate_expr_new_pointer(p, item -> result, item -> num_args, item -> args);
 885                         break;
 886                 case MODE_REAL:
 887                         jvm_generate_push_float(p, item -> real, item -> result -> size);
 888                         break;
 889                 default:
 890                         gen_error("push_item: unk mode %i", item -> mode);
 891                         break;
 892         }
 893 }
 894
 895 static void
 896 jvm_generate_logical_not(gen_proc_t * p)
 897 {
 898         int label_done = jvm_new_label_id(p);
 899         int label_false = jvm_new_label_id(p);
 900         char * label_name_done = jvm_get_label_name(label_done);
 901         char * label_name_false = jvm_get_label_name(label_false);
 902
 903         jvm_generate(p, 1, 0, "ifne %s", label_name_false);
 904         jvm_generate(p, 0, 1, "iconst_1");
 905         jvm_generate(p, 0, 0, "goto %s", label_name_done);
 906         jvm_generate_label(p, label_false);
 907         jvm_generate(p, 0, 1, "iconst_0");
 908         jvm_generate_label(p, label_done);
 909 }
 910
 911 static void
 912 jvm_generate_abs(gen_proc_t * p, char prefix)
 913 {
 914         char t = jvm_get_type_of_prefix(prefix);
 915         int cell_size = jvm_cell_size_for_postfix(prefix);
 916         jvm_generate(p, cell_size, cell_size, "invokestatic java/lang/Math/abs(%c)%c", t, t);
 917 }
 918
 919 static void
 920 jvm_generate_compare_op(gen_proc_t * p, char prefix, int op)
 921 {
 922         int label_true = jvm_new_label_id(p);
 923         int label_done = jvm_new_label_id(p);
 924         char * label_name_true = jvm_get_label_name(label_true);
 925         char * label_name_done = jvm_get_label_name(label_done);
 926         int cell_size = 2 * jvm_cell_size_for_postfix(prefix);
 927
 928         assert(prefix == 'i' || prefix == 'a');
 929
 930         const char * cmpop = "";
 931         switch(op)
 932         {
 933                 case OP_EQ:
 934                         cmpop = "eq";
 935                         break;
 936                 case OP_NEQ:
 937                         cmpop = "ne";
 938                         break;
 939                 case OP_LSS:
 940                         cmpop = "lt";
 941                         break;
 942                 case OP_LEQ:
 943                         cmpop = "le";
 944                         break;
 945                 case OP_GRT:
 946                         cmpop = "gt";
 947                         break;
 948                 case OP_GEQ:
 949                         cmpop = "ge";
 950                         break;
 951                 default:
 952                         gen_error("jvm_generate_compare_op: wat");
 953                         break;
 954         }
 955
 956         jvm_generate(p, cell_size, 0, "if_%ccmp%s %s", prefix, cmpop, label_name_true);
 957         jvm_generate(p, 0, 1, "iconst_0");
 958         jvm_generate(p, 0, 0, "goto %s", label_name_done);
 959         jvm_generate_label(p, label_true);
 960         jvm_generate(p, 0, 1, "iconst_1");
 961         jvm_generate_label(p, label_done);
 962 }
 963
 964 static void
 965 jvm_generate_operator(gen_proc_t * p, char prefix, int op)
 966 {
 967         int cell_size = jvm_cell_size_for_postfix(prefix);
 968         switch(op)
 969         {
 970                 case OP_UNARY_MINUS:
 971                         jvm_generate(p, cell_size, cell_size, "%cneg", prefix);
 972                         break;
 973                 case OP_BITWISE_NOT:
 974                         jvm_generate_push_int(p, -1);
 975                         jvm_generate(p, 2 * cell_size, cell_size, "%cxor", prefix);
 976                         break;
 977                 case OP_LOGIC_NOT:
 978                         jvm_generate_logical_not(p);
 979                         break;
 980                 case OP_ABS:
 981                         jvm_generate_abs(p, prefix);
 982                         break;
 983
 984                 case OP_ADD:
 985                         jvm_generate(p, 2 * cell_size, cell_size, "%cadd", prefix);
 986                         break;
 987                 case OP_SUB:
 988                         jvm_generate(p, 2 * cell_size, cell_size, "%csub", prefix);
 989                         break;
 990                 case OP_MUL:
 991                         jvm_generate(p, 2 * cell_size, cell_size, "%cmul", prefix);
 992                         break;
 993                 case OP_DIV:
 994                         jvm_generate(p, 2 * cell_size, cell_size, "%cdiv", prefix);
 995                         break;
 996                 case OP_MOD:
 997                         jvm_generate(p, 2 * cell_size, cell_size, "%crem", prefix);
 998                         break;
 999                 case OP_BITWISE_AND:
1000                         jvm_generate(p, 2 * cell_size, cell_size, "%cand", prefix);
1001                         break;
1002                 case OP_BITWISE_XOR:
1003                         jvm_generate(p, 2 * cell_size, cell_size, "%cxor", prefix);
1004                         break;
1005                 case OP_BITWISE_OR:
1006                         jvm_generate(p, 2 * cell_size, cell_size, "%cor", prefix);
1007                         break;
1008
1009                 case OP_EQ:
1010                 case OP_NEQ:
1011                 case OP_LSS:
1012                 case OP_LEQ:
1013                 case OP_GRT:
1014                 case OP_GEQ:
1015                         jvm_generate_compare_op(p, prefix, op);
1016                         break;
1017                 default:
1018                         gen_error("jvm_generate_operator: unk op %i", op);
1019                         break;
1020         }
1021 }
1022
1023 static void
1024 jvm_generate_logical_or(gen_proc_t * p, oberon_expr_t * a, oberon_expr_t * b)
1025 {
1026         int label_calc_b = jvm_new_label_id(p);
1027         int label_done = jvm_new_label_id(p);
1028         char * label_name_calc_b = jvm_get_label_name(label_calc_b);
1029         char * label_name_done = jvm_get_label_name(label_done);
1030
1031         /* a OR b -- если a, то TRUE, иначе b */
1032
1033         push_expr(p, a);
1034         jvm_generate(p, 1, 0, "ifne %s", label_name_calc_b);
1035         jvm_generate(p, 0, 1, "iconst_1");
1036         jvm_generate(p, 0, 0, "goto %s", label_name_done);
1037         jvm_generate_label(p, label_calc_b);
1038         push_expr(p, b);
1039         jvm_generate_label(p, label_done);
1040 }
1041
1042 static void
1043 jvm_generate_logical_and(gen_proc_t * p, oberon_expr_t * a, oberon_expr_t * b)
1044 {
1045         int label_false = jvm_new_label_id(p);
1046         int label_done = jvm_new_label_id(p);
1047         char * label_name_false = jvm_get_label_name(label_false);
1048         char * label_name_done = jvm_get_label_name(label_done);
1049
1050         /* a AND b -- если a, то b, иначе FALSE */
1051
1052         push_expr(p, a);
1053         jvm_generate(p, 1, 0, "ifne %s", label_name_false);
1054         push_expr(p, b);
1055         jvm_generate(p, 0, 0, "goto %s", label_name_done);
1056         jvm_generate_label(p, label_false);
1057         jvm_generate(p, 0, 1, "iconst_0");
1058         jvm_generate_label(p, label_done);
1059 }
1060
1061 static void
1062 push_operator(gen_proc_t * p, oberon_oper_t * oper)
1063 {
1064         char prefix = jvm_get_prefix(oper -> result);
1065         int op = oper -> op;
1066         switch(op)
1067         {
1068                 case OP_UNARY_MINUS:
1069                 case OP_BITWISE_NOT:
1070                 case OP_LOGIC_NOT:
1071                 case OP_ABS:
1072                         push_expr(p, oper -> left);
1073                         jvm_generate_operator(p, prefix, op);
1074                         break;
1075
1076                 case OP_ADD:
1077                 case OP_SUB:
1078                 case OP_MUL:
1079                 case OP_DIV:
1080                 case OP_MOD:
1081                 case OP_BITWISE_AND:
1082                 case OP_BITWISE_XOR:
1083                 case OP_BITWISE_OR:
1084
1085                 case OP_EQ:
1086                 case OP_NEQ:
1087                 case OP_LSS:
1088                 case OP_LEQ:
1089                 case OP_GRT:
1090                 case OP_GEQ:
1091                         push_expr(p, oper -> left);
1092                         push_expr(p, oper -> right);
1093                         jvm_generate_operator(p, prefix, op);
1094                         break;
1095
1096                 case OP_LOGIC_OR:
1097                         jvm_generate_logical_or(p, oper -> left, oper -> right);
1098                         break;
1099                 case OP_LOGIC_AND:
1100                         jvm_generate_logical_and(p, oper -> left, oper -> right);
1101                         break;
1102                 default:
1103                         gen_error("push_oper: unk op %i", op);
1104                         break;
1105         }
1106 }
1107
1108 static void
1109 push_expr(gen_proc_t * p, oberon_expr_t * expr)
1110 {
1111         if(expr -> is_item)
1112         {
1113                 push_item(p, (oberon_item_t *) expr);
1114         }
1115         else
1116         {
1117                 push_operator(p, (oberon_oper_t *) expr);
1118         }
1119 }
1120
1121 static void
1122 store_expr(gen_proc_t * p, oberon_expr_t * dst, oberon_expr_t * src)
1123 {
1124         assert(dst -> is_item);
1125         oberon_item_t * item = (oberon_item_t *) dst;
1126
1127         if(dst -> result -> class == OBERON_TYPE_ARRAY
1128                 || src -> result -> class == OBERON_TYPE_ARRAY)
1129         {
1130                 gen_error("array copy not implemented");
1131         }
1132         else if(dst -> result -> class == OBERON_TYPE_RECORD
1133                 || src -> result -> class == OBERON_TYPE_RECORD)
1134         {
1135                 gen_error("record copy not implemented");
1136         }
1137
1138         switch(item -> mode)
1139         {
1140                 case MODE_VAR:
1141                         push_expr(p, src);
1142                         jvm_generate_store(p, src -> result, item -> var -> gen_var);
1143                         break;
1144                 case MODE_INDEX:
1145                         ;
1146                         char postfix = jvm_get_postfix(src -> result);
1147                         int cell_size = jvm_cell_size_for_postfix(postfix);
1148                         push_item(p, item -> parent);
1149                         push_expr(p, item -> args);
1150                         push_expr(p, src);
1151                         jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix);
1152                         break;
1153                 case MODE_FIELD:
1154                         push_item(p, item -> parent);
1155                         push_expr(p, src);
1156                         jvm_generate_store(p, src -> result, item -> var -> gen_var);
1157                         break;
1158                 default:
1159                         gen_error("store_expr: unk mode %i", item -> mode);
1160                         break;
1161         }
1162 }
1163
1164 void
1165 oberon_generate_assign(oberon_context_t * ctx, oberon_expr_t * src, oberon_expr_t * dst)
1166 {
1167         gen_module_t * m;
1168         gen_proc_t * p;
1169
1170         m = ctx -> mod -> gen_mod;
1171         p = m -> class -> p;
1172
1173         store_expr(p, dst, src);
1174 }
1175
1176 void
1177 oberon_generate_code(oberon_context_t * ctx)
1178 {
1179         printf("generate code\n");
1180 }
1181
1182 void
1183 oberon_generator_dump(oberon_context_t * ctx, char * path)
1184 {
1185         printf("jit: dump code\n");
1186 }
1187
1188 void *
1189 oberon_generator_get_procedure(oberon_context_t * ctx, const char * name)
1190 {
1191         printf("jit: get pointer to procedure %s\n", name);
1192         return NULL;
1193 }
1194
1195 void *
1196 oberon_generator_get_var(oberon_context_t * ctx, const char * name)
1197 {
1198         printf("jit: get pointer to var %s\n", name);
1199         return NULL;
1200 }