home *** CD-ROM | disk | FTP | other *** search
/ Tutto per Internet / Internet.iso / soft95 / Java / espints / espinst.exe / classes / espresso / Gen.class (.txt) < prev    next >
Encoding:
Java Class File  |  1996-02-28  |  10.3 KB  |  667 lines
  1. package espresso;
  2.  
  3. class Gen implements Constants {
  4.    private static int[] stackdiff = new int[210];
  5.    private static Pool pool = new Pool();
  6.    private static int statPos;
  7.    private static int stacksize;
  8.    private static boolean fixedPc;
  9.    static boolean alive;
  10.    static Code code;
  11.    static int dontgoto = 168;
  12.  
  13.    static {
  14.       stackdiff[0] = 0;
  15.       stackdiff[1] = 1;
  16.       stackdiff[2] = 1;
  17.       stackdiff[3] = 1;
  18.       stackdiff[4] = 1;
  19.       stackdiff[5] = 1;
  20.       stackdiff[6] = 1;
  21.       stackdiff[7] = 1;
  22.       stackdiff[8] = 1;
  23.       stackdiff[9] = 2;
  24.       stackdiff[10] = 2;
  25.       stackdiff[11] = 1;
  26.       stackdiff[12] = 1;
  27.       stackdiff[13] = 1;
  28.       stackdiff[14] = 2;
  29.       stackdiff[15] = 2;
  30.       stackdiff[16] = 1;
  31.       stackdiff[17] = 1;
  32.       stackdiff[18] = 1;
  33.       stackdiff[19] = 1;
  34.       stackdiff[20] = 2;
  35.       stackdiff[21] = 1;
  36.       stackdiff[22] = 2;
  37.       stackdiff[23] = 1;
  38.       stackdiff[24] = 2;
  39.       stackdiff[25] = 1;
  40.       stackdiff[26] = 1;
  41.       stackdiff[30] = 2;
  42.       stackdiff[34] = 1;
  43.       stackdiff[38] = 2;
  44.       stackdiff[42] = 1;
  45.       stackdiff[27] = 1;
  46.       stackdiff[31] = 2;
  47.       stackdiff[35] = 1;
  48.       stackdiff[39] = 2;
  49.       stackdiff[43] = 1;
  50.       stackdiff[28] = 1;
  51.       stackdiff[32] = 2;
  52.       stackdiff[36] = 1;
  53.       stackdiff[40] = 2;
  54.       stackdiff[44] = 1;
  55.       stackdiff[29] = 1;
  56.       stackdiff[33] = 2;
  57.       stackdiff[37] = 1;
  58.       stackdiff[41] = 2;
  59.       stackdiff[45] = 1;
  60.       stackdiff[46] = -1;
  61.       stackdiff[47] = 0;
  62.       stackdiff[48] = -1;
  63.       stackdiff[49] = 0;
  64.       stackdiff[50] = -1;
  65.       stackdiff[51] = -1;
  66.       stackdiff[52] = -1;
  67.       stackdiff[53] = -1;
  68.       stackdiff[54] = -1;
  69.       stackdiff[55] = -2;
  70.       stackdiff[56] = -1;
  71.       stackdiff[57] = -2;
  72.       stackdiff[58] = -1;
  73.       stackdiff[59] = -1;
  74.       stackdiff[63] = -2;
  75.       stackdiff[67] = -1;
  76.       stackdiff[71] = -2;
  77.       stackdiff[75] = -1;
  78.       stackdiff[60] = -1;
  79.       stackdiff[64] = -2;
  80.       stackdiff[68] = -1;
  81.       stackdiff[72] = -2;
  82.       stackdiff[76] = -1;
  83.       stackdiff[61] = -1;
  84.       stackdiff[65] = -2;
  85.       stackdiff[69] = -1;
  86.       stackdiff[73] = -2;
  87.       stackdiff[77] = -1;
  88.       stackdiff[62] = -1;
  89.       stackdiff[66] = -2;
  90.       stackdiff[70] = -1;
  91.       stackdiff[74] = -2;
  92.       stackdiff[78] = -1;
  93.       stackdiff[79] = -3;
  94.       stackdiff[80] = -4;
  95.       stackdiff[81] = -3;
  96.       stackdiff[82] = -4;
  97.       stackdiff[83] = -3;
  98.       stackdiff[84] = -3;
  99.       stackdiff[85] = -3;
  100.       stackdiff[86] = -3;
  101.       stackdiff[87] = -1;
  102.       stackdiff[88] = -2;
  103.       stackdiff[89] = 1;
  104.       stackdiff[90] = 1;
  105.       stackdiff[91] = 1;
  106.       stackdiff[92] = 2;
  107.       stackdiff[93] = 2;
  108.       stackdiff[94] = 2;
  109.       stackdiff[95] = 0;
  110.       stackdiff[96] = -1;
  111.       stackdiff[97] = -2;
  112.       stackdiff[98] = -1;
  113.       stackdiff[99] = -2;
  114.       stackdiff[100] = -1;
  115.       stackdiff[101] = -2;
  116.       stackdiff[102] = -1;
  117.       stackdiff[103] = -2;
  118.       stackdiff[104] = -1;
  119.       stackdiff[105] = -2;
  120.       stackdiff[106] = -1;
  121.       stackdiff[107] = -2;
  122.       stackdiff[108] = -1;
  123.       stackdiff[109] = -2;
  124.       stackdiff[110] = -1;
  125.       stackdiff[111] = -2;
  126.       stackdiff[112] = -1;
  127.       stackdiff[113] = -2;
  128.       stackdiff[114] = -1;
  129.       stackdiff[115] = -2;
  130.       stackdiff[116] = 0;
  131.       stackdiff[117] = 0;
  132.       stackdiff[118] = 0;
  133.       stackdiff[119] = 0;
  134.       stackdiff[120] = -1;
  135.       stackdiff[121] = -1;
  136.       stackdiff[122] = -1;
  137.       stackdiff[123] = -1;
  138.       stackdiff[124] = -1;
  139.       stackdiff[125] = -1;
  140.       stackdiff[126] = -1;
  141.       stackdiff[127] = -2;
  142.       stackdiff[128] = -1;
  143.       stackdiff[129] = -2;
  144.       stackdiff[130] = -1;
  145.       stackdiff[131] = -2;
  146.       stackdiff[132] = 0;
  147.       stackdiff[133] = 1;
  148.       stackdiff[134] = 0;
  149.       stackdiff[135] = 1;
  150.       stackdiff[136] = -1;
  151.       stackdiff[137] = -1;
  152.       stackdiff[138] = 0;
  153.       stackdiff[139] = 0;
  154.       stackdiff[140] = 1;
  155.       stackdiff[141] = 1;
  156.       stackdiff[142] = -1;
  157.       stackdiff[143] = 0;
  158.       stackdiff[144] = -1;
  159.       stackdiff[145] = 0;
  160.       stackdiff[146] = 0;
  161.       stackdiff[147] = 0;
  162.       stackdiff[148] = -3;
  163.       stackdiff[149] = -1;
  164.       stackdiff[150] = -1;
  165.       stackdiff[151] = -3;
  166.       stackdiff[152] = -3;
  167.       stackdiff[153] = -1;
  168.       stackdiff[154] = -1;
  169.       stackdiff[155] = -1;
  170.       stackdiff[156] = -1;
  171.       stackdiff[157] = -1;
  172.       stackdiff[158] = -1;
  173.       stackdiff[159] = -2;
  174.       stackdiff[160] = -2;
  175.       stackdiff[161] = -2;
  176.       stackdiff[162] = -2;
  177.       stackdiff[163] = -2;
  178.       stackdiff[164] = -2;
  179.       stackdiff[165] = -2;
  180.       stackdiff[166] = -2;
  181.       stackdiff[167] = 0;
  182.       stackdiff[168] = 0;
  183.       stackdiff[169] = 0;
  184.       stackdiff[170] = -1;
  185.       stackdiff[171] = -1;
  186.       stackdiff[172] = -1001;
  187.       stackdiff[173] = -1002;
  188.       stackdiff[174] = -1001;
  189.       stackdiff[175] = -1002;
  190.       stackdiff[176] = -1001;
  191.       stackdiff[177] = -1000;
  192.       stackdiff[178] = -999;
  193.       stackdiff[179] = -999;
  194.       stackdiff[180] = -999;
  195.       stackdiff[181] = -999;
  196.       stackdiff[182] = -999;
  197.       stackdiff[183] = -999;
  198.       stackdiff[184] = -999;
  199.       stackdiff[185] = -999;
  200.       stackdiff[186] = 0;
  201.       stackdiff[187] = 1;
  202.       stackdiff[188] = 0;
  203.       stackdiff[189] = 0;
  204.       stackdiff[190] = 0;
  205.       stackdiff[191] = -1001;
  206.       stackdiff[192] = 0;
  207.       stackdiff[193] = 0;
  208.       stackdiff[194] = -1;
  209.       stackdiff[195] = -1;
  210.       stackdiff[196] = 0;
  211.       stackdiff[197] = -999;
  212.       stackdiff[198] = -1;
  213.       stackdiff[199] = -1;
  214.       stackdiff[200] = 0;
  215.       stackdiff[201] = 0;
  216.       stackdiff[202] = 0;
  217.       stackdiff[209] = 0;
  218.    }
  219.  
  220.    static void useCode(Code var0) {
  221.       code = var0;
  222.    }
  223.  
  224.    static Code newCode(Obj var0, boolean var1, boolean var2) {
  225.       code = new Code(var0, var1, var2);
  226.       return code;
  227.    }
  228.  
  229.    static Pool newPool() {
  230.       pool.reset();
  231.       return pool;
  232.    }
  233.  
  234.    static Label mergeLabels(Label var0, Label var1) {
  235.       if (var1 == null) {
  236.          return var0;
  237.       } else {
  238.          return var0 == null ? var1 : new Label(var1.pc, mergeLabels(var0, var1.next), var1.stacksize, var1.uninits);
  239.       }
  240.    }
  241.  
  242.    static void resolve(Label var0) {
  243.       resolve(var0, code.cp);
  244.    }
  245.  
  246.    static void resolve(Label var0, int var1) {
  247.       if (var0 != null) {
  248.          if (var1 > code.cp) {
  249.             var1 = code.cp;
  250.          }
  251.  
  252.          if (get1(var0.pc) == 167 && var0.pc + 3 == var1 && var1 == code.cp && !fixedPc) {
  253.             code.cp -= 3;
  254.             var1 -= 3;
  255.          } else if (code.fatCode) {
  256.             put4(var0.pc + 1, var1 - var0.pc);
  257.          } else if (var1 - var0.pc >= -32768 && var1 - var0.pc <= 32767) {
  258.             put2(var0.pc + 1, var1 - var0.pc);
  259.          } else {
  260.             code.fatCode = true;
  261.          }
  262.  
  263.          fixedPc = true;
  264.          resolve(var0.next, var1);
  265.          if (code.cp == var1) {
  266.             alive = true;
  267.             stacksize = var0.stacksize;
  268.             code.uninits.orSet(var0.uninits);
  269.          }
  270.       }
  271.  
  272.    }
  273.  
  274.    static Label branch(int var0) {
  275.       if (var0 != dontgoto && alive) {
  276.          Label var1 = new Label(code.cp, (Label)null, stacksize + stackdiff[var0], uninitSet());
  277.          emitJump(var1, var0);
  278.          fixedPc = code.fatCode;
  279.          if (var0 == 167) {
  280.             alive = false;
  281.             code.uninits.clear();
  282.          }
  283.  
  284.          return var1;
  285.       } else {
  286.          return null;
  287.       }
  288.    }
  289.  
  290.    static void emitJump(Label var0, int var1) {
  291.       if (code.fatCode) {
  292.          if (var1 != 167 && var1 != 168) {
  293.             emitop2(negate(var1), 8);
  294.             emitop4(167, 0);
  295.             var0.pc += 3;
  296.          } else {
  297.             emitop4(var1, 0);
  298.          }
  299.       } else {
  300.          emitop2(var1, 0);
  301.       }
  302.  
  303.    }
  304.  
  305.    static int negate(int var0) {
  306.       return (var0 + 1 ^ 1) - 1;
  307.    }
  308.  
  309.    static void emitMinusOne(int var0) {
  310.       if (var0 == 0) {
  311.          emitop(2);
  312.       } else {
  313.          emitop(9);
  314.          emitop(10);
  315.          emitop(101);
  316.       }
  317.  
  318.    }
  319.  
  320.    static int one(int var0) {
  321.       return zero(var0) + 1;
  322.    }
  323.  
  324.    static int zero(int var0) {
  325.       switch (var0) {
  326.          case 0:
  327.             return 3;
  328.          case 1:
  329.             return 9;
  330.          case 2:
  331.             return 11;
  332.          case 3:
  333.             return 14;
  334.          default:
  335.             throw new CompilerError("zero");
  336.       }
  337.    }
  338.  
  339.    static int width(Typ[] var0) {
  340.       int var1 = 0;
  341.  
  342.       for(int var2 = 0; var2 < var0.length; ++var2) {
  343.          var1 += width(var0[var2]);
  344.       }
  345.  
  346.       return var1;
  347.    }
  348.  
  349.    static int width(Typ var0) {
  350.       switch (var0.tag) {
  351.          case 12:
  352.             return 0;
  353.          case 7:
  354.          case 9:
  355.             return 2;
  356.          default:
  357.             return 1;
  358.       }
  359.    }
  360.  
  361.    static int typecode(Typ var0) {
  362.       return truncateCode(longTypecode(var0));
  363.    }
  364.  
  365.    static int truncateCode(int var0) {
  366.       switch (var0) {
  367.          case 5:
  368.          case 6:
  369.          case 7:
  370.             return 0;
  371.          default:
  372.             return var0;
  373.       }
  374.    }
  375.  
  376.    static int longTypecode(Typ var0) {
  377.       switch (var0.tag) {
  378.          case 2:
  379.             return 5;
  380.          case 3:
  381.          case 12:
  382.          case 14:
  383.          default:
  384.             throw new CompilerError("typecode");
  385.          case 4:
  386.             return 6;
  387.          case 5:
  388.             return 7;
  389.          case 6:
  390.             return 0;
  391.          case 7:
  392.             return 1;
  393.          case 8:
  394.             return 2;
  395.          case 9:
  396.             return 3;
  397.          case 10:
  398.             return 5;
  399.          case 11:
  400.             return 4;
  401.          case 13:
  402.             return 4;
  403.          case 15:
  404.             return 4;
  405.       }
  406.    }
  407.  
  408.    static int mkref(Obj var0) {
  409.       if (var0 instanceof ClassObj) {
  410.          return pool.put(className((ClassObj)var0));
  411.       } else {
  412.          byte var1;
  413.          if (var0 instanceof VarObj) {
  414.             var1 = 9;
  415.          } else if ((var0.owner.modifiers & 512) != 0) {
  416.             var1 = 11;
  417.          } else {
  418.             var1 = 10;
  419.          }
  420.  
  421.          return pool.put(new Reference(var1, className((ClassObj)var0.owner), nameType(var0)));
  422.       }
  423.    }
  424.  
  425.    static int mkref(Typ var0) {
  426.       return pool.put(new NameRef(7, xClassName(var0)));
  427.    }
  428.  
  429.    private static Name xClassName(Typ var0) {
  430.       switch (var0.tag) {
  431.          case 11:
  432.             return var0.obj.fullname;
  433.          case 12:
  434.          default:
  435.             return ClassFile.typeSig(var0, false);
  436.          case 13:
  437.             return ClassFile.typeSig(var0, false);
  438.          case 14:
  439.             throw new CompilerError("xClassName");
  440.       }
  441.    }
  442.  
  443.    private static NameAndType nameType(Obj var0) {
  444.       Name var1 = var0.name;
  445.       if ((var0.modifiers & 2) != 0 && Switches.obfuscate) {
  446.          var1 = Name.fromString(String.valueOf("_$").concat(String.valueOf(var1.index)));
  447.       }
  448.  
  449.       return new NameAndType(var1, ClassFile.typeSig(var0.typ, false));
  450.    }
  451.  
  452.    static NameRef stringName(Name var0) {
  453.       return new NameRef(8, var0);
  454.    }
  455.  
  456.    static NameRef className(ClassObj var0) {
  457.       return new NameRef(7, var0.fullname);
  458.    }
  459.  
  460.    static int putConstant(Object var0) {
  461.       return pool.put(var0);
  462.    }
  463.  
  464.    static void checkInit(int var0, int var1) {
  465.       if (alive) {
  466.          if (var1 < 0) {
  467.             Report.error(var0, "illegal forward reference");
  468.          } else if (code.uninits.member(var1)) {
  469.             Report.error(var0, "variable might not have been initialized");
  470.             code.uninits.excl(var1);
  471.          }
  472.       }
  473.  
  474.    }
  475.  
  476.    static void letInit(int var0) {
  477.       if (alive) {
  478.          code.uninits.excl(var0);
  479.       }
  480.  
  481.    }
  482.  
  483.    static void letUninit(int var0) {
  484.       if (alive) {
  485.          code.uninits.incl(var0);
  486.       }
  487.  
  488.    }
  489.  
  490.    static void statBegin(int var0) {
  491.       if (alive) {
  492.          statPos = var0;
  493.          code.addLineNumber(code.cp, var0 >>> 10);
  494.       } else {
  495.          Report.warning(var0, "statement is unreachable");
  496.       }
  497.  
  498.    }
  499.  
  500.    static void adrGlobal(VarObj var0) {
  501.       var0.adr = code.max_fields++;
  502.    }
  503.  
  504.    static void endScopes(int var0) {
  505.       code.setEndPc(var0, code.cp);
  506.    }
  507.  
  508.    static int nextLocal() {
  509.       return code.nvars;
  510.    }
  511.  
  512.    static void adrLocal(VarObj var0, int var1) {
  513.       var0.adr = var1;
  514.       code.addLocalVar(code.cp, var0);
  515.    }
  516.  
  517.    static int newLocal(Typ var0) {
  518.       int var1 = code.max_locals;
  519.       code.max_locals += width(var0);
  520.       return var1;
  521.    }
  522.  
  523.    static void registerCatch(int var0, int var1, int var2, int var3) {
  524.       code.addCatch(var0, var1, var2, var3);
  525.    }
  526.  
  527.    static void entryPoint(int var0, Bits var1) {
  528.       entryPoint(var0);
  529.       code.uninits = var1.dup();
  530.    }
  531.  
  532.    static void entryPoint(int var0) {
  533.       stacksize = var0;
  534.       alive = true;
  535.       if (stacksize > code.max_stack) {
  536.          code.max_stack = stacksize;
  537.       }
  538.  
  539.    }
  540.  
  541.    static void align(int var0) {
  542.       if (alive) {
  543.          while(code.cp % var0 != 0) {
  544.             emit1(0);
  545.          }
  546.       }
  547.  
  548.    }
  549.  
  550.    static int get4(int var0) {
  551.       return get1(var0) << 24 | get1(var0 + 1) << 16 | get1(var0 + 2) << 8 | get1(var0 + 3);
  552.    }
  553.  
  554.    static int get1(int var0) {
  555.       return code.code[var0] & 255;
  556.    }
  557.  
  558.    static void put4(int var0, int var1) {
  559.       put1(var0, var1 >> 24 & 255);
  560.       put1(var0 + 1, var1 >> 16 & 255);
  561.       put1(var0 + 2, var1 >> 8 & 255);
  562.       put1(var0 + 3, var1 & 255);
  563.    }
  564.  
  565.    static void put2(int var0, int var1) {
  566.       put1(var0, var1 >> 8 & 255);
  567.       put1(var0 + 1, var1 & 255);
  568.    }
  569.  
  570.    static void put1(int var0, int var1) {
  571.       code.code[var0] = (byte)var1;
  572.    }
  573.  
  574.    static void emitop4(int var0, int var1) {
  575.       emitop(var0);
  576.       emit2(var1);
  577.    }
  578.  
  579.    static void emitop2(int var0, int var1) {
  580.       emitop(var0);
  581.       emit2(var1);
  582.    }
  583.  
  584.    static void emitop1w(int var0, int var1) {
  585.       if (var1 > 255) {
  586.          emitop1(196, var1 >>> 8);
  587.       }
  588.  
  589.       emitop(var0);
  590.       emit1(var1 & 255);
  591.    }
  592.  
  593.    static void emitop1(int var0, int var1) {
  594.       emitop(var0);
  595.       emit1(var1);
  596.    }
  597.  
  598.    static void emitop(int var0) {
  599.       emitop(var0, stackdiff[var0]);
  600.    }
  601.  
  602.    static void emitop(int var0, int var1) {
  603.       if (alive) {
  604.          emit1(var0);
  605.          if (var1 <= -1000) {
  606.             alive = false;
  607.             code.uninits.clear();
  608.          } else {
  609.             stacksize += var1;
  610.             if (stacksize > code.max_stack) {
  611.                code.max_stack = stacksize;
  612.             }
  613.          }
  614.       }
  615.  
  616.    }
  617.  
  618.    static void emit4(int var0) {
  619.       emit1(var0 >> 24 & 255);
  620.       emit1(var0 >> 16 & 255);
  621.       emit1(var0 >> 8 & 255);
  622.       emit1(var0 & 255);
  623.    }
  624.  
  625.    static void emit2(int var0) {
  626.       int var1 = var0 >> 8 & 255;
  627.       int var2 = var0 & 255;
  628.       if (alive) {
  629.          if (code.cp + 2 > code.code.length) {
  630.             code.addCode((byte)var1);
  631.             code.addCode((byte)var2);
  632.          } else {
  633.             code.code[code.cp++] = (byte)var1;
  634.             code.code[code.cp++] = (byte)var2;
  635.          }
  636.       }
  637.  
  638.    }
  639.  
  640.    static void emit1(int var0) {
  641.       if (alive) {
  642.          if (code.cp == code.code.length) {
  643.             code.addCode((byte)var0);
  644.          } else {
  645.             code.code[code.cp++] = (byte)var0;
  646.          }
  647.       }
  648.  
  649.    }
  650.  
  651.    static Bits uninitSet() {
  652.       return code.uninits.dup();
  653.    }
  654.  
  655.    static int stackSize() {
  656.       return stacksize;
  657.    }
  658.  
  659.    static int curPc() {
  660.       fixedPc = true;
  661.       return code.cp;
  662.    }
  663.  
  664.    public Gen() {
  665.    }
  666. }
  667.