hg/bck2brwsr: src/main/java/org/apidesign/java4browser/ByteCodeToJavaScript.java@6e8e00258234

     1 /*

     2 Java 4 Browser Bytecode Translator

     3 Copyright (C) 2012-2012 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

     5 This program is free software: you can redistribute it and/or modify

     6 it under the terms of the GNU General Public License as published by

     7 the Free Software Foundation, version 2 of the License.

     9 This program is distributed in the hope that it will be useful,

    10 but WITHOUT ANY WARRANTY; without even the implied warranty of

    11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12 GNU General Public License for more details.

    14 You should have received a copy of the GNU General Public License

    15 along with this program. Look for COPYING file in the top folder.

    16 If not, see http://opensource.org/licenses/GPL-2.0.

    17 */

    18 package org.apidesign.java4browser;

    20 import java.io.IOException;

    21 import java.io.InputStream;

    22 import java.util.List;

    23 import static org.netbeans.modules.classfile.ByteCodes.*;

    24 import org.netbeans.modules.classfile.CPClassInfo;

    25 import org.netbeans.modules.classfile.CPEntry;

    26 import org.netbeans.modules.classfile.CPFieldInfo;

    27 import org.netbeans.modules.classfile.CPMethodInfo;

    28 import org.netbeans.modules.classfile.ClassFile;

    29 import org.netbeans.modules.classfile.ClassName;

    30 import org.netbeans.modules.classfile.Code;

    31 import org.netbeans.modules.classfile.Method;

    32 import org.netbeans.modules.classfile.Parameter;

    33 import org.netbeans.modules.classfile.Variable;

    35 /** Translator of the code inside class files to JavaScript.

    36  *

    37  * @author Jaroslav Tulach <jtulach@netbeans.org>

    38  */

    39 public final class ByteCodeToJavaScript {

    40     private final ClassFile jc;

    41     private final Appendable out;

    43     private ByteCodeToJavaScript(ClassFile jc, Appendable out) {

    44         this.jc = jc;

    45         this.out = out;

    46     }

    48     /** Converts a given class file to a JavaScript version.

    49      * @param fileName the name of the file we are reading

    50      * @param classFile input stream with code of the .class file

    51      * @param out a {@link StringBuilder} or similar to generate the output to

    52      * @throws IOException if something goes wrong during read or write or translating

    53      */

    54     public static void compile(String fileName, InputStream classFile, Appendable out) throws IOException {

    55         ClassFile jc = new ClassFile(classFile, true);

    56         ByteCodeToJavaScript compiler = new ByteCodeToJavaScript(jc, out);

    57         for (Method m : jc.getMethods()) {

    58             if (m.isStatic()) {

    59                 compiler.generateStaticMethod(m);

    60             } else {

    61                 compiler.generateInstanceMethod(m);

    62             }

    63         }

    64         for (Variable v : jc.getVariables()) {

    65             if (v.isStatic()) {

    66                 compiler.generateStaticField(v);

    67             }

    68         }

    69         out.append("function java_lang_Object(){}\n"); // XXX temporary

    70         out.append("function java_lang_Object_consV(self){}\n"); // XXX temporary

    72         final String className = jc.getName().getExternalName().replace('.', '_');

    73         out.append("\nfunction ").append(className);

    74         out.append("() {");

    75         for (Method m : jc.getMethods()) {

    76             if (!m.isStatic()) {

    77                 compiler.generateMethodReference(m);

    78             }

    79         }

    80         for (Variable v : jc.getVariables()) {

    81             if (!v.isStatic()) {

    82                 out.append("\n  this." + v.getName() + " = 0;");

    83             }

    84         }

    85         out.append("\n}");

    86         ClassName sc = jc.getSuperClass();

    87         if (sc != null) {

    88             out.append("\n  ").append(className)

    89                .append(".prototype = new ").append(sc.getExternalName().replace('.', '_'));

    90         }

    91     }

    92     private void generateStaticMethod(Method m) throws IOException {

    93         out.append("\nfunction ").append(

    94             jc.getName().getExternalName().replace('.', '_')

    95         ).append('_').append(findMethodName(m));

    96         out.append('(');

    97         String space = "";

    98         List<Parameter> args = m.getParameters();

    99         for (int index = 0, i = 0; i < args.size(); i++) {

   100             out.append(space);

   101             out.append("arg").append(String.valueOf(index));

   102             space = ",";

   103             final String desc = args.get(i).getDescriptor();

   104             if ("D".equals(desc) || "J".equals(desc)) {

   105                 index += 2;

   106             } else {

   107                 index++;

   108             }

   109         }

   110         out.append(") {").append("\n");

   111         final Code code = m.getCode();

   112         int len = code.getMaxLocals();

   113         for (int index = args.size(), i = args.size(); i < len; i++) {

   114             out.append("  var ");

   115             out.append("arg").append(String.valueOf(i)).append(";\n");

   116         }

   117         out.append("  var stack = new Array(");

   118         out.append(Integer.toString(code.getMaxStack()));

   119         out.append(");\n");

   120         produceCode(code.getByteCodes());

   121         out.append("}");

   122     }

   124     private void generateMethodReference(Method m) throws IOException {

   125         final String name = findMethodName(m);

   126         out.append("\n  this.").append(name).append(" = ")

   127            .append(jc.getName().getExternalName().replace('.', '_'))

   128            .append('_').append(name).append(";");

   129     }

   131     private void generateInstanceMethod(Method m) throws IOException {

   132         out.append("\nfunction ").append(

   133             jc.getName().getExternalName().replace('.', '_')

   134         ).append('_').append(findMethodName(m));

   135         out.append("(arg0");

   136         String space = ",";

   137         List<Parameter> args = m.getParameters();

   138         for (int index = 1, i = 0; i < args.size(); i++) {

   139             out.append(space);

   140             out.append("arg").append(String.valueOf(index));

   141             final String desc = args.get(i).getDescriptor();

   142             if ("D".equals(desc) || "J".equals(desc)) {

   143                 index += 2;

   144             } else {

   145                 index++;

   146             }

   147         }

   148         out.append(") {").append("\n");

   149         final Code code = m.getCode();

   150         int len = code.getMaxLocals();

   151         for (int index = args.size(), i = args.size(); i < len; i++) {

   152             out.append("  var ");

   153             out.append("arg").append(String.valueOf(i + 1)).append(";\n");

   154         }

   155         out.append(";\n  var stack = new Array(");

   156         out.append(Integer.toString(code.getMaxStack()));

   157         out.append(");\n");

   158         produceCode(code.getByteCodes());

   159         out.append("}");

   160     }

   162     private void produceCode(byte[] byteCodes) throws IOException {

   163         out.append("\n  var gt = 0;\n  for(;;) switch(gt) {\n");

   164         for (int i = 0; i < byteCodes.length; i++) {

   165             int prev = i;

   166             out.append("    case " + i).append(": ");

   167             final int c = (byteCodes[i] + 256) % 256;

   168             switch (c) {

   169                 case bc_aload_0:

   170                 case bc_iload_0:

   171                 case bc_lload_0:

   172                 case bc_fload_0:

   173                 case bc_dload_0:

   174                     out.append("stack.push(arg0);");

   175                     break;

   176                 case bc_aload_1:

   177                 case bc_iload_1:

   178                 case bc_lload_1:

   179                 case bc_fload_1:

   180                 case bc_dload_1:

   181                     out.append("stack.push(arg1);");

   182                     break;

   183                 case bc_aload_2:

   184                 case bc_iload_2:

   185                 case bc_lload_2:

   186                 case bc_fload_2:

   187                 case bc_dload_2:

   188                     out.append("stack.push(arg2);");

   189                     break;

   190                 case bc_aload_3:

   191                 case bc_iload_3:

   192                 case bc_lload_3:

   193                 case bc_fload_3:

   194                 case bc_dload_3:

   195                     out.append("stack.push(arg3);");

   196                     break;

   197                 case bc_iload:

   198                 case bc_lload:

   199                 case bc_fload:

   200                 case bc_dload:

   201                 case bc_aload: {

   202                     final int indx = (byteCodes[++i] + 256) % 256;

   203                     out.append("stack.push(arg").append(indx + ");");

   204                     break;

   205                 }

   206                 case bc_astore_0:

   207                 case bc_istore_0:

   208                 case bc_lstore_0:

   209                 case bc_fstore_0:

   210                 case bc_dstore_0:

   211                     out.append("arg0 = stack.pop();");

   212                     break;

   213                 case bc_astore_1:

   214                 case bc_istore_1:

   215                 case bc_lstore_1:

   216                 case bc_fstore_1:

   217                 case bc_dstore_1:

   218                     out.append("arg1 = stack.pop();");

   219                     break;

   220                 case bc_astore_2:

   221                 case bc_istore_2:

   222                 case bc_lstore_2:

   223                 case bc_fstore_2:

   224                 case bc_dstore_2:

   225                     out.append("arg2 = stack.pop();");

   226                     break;

   227                 case bc_astore_3:

   228                 case bc_istore_3:

   229                 case bc_lstore_3:

   230                 case bc_fstore_3:

   231                 case bc_dstore_3:

   232                     out.append("arg3 = stack.pop();");

   233                     break;

   234                 case bc_iadd:

   235                 case bc_ladd:

   236                 case bc_fadd:

   237                 case bc_dadd:

   238                     out.append("stack.push(stack.pop() + stack.pop());");

   239                     break;

   240                 case bc_isub:

   241                 case bc_lsub:

   242                 case bc_fsub:

   243                 case bc_dsub:

   244                     out.append("{ var tmp = stack.pop(); stack.push(stack.pop() - tmp); }");

   245                     break;

   246                 case bc_imul:

   247                 case bc_lmul:

   248                 case bc_fmul:

   249                 case bc_dmul:

   250                     out.append("stack.push(stack.pop() * stack.pop());");

   251                     break;

   252                 case bc_idiv:

   253                 case bc_ldiv:

   254                     out.append("{ var tmp = stack.pop(); stack.push(Math.floor(stack.pop() / tmp)); }");

   255                     break;

   256                 case bc_fdiv:

   257                 case bc_ddiv:

   258                     out.append("{ var tmp = stack.pop(); stack.push(stack.pop() / tmp); }");

   259                     break;

   260                 case bc_iand:

   261                 case bc_land:

   262                     out.append("stack.push(stack.pop() & stack.pop());");

   263                     break;

   264                 case bc_ior:

   265                 case bc_lor:

   266                     out.append("stack.push(stack.pop() | stack.pop());");

   267                     break;

   268                 case bc_ixor:

   269                 case bc_lxor:

   270                     out.append("stack.push(stack.pop() ^ stack.pop());");

   271                     break;

   272                 case bc_iinc: {

   273                     final int varIndx = (byteCodes[++i] + 256) % 256;

   274                     final int incrBy = (byteCodes[++i] + 256) % 256;

   275                     if (incrBy == 1) {

   276                         out.append("arg" + varIndx).append("++;");

   277                     } else {

   278                         out.append("arg" + varIndx).append(" += " + incrBy).append(";");

   279                     }

   280                     break;

   281                 }

   282                 case bc_return:

   283                     out.append("return;");

   284                     break;

   285                 case bc_ireturn:

   286                 case bc_lreturn:

   287                 case bc_freturn:

   288                 case bc_dreturn:

   289                 case bc_areturn:

   290                     out.append("return stack.pop();");

   291                     break;

   292                 case bc_i2l:

   293                 case bc_i2f:

   294                 case bc_i2d:

   295                 case bc_l2i:

   296                     // max int check?

   297                 case bc_l2f:

   298                 case bc_l2d:

   299                 case bc_f2d:

   300                 case bc_d2f:

   301                     out.append("/* number conversion */");

   302                     break;

   303                 case bc_f2i:

   304                 case bc_f2l:

   305                 case bc_d2i:

   306                 case bc_d2l:

   307                     out.append("stack.push(Math.floor(stack.pop()));");

   308                     break;

   309                 case bc_i2b:

   310                 case bc_i2c:

   311                 case bc_i2s:

   312                     out.append("/* number conversion */");

   313                     break;

   314                 case bc_iconst_0:

   315                 case bc_dconst_0:

   316                 case bc_lconst_0:

   317                 case bc_fconst_0:

   318                     out.append("stack.push(0);");

   319                     break;

   320                 case bc_iconst_1:

   321                 case bc_lconst_1:

   322                 case bc_fconst_1:

   323                 case bc_dconst_1:

   324                     out.append("stack.push(1);");

   325                     break;

   326                 case bc_iconst_2:

   327                 case bc_fconst_2:

   328                     out.append("stack.push(2);");

   329                     break;

   330                 case bc_iconst_3:

   331                     out.append("stack.push(3);");

   332                     break;

   333                 case bc_iconst_4:

   334                     out.append("stack.push(4);");

   335                     break;

   336                 case bc_iconst_5:

   337                     out.append("stack.push(5);");

   338                     break;

   339                 case bc_ldc_w:

   340                 case bc_ldc2_w: {

   341                     int indx = readIntArg(byteCodes, i);

   342                     CPEntry entry = jc.getConstantPool().get(indx);

   343                     i += 2;

   344                     out.append("stack.push(" + entry.getValue() + ");");

   345                     break;

   346                 }

   347                 case bc_if_icmpeq: {

   348                     i = generateIf(byteCodes, i, "==");

   349                     break;

   350                 }

   351                 case bc_ifeq: {

   352                     int indx = i + readIntArg(byteCodes, i);

   353                     out.append("if (stack.pop() == 0) { gt = " + indx);

   354                     out.append("; continue; }");

   355                     i += 2;

   356                     break;

   357                 }

   358                 case bc_ifnonnull: {

   359                     int indx = i + readIntArg(byteCodes, i);

   360                     out.append("if (stack.pop()) { gt = " + indx);

   361                     out.append("; continue; }");

   362                     i += 2;

   363                     break;

   364                 }

   365                 case bc_ifnull: {

   366                     int indx = i + readIntArg(byteCodes, i);

   367                     out.append("if (!stack.pop()) { gt = " + indx);

   368                     out.append("; continue; }");

   369                     i += 2;

   370                     break;

   371                 }

   372                 case bc_if_icmpne:

   373                     i = generateIf(byteCodes, i, "!=");

   374                     break;

   375                 case bc_if_icmplt:

   376                     i = generateIf(byteCodes, i, ">");

   377                     break;

   378                 case bc_if_icmple:

   379                     i = generateIf(byteCodes, i, ">=");

   380                     break;

   381                 case bc_if_icmpgt:

   382                     i = generateIf(byteCodes, i, "<");

   383                     break;

   384                 case bc_if_icmpge:

   385                     i = generateIf(byteCodes, i, "<=");

   386                     break;

   387                 case bc_goto: {

   388                     int indx = i + readIntArg(byteCodes, i);

   389                     out.append("gt = " + indx).append("; continue;");

   390                     i += 2;

   391                     break;

   392                 }

   393                 case bc_invokeinterface:

   394                 case bc_invokevirtual:

   395                     i = invokeVirtualMethod(byteCodes, i);

   396                     break;

   397                 case bc_invokespecial:

   398                     i = invokeStaticMethod(byteCodes, i, false);

   399                     break;

   400                 case bc_invokestatic:

   401                     i = invokeStaticMethod(byteCodes, i, true);

   402                     break;

   403                 case bc_new: {

   404                     int indx = readIntArg(byteCodes, i);

   405                     CPClassInfo ci = jc.getConstantPool().getClass(indx);

   406                     out.append("stack.push(");

   407                     out.append("new ").append(ci.getClassName().getExternalName().replace('.','_'));

   408                     out.append(");");

   409                     i += 2;

   410                     break;

   411                 }

   412                 case bc_dup:

   413                     out.append("stack.push(stack[stack.length - 1]);");

   414                     break;

   415                 case bc_bipush:

   416                     out.append("stack.push(" + byteCodes[++i] + ");");

   417                     break;

   418                 case bc_getfield: {

   419                     int indx = readIntArg(byteCodes, i);

   420                     CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);

   421                     out.append(" stack.push(stack.pop().").append(fi.getFieldName()).append(");");

   422                     i += 2;

   423                     break;

   424                 }

   425                 case bc_getstatic: {

   426                     int indx = readIntArg(byteCodes, i);

   427                     CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);

   428                     out.append("stack.push(").append(fi.getClassName().getExternalName().replace('.', '_'));

   429                     out.append('_').append(fi.getFieldName()).append(");");

   430                     i += 2;

   431                     break;

   432                 }

   433                 case bc_putstatic: {

   434                     int indx = readIntArg(byteCodes, i);

   435                     CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);

   436                     out.append(fi.getClassName().getExternalName().replace('.', '_'));

   437                     out.append('_').append(fi.getFieldName()).append(" = stack.pop();");

   438                     i += 2;

   439                     break;

   440                 }

   441                 case bc_putfield: {

   442                     int indx = readIntArg(byteCodes, i);

   443                     CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);

   444                     out.append("{ var v = stack.pop(); stack.pop().")

   445                        .append(fi.getFieldName()).append(" = v; }");

   446                     i += 2;

   447                     break;

   448                 }

   450             }

   451             out.append(" /*");

   452             for (int j = prev; j <= i; j++) {

   453                 out.append(" ");

   454                 final int cc = (byteCodes[j] + 256) % 256;

   455                 out.append(Integer.toString(cc));

   456             }

   457             out.append("*/\n");

   458         }

   459         out.append("  }\n");

   460     }

   462     private int generateIf(byte[] byteCodes, int i, final String test) throws IOException {

   463         int indx = i + readIntArg(byteCodes, i);

   464         out.append("if (stack.pop() ").append(test).append(" stack.pop()) { gt = " + indx);

   465         out.append("; continue; }");

   466         return i + 2;

   467     }

   469     private int readIntArg(byte[] byteCodes, int offsetInstruction) {

   470         final int indxHi = byteCodes[offsetInstruction + 1] << 8;

   471         final int indxLo = byteCodes[offsetInstruction + 2];

   472         return (indxHi & 0xffffff00) | (indxLo & 0xff);

   473     }

   475     private static int countArgs(String descriptor, boolean[] hasReturnType, StringBuilder sig) {

   476         int cnt = 0;

   477         int i = 0;

   478         Boolean count = null;

   479         int firstPos = sig.length();

   480         while (i < descriptor.length()) {

   481             char ch = descriptor.charAt(i++);

   482             switch (ch) {

   483                 case '(':

   484                     count = true;

   485                     continue;

   486                 case ')':

   487                     count = false;

   488                     continue;

   489                 case 'B':

   490                 case 'C':

   491                 case 'D':

   492                 case 'F':

   493                 case 'I':

   494                 case 'J':

   495                 case 'S':

   496                 case 'Z':

   497                     if (count) {

   498                         cnt++;

   499                         sig.append(ch);

   500                     } else {

   501                         hasReturnType[0] = true;

   502                         sig.insert(firstPos, ch);

   503                     }

   504                     continue;

   505                 case 'V':

   506                     assert !count;

   507                     hasReturnType[0] = false;

   508                     sig.insert(firstPos, 'V');

   509                     continue;

   510                 case 'L':

   511                     int next = descriptor.indexOf(';', i);

   512                     if (count) {

   513                         cnt++;

   514                         sig.append(ch);

   515                         sig.append(descriptor.substring(i, next).replace('/', '_'));

   516                     } else {

   517                         sig.insert(firstPos, descriptor.substring(i, next).replace('/', '_'));

   518                         sig.insert(firstPos, ch);

   519                         hasReturnType[0] = true;

   520                     }

   521                     i = next + 1;

   522                     continue;

   523                 case '[':

   524                     //arrays++;

   525                     continue;

   526                 default:

   527                     break; // invalid character

   528             }

   529         }

   530         return cnt;

   531     }

   533     private void generateStaticField(Variable v) throws IOException {

   534         out.append("\nvar ")

   535            .append(jc.getName().getExternalName().replace('.', '_'))

   536            .append('_').append(v.getName()).append(" = 0;");

   537     }

   539     private String findMethodName(Method m) {

   540         StringBuilder out = new StringBuilder();

   541         if ("<init>".equals(m.getName())) { // NOI18N

   542             out.append("consV"); // NOI18N

   543         } else {

   544             out.append(m.getName());

   545             outType(m.getReturnType(), out);

   546         }

   547         List<Parameter> args = m.getParameters();

   548         for (Parameter t : args) {

   549             outType(t.getDescriptor(), out);

   550         }

   551         return out.toString();

   552     }

   554     private String findMethodName(CPMethodInfo mi, int[] cnt, boolean[] hasReturn) {

   555         StringBuilder name = new StringBuilder();

   556         if ("<init>".equals(mi.getName())) { // NOI18N

   557             name.append("cons"); // NOI18N

   558         } else {

   559             name.append(mi.getName());

   560         }

   561         cnt[0] = countArgs(mi.getDescriptor(), hasReturn, name);

   562         return name.toString();

   563     }

   565     private int invokeStaticMethod(byte[] byteCodes, int i, boolean isStatic)

   566     throws IOException {

   567         int methodIndex = readIntArg(byteCodes, i);

   568         CPMethodInfo mi = (CPMethodInfo) jc.getConstantPool().get(methodIndex);

   569         boolean[] hasReturn = { false };

   570         int[] cnt = { 0 };

   571         String mn = findMethodName(mi, cnt, hasReturn);

   572         out.append("{ ");

   573         for (int j = cnt[0] - 1; j >= 0; j--) {

   574             out.append("var v" + j).append(" = stack.pop(); ");

   575         }

   577         if (hasReturn[0]) {

   578             out.append("stack.push(");

   579         }

   580         out.append(mi.getClassName().getInternalName().replace('/', '_'));

   581         out.append('_');

   582         out.append(mn);

   583         out.append('(');

   584         String sep = "";

   585         if (!isStatic) {

   586             out.append("stack.pop()");

   587             sep = ", ";

   588         }

   589         for (int j = 0; j < cnt[0]; j++) {

   590             out.append(sep);

   591             out.append("v" + j);

   592             sep = ", ";

   593         }

   594         out.append(")");

   595         if (hasReturn[0]) {

   596             out.append(")");

   597         }

   598         out.append("; }");

   599         i += 2;

   600         return i;

   601     }

   602     private int invokeVirtualMethod(byte[] byteCodes, int i)

   603     throws IOException {

   604         int methodIndex = readIntArg(byteCodes, i);

   605         CPMethodInfo mi = (CPMethodInfo) jc.getConstantPool().get(methodIndex);

   606         boolean[] hasReturn = { false };

   607         int[] cnt = { 0 };

   608         String mn = findMethodName(mi, cnt, hasReturn);

   609         out.append("{ ");

   610         for (int j = cnt[0] - 1; j >= 0; j--) {

   611             out.append("var v" + j).append(" = stack.pop(); ");

   612         }

   613         out.append("var self = stack.pop(); ");

   614         if (hasReturn[0]) {

   615             out.append("stack.push(");

   616         }

   617         out.append("self.");

   618         out.append(mn);

   619         out.append('(');

   620         out.append("self");

   621         for (int j = 0; j < cnt[0]; j++) {

   622             out.append(", ");

   623             out.append("v" + j);

   624         }

   625         out.append(")");

   626         if (hasReturn[0]) {

   627             out.append(")");

   628         }

   629         out.append("; }");

   630         i += 2;

   631         return i;

   632     }

   634     private void outType(final String d, StringBuilder out) {

   635         if (d.charAt(0) == 'L') {

   636             assert d.charAt(d.length() - 1) == ';';

   637             out.append(d.replace('/', '_').substring(0, d.length() - 1));

   638         } else {

   639             out.append(d);

   640         }

   641     }

   642 }

author	Jaroslav Tulach <jaroslav.tulach@apidesign.org>
	Thu, 20 Sep 2012 10:26:59 +0200
changeset 16	6e8e00258234
parent 15	65f6fdfd34b6
child 17	cb0cfba1b863
permissions	-rw-r--r--