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

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

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

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

    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             }

    61         }

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

    63             if (v.isStatic()) {

    64                 compiler.generateStaticField(v);

    65             }

    66         }

    67     }

    68     private void generateStaticMethod(Method m) throws IOException {

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

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

    71         ).append('_').append(

    72             m.getName()

    73         );

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

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

    76         for (Parameter t : args) {

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

    78         }

    79         out.append('(');

    80         String space = "";

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

    82             out.append(space);

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

    84             space = ",";

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

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

    87                 index += 2;

    88             } else {

    89                 index++;

    90             }

    91         }

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

    93         final Code code = m.getCode();

    94         int len = code.getMaxLocals();

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

    96             out.append("  var ");

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

    98         }

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

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

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

   102         produceCode(code.getByteCodes());

   103         out.append("}");

   104     }

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

   107         out.append("\nvar gt = 0;\nfor(;;) switch(gt) {\n");

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

   109             int prev = i;

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

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

   112             switch (c) {

   113                 case bc_aload_0:

   114                 case bc_iload_0:

   115                 case bc_lload_0:

   116                 case bc_fload_0:

   117                 case bc_dload_0:

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

   119                     break;

   120                 case bc_aload_1:

   121                 case bc_iload_1:

   122                 case bc_lload_1:

   123                 case bc_fload_1:

   124                 case bc_dload_1:

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

   126                     break;

   127                 case bc_aload_2:

   128                 case bc_iload_2:

   129                 case bc_lload_2:

   130                 case bc_fload_2:

   131                 case bc_dload_2:

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

   133                     break;

   134                 case bc_aload_3:

   135                 case bc_iload_3:

   136                 case bc_lload_3:

   137                 case bc_fload_3:

   138                 case bc_dload_3:

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

   140                     break;

   141                 case bc_iload:

   142                 case bc_lload:

   143                 case bc_fload:

   144                 case bc_dload:

   145                 case bc_aload: {

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

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

   148                     break;

   149                 }

   150                 case bc_astore_0:

   151                 case bc_istore_0:

   152                 case bc_lstore_0:

   153                 case bc_fstore_0:

   154                 case bc_dstore_0:

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

   156                     break;

   157                 case bc_astore_1:

   158                 case bc_istore_1:

   159                 case bc_lstore_1:

   160                 case bc_fstore_1:

   161                 case bc_dstore_1:

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

   163                     break;

   164                 case bc_astore_2:

   165                 case bc_istore_2:

   166                 case bc_lstore_2:

   167                 case bc_fstore_2:

   168                 case bc_dstore_2:

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

   170                     break;

   171                 case bc_astore_3:

   172                 case bc_istore_3:

   173                 case bc_lstore_3:

   174                 case bc_fstore_3:

   175                 case bc_dstore_3:

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

   177                     break;

   178                 case bc_iadd:

   179                 case bc_ladd:

   180                 case bc_fadd:

   181                 case bc_dadd:

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

   183                     break;

   184                 case bc_isub:

   185                 case bc_lsub:

   186                 case bc_fsub:

   187                 case bc_dsub:

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

   189                     break;

   190                 case bc_imul:

   191                 case bc_lmul:

   192                 case bc_fmul:

   193                 case bc_dmul:

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

   195                     break;

   196                 case bc_idiv:

   197                 case bc_ldiv:

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

   199                     break;

   200                 case bc_fdiv:

   201                 case bc_ddiv:

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

   203                     break;

   204                 case bc_iand:

   205                 case bc_land:

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

   207                     break;

   208                 case bc_ior:

   209                 case bc_lor:

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

   211                     break;

   212                 case bc_ixor:

   213                 case bc_lxor:

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

   215                     break;

   216                 case bc_iinc: {

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

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

   219                     if (incrBy == 1) {

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

   221                     } else {

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

   223                     }

   224                     break;

   225                 }

   226                 case bc_ireturn:

   227                 case bc_lreturn:

   228                 case bc_freturn:

   229                 case bc_dreturn:

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

   231                     break;

   232                 case bc_i2l:

   233                 case bc_i2f:

   234                 case bc_i2d:

   235                 case bc_l2i:

   236                     // max int check?

   237                 case bc_l2f:

   238                 case bc_l2d:

   239                 case bc_f2d:

   240                 case bc_d2f:

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

   242                     break;

   243                 case bc_f2i:

   244                 case bc_f2l:

   245                 case bc_d2i:

   246                 case bc_d2l:

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

   248                     break;

   249                 case bc_i2b:

   250                 case bc_i2c:

   251                 case bc_i2s:

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

   253                     break;

   254                 case bc_iconst_0:

   255                 case bc_dconst_0:

   256                 case bc_lconst_0:

   257                 case bc_fconst_0:

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

   259                     break;

   260                 case bc_iconst_1:

   261                 case bc_lconst_1:

   262                 case bc_fconst_1:

   263                 case bc_dconst_1:

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

   265                     break;

   266                 case bc_iconst_2:

   267                 case bc_fconst_2:

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

   269                     break;

   270                 case bc_iconst_3:

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

   272                     break;

   273                 case bc_iconst_4:

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

   275                     break;

   276                 case bc_iconst_5:

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

   278                     break;

   279                 case bc_ldc_w:

   280                 case bc_ldc2_w: {

   281                     int indx = readIntArg(byteCodes, i);

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

   283                     i += 2;

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

   285                     break;

   286                 }

   287                 case bc_if_icmpeq: {

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

   289                     break;

   290                 }

   291                 case bc_ifeq: {

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

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

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

   295                     i += 2;

   296                     break;

   297                 }

   298                 case bc_if_icmpne:

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

   300                     break;

   301                 case bc_if_icmplt:

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

   303                     break;

   304                 case bc_if_icmple:

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

   306                     break;

   307                 case bc_if_icmpgt:

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

   309                     break;

   310                 case bc_if_icmpge:

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

   312                     break;

   313                 case bc_goto: {

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

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

   316                     i += 2;

   317                     break;

   318                 }

   319                 case bc_invokestatic: {

   320                     int methodIndex = readIntArg(byteCodes, i);

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

   322                     boolean[] hasReturn = { false };

   323                     StringBuilder signature = new StringBuilder();

   324                     int cnt = countArgs(mi.getDescriptor(), hasReturn, signature);

   326                     if (hasReturn[0]) {

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

   328                     }

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

   330                     out.append('_');

   331                     out.append(mi.getName());

   332                     out.append(signature.toString());

   333                     out.append('(');

   334                     String sep = "";

   335                     for (int j = 0; j < cnt; j++) {

   336                         out.append(sep);

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

   338                         sep = ", ";

   339                     }

   340                     out.append(")");

   341                     if (hasReturn[0]) {

   342                         out.append(")");

   343                     }

   344                     out.append(";");

   345                     i += 2;

   346                     break;

   347                 }

   348                 case bc_new: {

   349                     int indx = readIntArg(byteCodes, i);

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

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

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

   353                     out.append("());");

   354                     i += 2;

   355                     break;

   356                 }

   357                 case bc_dup:

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

   359                     break;

   360                 case bc_bipush:

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

   362                     break;

   363                 case bc_invokevirtual:

   364                 case bc_invokespecial: {

   365                     int indx = readIntArg(byteCodes, i);

   366                     CPMethodInfo mi = (CPMethodInfo) jc.getConstantPool().get(indx);

   367                     out.append("{ var tmp = stack.pop(); tmp." + mi.getMethodName() + "(); }");

   368                     i += 2;

   369                     break;

   370                 }

   371                 case bc_getfield: {

   372                     int indx = readIntArg(byteCodes, i);

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

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

   375                     i += 2;

   376                     break;

   377                 }

   378                 case bc_getstatic: {

   379                     int indx = readIntArg(byteCodes, i);

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

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

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

   383                     i += 2;

   384                     break;

   385                 }

   386                 case bc_putstatic: {

   387                     int indx = readIntArg(byteCodes, i);

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

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

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

   391                     i += 2;

   392                     break;

   393                 }

   395             }

   396             out.append(" /*");

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

   398                 out.append(" ");

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

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

   401             }

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

   403         }

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

   405     }

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

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

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

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

   411         return i + 2;

   412     }

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

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

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

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

   418     }

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

   421         int cnt = 0;

   422         int i = 0;

   423         Boolean count = null;

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

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

   426             switch (ch) {

   427                 case '(':

   428                     count = true;

   429                     continue;

   430                 case ')':

   431                     count = false;

   432                     continue;

   433                 case 'B':

   434                 case 'C':

   435                 case 'D':

   436                 case 'F':

   437                 case 'I':

   438                 case 'J':

   439                 case 'S':

   440                 case 'Z':

   441                     if (count) {

   442                         cnt++;

   443                         sig.append(ch);

   444                     } else {

   445                         hasReturnType[0] = true;

   446                         sig.insert(0, ch);

   447                     }

   448                     continue;

   449                 case 'V':

   450                     assert !count;

   451                     hasReturnType[0] = false;

   452                     sig.insert(0, 'V');

   453                     continue;

   454                 case 'L':

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

   456                     if (count) {

   457                         cnt++;

   458                     } else {

   459                         hasReturnType[0] = true;

   460                     }

   461                     continue;

   462                 case '[':

   463                     //arrays++;

   464                     continue;

   465                 default:

   466                     break; // invalid character

   467             }

   468         }

   469         return cnt;

   470     }

   472     private void generateStaticField(Variable v) throws IOException {

   473         out.append("\nvar ")

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

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

   476     }

   477 }

author	Jaroslav Tulach <jaroslav.tulach@apidesign.org>
	Sun, 16 Sep 2012 07:28:57 +0200
changeset 9	0cab1e07e677
parent 8	82772c96ec57
child 10	e84d9314f1bc
permissions	-rw-r--r--