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

     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.Code;

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

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

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

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

    35  *

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

    37  */

    38 public final class ByteCodeToJavaScript {

    39     private final ClassFile jc;

    40     private final Appendable out;

    42     private ByteCodeToJavaScript(ClassFile jc, Appendable out) {

    43         this.jc = jc;

    44         this.out = out;

    45     }

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

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

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

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

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

    52      */

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

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

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

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

    57             if (m.isStatic()) {

    58                 compiler.generateStaticMethod(m);

    59             } else {

    60                 compiler.generateInstanceMethod(m);

    61             }

    62         }

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

    64             if (v.isStatic()) {

    65                 compiler.generateStaticField(v);

    66             }

    67         }

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

    70         out.append("\nfunction ").append(jc.getName().getExternalName().replace('.', '_'));

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

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

    73             if (!m.isStatic()) {

    75             }

    76         }

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

    78             if (!v.isStatic()) {

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

    80             }

    81         }

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

    83     }

    84     private void generateStaticMethod(Method m) throws IOException {

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

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

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

    88         out.append('(');

    89         String space = "";

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

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

    92             out.append(space);

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

    94             space = ",";

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

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

    97                 index += 2;

    98             } else {

    99                 index++;

   100             }

   101         }

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

   103         final Code code = m.getCode();

   104         int len = code.getMaxLocals();

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

   106             out.append("  var ");

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

   108         }

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

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

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

   112         produceCode(code.getByteCodes());

   113         out.append("}");

   114     }

   116     private void generateInstanceMethod(Method m) throws IOException {

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

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

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

   120         out.append("(arg0");

   121         String space = ",";

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

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

   124             out.append(space);

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

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

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

   128                 index += 2;

   129             } else {

   130                 index++;

   131             }

   132         }

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

   134         final Code code = m.getCode();

   135         int len = code.getMaxLocals();

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

   137             out.append("  var ");

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

   139         }

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

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

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

   143         produceCode(code.getByteCodes());

   144         out.append("}");

   145     }

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

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

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

   150             int prev = i;

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

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

   153             switch (c) {

   154                 case bc_aload_0:

   155                 case bc_iload_0:

   156                 case bc_lload_0:

   157                 case bc_fload_0:

   158                 case bc_dload_0:

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

   160                     break;

   161                 case bc_aload_1:

   162                 case bc_iload_1:

   163                 case bc_lload_1:

   164                 case bc_fload_1:

   165                 case bc_dload_1:

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

   167                     break;

   168                 case bc_aload_2:

   169                 case bc_iload_2:

   170                 case bc_lload_2:

   171                 case bc_fload_2:

   172                 case bc_dload_2:

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

   174                     break;

   175                 case bc_aload_3:

   176                 case bc_iload_3:

   177                 case bc_lload_3:

   178                 case bc_fload_3:

   179                 case bc_dload_3:

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

   181                     break;

   182                 case bc_iload:

   183                 case bc_lload:

   184                 case bc_fload:

   185                 case bc_dload:

   186                 case bc_aload: {

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

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

   189                     break;

   190                 }

   191                 case bc_astore_0:

   192                 case bc_istore_0:

   193                 case bc_lstore_0:

   194                 case bc_fstore_0:

   195                 case bc_dstore_0:

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

   197                     break;

   198                 case bc_astore_1:

   199                 case bc_istore_1:

   200                 case bc_lstore_1:

   201                 case bc_fstore_1:

   202                 case bc_dstore_1:

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

   204                     break;

   205                 case bc_astore_2:

   206                 case bc_istore_2:

   207                 case bc_lstore_2:

   208                 case bc_fstore_2:

   209                 case bc_dstore_2:

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

   211                     break;

   212                 case bc_astore_3:

   213                 case bc_istore_3:

   214                 case bc_lstore_3:

   215                 case bc_fstore_3:

   216                 case bc_dstore_3:

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

   218                     break;

   219                 case bc_iadd:

   220                 case bc_ladd:

   221                 case bc_fadd:

   222                 case bc_dadd:

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

   224                     break;

   225                 case bc_isub:

   226                 case bc_lsub:

   227                 case bc_fsub:

   228                 case bc_dsub:

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

   230                     break;

   231                 case bc_imul:

   232                 case bc_lmul:

   233                 case bc_fmul:

   234                 case bc_dmul:

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

   236                     break;

   237                 case bc_idiv:

   238                 case bc_ldiv:

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

   240                     break;

   241                 case bc_fdiv:

   242                 case bc_ddiv:

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

   244                     break;

   245                 case bc_iand:

   246                 case bc_land:

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

   248                     break;

   249                 case bc_ior:

   250                 case bc_lor:

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

   252                     break;

   253                 case bc_ixor:

   254                 case bc_lxor:

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

   256                     break;

   257                 case bc_iinc: {

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

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

   260                     if (incrBy == 1) {

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

   262                     } else {

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

   264                     }

   265                     break;

   266                 }

   267                 case bc_return:

   268                     out.append("return;");

   269                     break;

   270                 case bc_ireturn:

   271                 case bc_lreturn:

   272                 case bc_freturn:

   273                 case bc_dreturn:

   274                 case bc_areturn:

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

   276                     break;

   277                 case bc_i2l:

   278                 case bc_i2f:

   279                 case bc_i2d:

   280                 case bc_l2i:

   281                     // max int check?

   282                 case bc_l2f:

   283                 case bc_l2d:

   284                 case bc_f2d:

   285                 case bc_d2f:

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

   287                     break;

   288                 case bc_f2i:

   289                 case bc_f2l:

   290                 case bc_d2i:

   291                 case bc_d2l:

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

   293                     break;

   294                 case bc_i2b:

   295                 case bc_i2c:

   296                 case bc_i2s:

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

   298                     break;

   299                 case bc_iconst_0:

   300                 case bc_dconst_0:

   301                 case bc_lconst_0:

   302                 case bc_fconst_0:

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

   304                     break;

   305                 case bc_iconst_1:

   306                 case bc_lconst_1:

   307                 case bc_fconst_1:

   308                 case bc_dconst_1:

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

   310                     break;

   311                 case bc_iconst_2:

   312                 case bc_fconst_2:

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

   314                     break;

   315                 case bc_iconst_3:

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

   317                     break;

   318                 case bc_iconst_4:

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

   320                     break;

   321                 case bc_iconst_5:

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

   323                     break;

   324                 case bc_ldc_w:

   325                 case bc_ldc2_w: {

   326                     int indx = readIntArg(byteCodes, i);

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

   328                     i += 2;

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

   330                     break;

   331                 }

   332                 case bc_if_icmpeq: {

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

   334                     break;

   335                 }

   336                 case bc_ifeq: {

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

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

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

   340                     i += 2;

   341                     break;

   342                 }

   343                 case bc_if_icmpne:

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

   345                     break;

   346                 case bc_if_icmplt:

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

   348                     break;

   349                 case bc_if_icmple:

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

   351                     break;

   352                 case bc_if_icmpgt:

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

   354                     break;

   355                 case bc_if_icmpge:

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

   357                     break;

   358                 case bc_goto: {

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

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

   361                     i += 2;

   362                     break;

   363                 }

   364                 case bc_invokespecial:

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

   366                     break;

   367                 case bc_invokestatic:

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

   369                     break;

   370                 case bc_new: {

   371                     int indx = readIntArg(byteCodes, i);

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

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

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

   375                     out.append(");");

   376                     i += 2;

   377                     break;

   378                 }

   379                 case bc_dup:

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

   381                     break;

   382                 case bc_bipush:

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

   384                     break;

   385                 case bc_getfield: {

   386                     int indx = readIntArg(byteCodes, i);

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

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

   389                     i += 2;

   390                     break;

   391                 }

   392                 case bc_getstatic: {

   393                     int indx = readIntArg(byteCodes, i);

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

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

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

   397                     i += 2;

   398                     break;

   399                 }

   400                 case bc_putstatic: {

   401                     int indx = readIntArg(byteCodes, i);

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

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

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

   405                     i += 2;

   406                     break;

   407                 }

   408                 case bc_putfield: {

   409                     int indx = readIntArg(byteCodes, i);

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

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

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

   413                     i += 2;

   414                     break;

   415                 }

   417             }

   418             out.append(" /*");

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

   420                 out.append(" ");

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

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

   423             }

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

   425         }

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

   427     }

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

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

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

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

   433         return i + 2;

   434     }

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

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

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

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

   440     }

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

   443         int cnt = 0;

   444         int i = 0;

   445         Boolean count = null;

   446         int firstPos = sig.length();

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

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

   449             switch (ch) {

   450                 case '(':

   451                     count = true;

   452                     continue;

   453                 case ')':

   454                     count = false;

   455                     continue;

   456                 case 'B':

   457                 case 'C':

   458                 case 'D':

   459                 case 'F':

   460                 case 'I':

   461                 case 'J':

   462                 case 'S':

   463                 case 'Z':

   464                     if (count) {

   465                         cnt++;

   466                         sig.append(ch);

   467                     } else {

   468                         hasReturnType[0] = true;

   469                         sig.insert(firstPos, ch);

   470                     }

   471                     continue;

   472                 case 'V':

   473                     assert !count;

   474                     hasReturnType[0] = false;

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

   476                     continue;

   477                 case 'L':

   478                     i = descriptor.indexOf(';', i);

   479                     if (count) {

   480                         cnt++;

   481                     } else {

   482                         hasReturnType[0] = true;

   483                     }

   484                     continue;

   485                 case '[':

   486                     //arrays++;

   487                     continue;

   488                 default:

   489                     break; // invalid character

   490             }

   491         }

   492         return cnt;

   493     }

   495     private void generateStaticField(Variable v) throws IOException {

   496         out.append("\nvar ")

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

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

   499     }

   501     private String findMethodName(Method m) {

   502         StringBuilder out = new StringBuilder();

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

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

   505         } else {

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

   507             out.append(m.getReturnType());

   508         }

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

   510         for (Parameter t : args) {

   511             out.append(t.getDescriptor());

   512         }

   513         return out.toString();

   514     }

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

   517         StringBuilder name = new StringBuilder();

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

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

   520         } else {

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

   522         }

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

   524         return name.toString();

   525     }

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

   528     throws IOException {

   529         int methodIndex = readIntArg(byteCodes, i);

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

   531         boolean[] hasReturn = { false };

   532         int[] cnt = { 0 };

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

   534         out.append("{ ");

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

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

   537         }

   539         if (hasReturn[0]) {

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

   541         }

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

   543         out.append('_');

   544         out.append(mn);

   545         out.append('(');

   546         String sep = "";

   547         if (!isStatic) {

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

   549             sep = ", ";

   550         }

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

   552             out.append(sep);

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

   554             sep = ", ";

   555         }

   556         out.append(")");

   557         if (hasReturn[0]) {

   558             out.append(")");

   559         }

   560         out.append("; }");

   561         i += 2;

   562         return i;

   563     }

   564 }

author	Jaroslav Tulach <jaroslav.tulach@apidesign.org>
	Wed, 19 Sep 2012 18:53:16 +0200
changeset 11	eca88b77b986
parent 10	e84d9314f1bc
child 12	282828609b86
permissions	-rw-r--r--