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