hg/bck2brwsr: vm/src/main/java/org/apidesign/vm4brwsr/ByteCodeToJavaScript.java@f2352e0b713e

     1 /**

     2  * Back 2 Browser Bytecode Translator

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

     4  *

     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.

     8  *

     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.

    13  *

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

    20 import java.io.IOException;

    21 import java.io.InputStream;

    22 import org.apidesign.javap.AnnotationParser;

    23 import org.apidesign.javap.ClassData;

    24 import org.apidesign.javap.FieldData;

    25 import org.apidesign.javap.MethodData;

    26 import org.apidesign.javap.StackMapIterator;

    27 import static org.apidesign.javap.RuntimeConstants.*;

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

    30  *

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

    32  */

    33 public abstract class ByteCodeToJavaScript {

    34     private ClassData jc;

    35     private final Appendable out;

    37     protected ByteCodeToJavaScript(Appendable out) {

    38         this.out = out;

    39     }

    41     /* Collects additional required resources.

    42      *

    43      * @param internalClassName classes that were referenced and should be loaded in order the

    44      *   generated JavaScript code works properly. The names are in internal

    45      *   JVM form so String is <code>java/lang/String</code>.

    46      */

    47     protected abstract boolean requireReference(String internalClassName);

    49     /*

    50      * @param resourcePath name of resources to read

    51      */

    52     protected abstract void requireScript(String resourcePath);

    54     /** Allows subclasses to redefine what field a function representing a

    55      * class gets assigned. By default it returns the suggested name followed

    56      * by <code>" = "</code>;

    57      *

    58      * @param className suggested name of the class

    59      */

    60     protected String assignClass(String className) {

    61         return className + " = ";

    62     }

    64     /**

    65      * Converts a given class file to a JavaScript version.

    66      *

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

    68      * @return the initialization code for this class, if any. Otherwise <code>null</code>

    69      *

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

    71      */

    73     public String compile(InputStream classFile) throws IOException {

    74         this.jc = new ClassData(classFile);

    75         byte[] arrData = jc.findAnnotationData(true);

    76         String[] arr = findAnnotation(arrData, jc,

    77             "org.apidesign.bck2brwsr.core.ExtraJavaScript",

    78             "resource", "processByteCode"

    79         );

    80         if (arr != null) {

    81             requireScript(arr[0]);

    82             if ("0".equals(arr[1])) {

    83                 return null;

    84             }

    85         }

    86         String[] proto = findAnnotation(arrData, jc,

    87             "org.apidesign.bck2brwsr.core.JavaScriptPrototype",

    88             "container", "prototype"

    89         );

    90         StringArray toInitilize = new StringArray();

    91         final String className = className(jc);

    92         out.append("\n\n").append(assignClass(className));

    93         out.append("function CLS() {");

    94         out.append("\n  if (!CLS.prototype.$instOf_").append(className).append(") {");

    95         for (FieldData v : jc.getFields()) {

    96             if (v.isStatic()) {

    97                 out.append("\n  CLS.").append(v.getName()).append(initField(v));

    98             }

    99         }

   100         if (proto == null) {

   101             String sc = jc.getSuperClassName(); // with _

   102             out.append("\n    var p = CLS.prototype = ").

   103                 append(sc.replace('/', '_')).append("(true);");

   104             out.append("\n    var c = p;");

   105         } else {

   106             out.append("\n    var p = CLS.prototype = ").append(proto[1]).append(";");

   107             out.append("\n    var c = ").append(proto[0]).append(";");

   108         }

   109         for (MethodData m : jc.getMethods()) {

   110             byte[] onlyArr = m.findAnnotationData(true);

   111             String[] only = findAnnotation(onlyArr, jc,

   112                 "org.apidesign.bck2brwsr.core.JavaScriptOnly",

   113                 "name", "value"

   114             );

   115             if (only != null) {

   116                 if (only[0] != null && only[1] != null) {

   117                     out.append("\n    p.").append(only[0]).append(" = ")

   118                         .append(only[1]).append(";");

   119                 }

   120                 continue;

   121             }

   122             if (m.isStatic()) {

   123                 generateStaticMethod("\n    c.", m, toInitilize);

   124             } else {

   125                 generateInstanceMethod("\n    c.", m);

   126             }

   127         }

   128         out.append("\n    c.constructor = CLS;");

   129         out.append("\n    c.$instOf_").append(className).append(" = true;");

   130         for (String superInterface : jc.getSuperInterfaces()) {

   131             out.append("\n    c.$instOf_").append(superInterface.replace('/', '_')).append(" = true;");

   132         }

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

   134         out.append("\n  if (arguments.length === 0) {");

   135         out.append("\n    if (!(this instanceof CLS)) {");

   136         out.append("\n      return new CLS();");

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

   138         for (FieldData v : jc.getFields()) {

   139             byte[] onlyArr = v.findAnnotationData(true);

   140             String[] only = findAnnotation(onlyArr, jc,

   141                 "org.apidesign.bck2brwsr.core.JavaScriptOnly",

   142                 "name", "value"

   143             );

   144             if (only != null) {

   145                 if (only[0] != null && only[1] != null) {

   146                     out.append("\n    p.").append(only[0]).append(" = ")

   147                         .append(only[1]).append(";");

   148                 }

   149                 continue;

   150             }

   151             if (!v.isStatic()) {

   152                 out.append("\n    this.fld_").

   153                     append(v.getName()).append(initField(v));

   154             }

   155         }

   156         out.append("\n    return this;");

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

   158         out.append("\n  return arguments[0] ? new CLS() : CLS.prototype;");

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

   160         StringBuilder sb = new StringBuilder();

   161         for (String init : toInitilize.toArray()) {

   162             sb.append("\n").append(init).append("();");

   163         }

   164         return sb.toString();

   165     }

   166     private void generateStaticMethod(String prefix, MethodData m, StringArray toInitilize) throws IOException {

   167         if (javaScriptBody(prefix, m, true)) {

   168             return;

   169         }

   170         StringBuilder argsCnt = new StringBuilder();

   171         final String mn = findMethodName(m, argsCnt);

   172         out.append(prefix).append(mn).append(" = function");

   173         if (mn.equals("classV")) {

   174             toInitilize.add(className(jc) + "(false)." + mn);

   175         }

   176         out.append('(');

   177         String space = "";

   178         for (int index = 0, i = 0; i < argsCnt.length(); i++) {

   179             out.append(space);

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

   181             space = ",";

   182             final String desc = null;// XXX findDescriptor(args.get(i).getDescriptor());

   183             if (argsCnt.charAt(i) == '1') {

   184                 index += 2;

   185             } else {

   186                 index++;

   187             }

   188         }

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

   190         if (m.getCode() != null) {

   191             int len = m.getMaxLocals();

   192             for (int i = argsCnt.length(); i < len; i++) {

   193                 out.append("  var ");

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

   195             }

   196             produceCode(m);

   197         } else {

   198             out.append("  throw 'no code found for ").append(m.getInternalSig()).append("';\n");

   199         }

   200         out.append("};");

   201     }

   203     private void generateInstanceMethod(String prefix, MethodData m) throws IOException {

   204         if (javaScriptBody(prefix, m, false)) {

   205             return;

   206         }

   207         StringBuilder argsCnt = new StringBuilder();

   208         final String mn = findMethodName(m, argsCnt);

   209         out.append(prefix).append(mn).append(" = function");

   210         out.append("(arg0");

   211         String space = ",";

   212         for (int index = 1, i = 0; i < argsCnt.length(); i++) {

   213             out.append(space);

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

   215             if (argsCnt.charAt(i) == '1') {

   216                 index += 2;

   217             } else {

   218                 index++;

   219             }

   220         }

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

   222         if (m.getCode() != null) {

   223             int len = m.getMaxLocals();

   224             for (int i = argsCnt.length(); i < len; i++) {

   225                 out.append("  var ");

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

   227             }

   228             produceCode(m);

   229         } else {

   230             out.append("  throw 'no code found for ").append(m.getInternalSig()).append("';\n");

   231         }

   232         out.append("};");

   233     }

   235     private void produceCode(MethodData m) throws IOException {

   236         final byte[] byteCodes = m.getCode();

   237         final StackMapIterator stackMapIterator = m.createStackMapIterator();

   238         final StackToVariableMapper mapper = new StackToVariableMapper();

   240         // maxStack includes two stack positions for every pushed long / double

   241         // so this might generate more stack variables than we need

   242         final int maxStack = m.getMaxStack();

   243         if (maxStack > 0) {

   244             // TODO: generate only used stack variables

   245             for (int j = 0; j <= Variable.LAST_TYPE; ++j) {

   246                 out.append("\n  var ").append(Variable.getStackVariable(j, 0));

   247                 for (int i = 1; i < maxStack; ++i) {

   248                     out.append(", ");

   249                     out.append(Variable.getStackVariable(j, i));

   250                 }

   251                 out.append(';');

   252             }

   253         }

   255         int lastStackFrame = -1;

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

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

   259             int prev = i;

   260             stackMapIterator.advanceTo(i);

   261             if (lastStackFrame != stackMapIterator.getFrameIndex()) {

   262                 lastStackFrame = stackMapIterator.getFrameIndex();

   263                 mapper.syncWithFrameStack(stackMapIterator.getFrameStack());

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

   265             } else {

   266                 out.append("    /* " + i).append(" */ ");

   267             }

   268             final int c = readByte(byteCodes, i);

   269             switch (c) {

   270                 case opc_aload_0:

   271                     out.append(mapper.pushA()).append(" = arg0;");

   272                     break;

   273                 case opc_iload_0:

   274                     out.append(mapper.pushI()).append(" = arg0;");

   275                     break;

   276                 case opc_lload_0:

   277                     out.append(mapper.pushL()).append(" = arg0;");

   278                     break;

   279                 case opc_fload_0:

   280                     out.append(mapper.pushF()).append(" = arg0;");

   281                     break;

   282                 case opc_dload_0:

   283                     out.append(mapper.pushD()).append(" = arg0;");

   284                     break;

   285                 case opc_aload_1:

   286                     out.append(mapper.pushA()).append(" = arg1;");

   287                     break;

   288                 case opc_iload_1:

   289                     out.append(mapper.pushI()).append(" = arg1;");

   290                     break;

   291                 case opc_lload_1:

   292                     out.append(mapper.pushL()).append(" = arg1;");

   293                     break;

   294                 case opc_fload_1:

   295                     out.append(mapper.pushF()).append(" = arg1;");

   296                     break;

   297                 case opc_dload_1:

   298                     out.append(mapper.pushD()).append(" = arg1;");

   299                     break;

   300                 case opc_aload_2:

   301                     out.append(mapper.pushA()).append(" = arg2;");

   302                     break;

   303                 case opc_iload_2:

   304                     out.append(mapper.pushI()).append(" = arg2;");

   305                     break;

   306                 case opc_lload_2:

   307                     out.append(mapper.pushL()).append(" = arg2;");

   308                     break;

   309                 case opc_fload_2:

   310                     out.append(mapper.pushF()).append(" = arg2;");

   311                     break;

   312                 case opc_dload_2:

   313                     out.append(mapper.pushD()).append(" = arg2;");

   314                     break;

   315                 case opc_aload_3:

   316                     out.append(mapper.pushA()).append(" = arg3;");

   317                     break;

   318                 case opc_iload_3:

   319                     out.append(mapper.pushI()).append(" = arg3;");

   320                     break;

   321                 case opc_lload_3:

   322                     out.append(mapper.pushL()).append(" = arg3;");

   323                     break;

   324                 case opc_fload_3:

   325                     out.append(mapper.pushF()).append(" = arg3;");

   326                     break;

   327                 case opc_dload_3:

   328                     out.append(mapper.pushD()).append(" = arg3;");

   329                     break;

   330                 case opc_iload: {

   331                     final int indx = readByte(byteCodes, ++i);

   332                     out.append(mapper.pushI()).append(" = ")

   333                        .append("arg").append(indx + ";");

   334                     break;

   335                 }

   336                 case opc_lload: {

   337                     final int indx = readByte(byteCodes, ++i);

   338                     out.append(mapper.pushL()).append(" = ")

   339                        .append("arg").append(indx + ";");

   340                     break;

   341                 }

   342                 case opc_fload: {

   343                     final int indx = readByte(byteCodes, ++i);

   344                     out.append(mapper.pushF()).append(" = ")

   345                        .append("arg").append(indx + ";");

   346                     break;

   347                 }

   348                 case opc_dload: {

   349                     final int indx = readByte(byteCodes, ++i);

   350                     out.append(mapper.pushD()).append(" = ")

   351                        .append("arg").append(indx + ";");

   352                     break;

   353                 }

   354                 case opc_aload: {

   355                     final int indx = readByte(byteCodes, ++i);

   356                     out.append(mapper.pushA()).append(" = ")

   357                        .append("arg").append(indx + ";");

   358                     break;

   359                 }

   360                 case opc_istore: {

   361                     final int indx = readByte(byteCodes, ++i);

   362                     out.append("arg" + indx).append(" = ")

   363                        .append(mapper.popI()).append(';');

   364                     break;

   365                 }

   366                 case opc_lstore: {

   367                     final int indx = readByte(byteCodes, ++i);

   368                     out.append("arg" + indx).append(" = ")

   369                        .append(mapper.popL()).append(';');

   370                     break;

   371                 }

   372                 case opc_fstore: {

   373                     final int indx = readByte(byteCodes, ++i);

   374                     out.append("arg" + indx).append(" = ")

   375                        .append(mapper.popF()).append(';');

   376                     break;

   377                 }

   378                 case opc_dstore: {

   379                     final int indx = readByte(byteCodes, ++i);

   380                     out.append("arg" + indx).append(" = ")

   381                        .append(mapper.popD()).append(';');

   382                     break;

   383                 }

   384                 case opc_astore: {

   385                     final int indx = readByte(byteCodes, ++i);

   386                     out.append("arg" + indx).append(" = ")

   387                        .append(mapper.popA()).append(';');

   388                     break;

   389                 }

   390                 case opc_astore_0:

   391                     out.append("arg0 = ").append(mapper.popA()).append(';');

   392                     break;

   393                 case opc_istore_0:

   394                     out.append("arg0 = ").append(mapper.popI()).append(';');

   395                     break;

   396                 case opc_lstore_0:

   397                     out.append("arg0 = ").append(mapper.popL()).append(';');

   398                     break;

   399                 case opc_fstore_0:

   400                     out.append("arg0 = ").append(mapper.popF()).append(';');

   401                     break;

   402                 case opc_dstore_0:

   403                     out.append("arg0 = ").append(mapper.popD()).append(';');

   404                     break;

   405                 case opc_astore_1:

   406                     out.append("arg1 = ").append(mapper.popA()).append(';');

   407                     break;

   408                 case opc_istore_1:

   409                     out.append("arg1 = ").append(mapper.popI()).append(';');

   410                     break;

   411                 case opc_lstore_1:

   412                     out.append("arg1 = ").append(mapper.popL()).append(';');

   413                     break;

   414                 case opc_fstore_1:

   415                     out.append("arg1 = ").append(mapper.popF()).append(';');

   416                     break;

   417                 case opc_dstore_1:

   418                     out.append("arg1 = ").append(mapper.popD()).append(';');

   419                     break;

   420                 case opc_astore_2:

   421                     out.append("arg2 = ").append(mapper.popA()).append(';');

   422                     break;

   423                 case opc_istore_2:

   424                     out.append("arg2 = ").append(mapper.popI()).append(';');

   425                     break;

   426                 case opc_lstore_2:

   427                     out.append("arg2 = ").append(mapper.popL()).append(';');

   428                     break;

   429                 case opc_fstore_2:

   430                     out.append("arg2 = ").append(mapper.popF()).append(';');

   431                     break;

   432                 case opc_dstore_2:

   433                     out.append("arg2 = ").append(mapper.popD()).append(';');

   434                     break;

   435                 case opc_astore_3:

   436                     out.append("arg3 = ").append(mapper.popA()).append(';');

   437                     break;

   438                 case opc_istore_3:

   439                     out.append("arg3 = ").append(mapper.popI()).append(';');

   440                     break;

   441                 case opc_lstore_3:

   442                     out.append("arg3 = ").append(mapper.popL()).append(';');

   443                     break;

   444                 case opc_fstore_3:

   445                     out.append("arg3 = ").append(mapper.popF()).append(';');

   446                     break;

   447                 case opc_dstore_3:

   448                     out.append("arg3 = ").append(mapper.popD()).append(';');

   449                     break;

   450                 case opc_iadd:

   451                     out.append(mapper.getI(1)).append(" += ")

   452                        .append(mapper.popI()).append(';');

   453                     break;

   454                 case opc_ladd:

   455                     out.append(mapper.getL(1)).append(" += ")

   456                        .append(mapper.popL()).append(';');

   457                     break;

   458                 case opc_fadd:

   459                     out.append(mapper.getF(1)).append(" += ")

   460                        .append(mapper.popF()).append(';');

   461                     break;

   462                 case opc_dadd:

   463                     out.append(mapper.getD(1)).append(" += ")

   464                        .append(mapper.popD()).append(';');

   465                     break;

   466                 case opc_isub:

   467                     out.append(mapper.getI(1)).append(" -= ")

   468                        .append(mapper.popI()).append(';');

   469                     break;

   470                 case opc_lsub:

   471                     out.append(mapper.getL(1)).append(" -= ")

   472                        .append(mapper.popL()).append(';');

   473                     break;

   474                 case opc_fsub:

   475                     out.append(mapper.getF(1)).append(" -= ")

   476                        .append(mapper.popF()).append(';');

   477                     break;

   478                 case opc_dsub:

   479                     out.append(mapper.getD(1)).append(" -= ")

   480                        .append(mapper.popD()).append(';');

   481                     break;

   482                 case opc_imul:

   483                     out.append(mapper.getI(1)).append(" *= ")

   484                        .append(mapper.popI()).append(';');

   485                     break;

   486                 case opc_lmul:

   487                     out.append(mapper.getL(1)).append(" *= ")

   488                        .append(mapper.popL()).append(';');

   489                     break;

   490                 case opc_fmul:

   491                     out.append(mapper.getF(1)).append(" *= ")

   492                        .append(mapper.popF()).append(';');

   493                     break;

   494                 case opc_dmul:

   495                     out.append(mapper.getD(1)).append(" *= ")

   496                        .append(mapper.popD()).append(';');

   497                     break;

   498                 case opc_idiv:

   499                     out.append(mapper.getI(1)).append(" = ")

   500                        .append("Math.floor(").append(mapper.getI(1))

   501                        .append(" / ").append(mapper.popI()).append(");");

   502                     break;

   503                 case opc_ldiv:

   504                     out.append(mapper.getL(1)).append(" = ")

   505                        .append("Math.floor(").append(mapper.getL(1))

   506                        .append(" / ").append(mapper.popL()).append(");");

   507                     break;

   508                 case opc_fdiv:

   509                     out.append(mapper.getF(1)).append(" /= ")

   510                        .append(mapper.popF()).append(';');

   511                     break;

   512                 case opc_ddiv:

   513                     out.append(mapper.getD(1)).append(" /= ")

   514                        .append(mapper.popD()).append(';');

   515                     break;

   516                 case opc_irem:

   517                     out.append(mapper.getI(1)).append(" %= ")

   518                        .append(mapper.popI()).append(';');

   519                     break;

   520                 case opc_lrem:

   521                     out.append(mapper.getL(1)).append(" %= ")

   522                        .append(mapper.popL()).append(';');

   523                     break;

   524                 case opc_frem:

   525                     out.append(mapper.getF(1)).append(" %= ")

   526                        .append(mapper.popF()).append(';');

   527                     break;

   528                 case opc_drem:

   529                     out.append(mapper.getD(1)).append(" %= ")

   530                        .append(mapper.popD()).append(';');

   531                     break;

   532                 case opc_iand:

   533                     out.append(mapper.getI(1)).append(" &= ")

   534                        .append(mapper.popI()).append(';');

   535                     break;

   536                 case opc_land:

   537                     out.append(mapper.getL(1)).append(" &= ")

   538                        .append(mapper.popL()).append(';');

   539                     break;

   540                 case opc_ior:

   541                     out.append(mapper.getI(1)).append(" |= ")

   542                        .append(mapper.popI()).append(';');

   543                     break;

   544                 case opc_lor:

   545                     out.append(mapper.getL(1)).append(" |= ")

   546                        .append(mapper.popL()).append(';');

   547                     break;

   548                 case opc_ixor:

   549                     out.append(mapper.getI(1)).append(" ^= ")

   550                        .append(mapper.popI()).append(';');

   551                     break;

   552                 case opc_lxor:

   553                     out.append(mapper.getL(1)).append(" ^= ")

   554                        .append(mapper.popL()).append(';');

   555                     break;

   556                 case opc_ineg:

   557                     out.append(mapper.getI(0)).append(" = -")

   558                        .append(mapper.getI(0)).append(';');

   559                     break;

   560                 case opc_lneg:

   561                     out.append(mapper.getL(0)).append(" = -")

   562                        .append(mapper.getL(0)).append(';');

   563                     break;

   564                 case opc_fneg:

   565                     out.append(mapper.getF(0)).append(" = -")

   566                        .append(mapper.getF(0)).append(';');

   567                     break;

   568                 case opc_dneg:

   569                     out.append(mapper.getD(0)).append(" = -")

   570                        .append(mapper.getD(0)).append(';');

   571                     break;

   572                 case opc_ishl:

   573                     out.append(mapper.getI(1)).append(" <<= ")

   574                        .append(mapper.popI()).append(';');

   575                     break;

   576                 case opc_lshl:

   577                     out.append(mapper.getL(1)).append(" <<= ")

   578                        .append(mapper.popI()).append(';');

   579                     break;

   580                 case opc_ishr:

   581                     out.append(mapper.getI(1)).append(" >>= ")

   582                        .append(mapper.popI()).append(';');

   583                     break;

   584                 case opc_lshr:

   585                     out.append(mapper.getL(1)).append(" >>= ")

   586                        .append(mapper.popI()).append(';');

   587                     break;

   588                 case opc_iushr:

   589                     out.append(mapper.getI(1)).append(" >>>= ")

   590                        .append(mapper.popI()).append(';');

   591                     break;

   592                 case opc_lushr:

   593                     out.append(mapper.getL(1)).append(" >>>= ")

   594                        .append(mapper.popI()).append(';');

   595                     break;

   596                 case opc_iinc: {

   597                     final int varIndx = readByte(byteCodes, ++i);

   598                     final int incrBy = byteCodes[++i];

   599                     if (incrBy == 1) {

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

   601                     } else {

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

   603                     }

   604                     break;

   605                 }

   606                 case opc_return:

   607                     out.append("return;");

   608                     break;

   609                 case opc_ireturn:

   610                     out.append("return ").append(mapper.popI()).append(';');

   611                     break;

   612                 case opc_lreturn:

   613                     out.append("return ").append(mapper.popL()).append(';');

   614                     break;

   615                 case opc_freturn:

   616                     out.append("return ").append(mapper.popF()).append(';');

   617                     break;

   618                 case opc_dreturn:

   619                     out.append("return ").append(mapper.popD()).append(';');

   620                     break;

   621                 case opc_areturn:

   622                     out.append("return ").append(mapper.popA()).append(';');

   623                     break;

   624                 case opc_i2l: {

   625                     final Variable v = mapper.popI();

   626                     out.append(mapper.pushL()).append(" = ")

   627                        .append(v).append(';');

   628                     break;

   629                 }

   630                 case opc_i2f: {

   631                     final Variable v = mapper.popI();

   632                     out.append(mapper.pushF()).append(" = ")

   633                        .append(v).append(';');

   634                     break;

   635                 }

   636                 case opc_i2d: {

   637                     final Variable v = mapper.popI();

   638                     out.append(mapper.pushD()).append(" = ")

   639                        .append(v).append(';');

   640                     break;

   641                 }

   642                 case opc_l2i: {

   643                     final Variable v = mapper.popL();

   644                     out.append(mapper.pushI()).append(" = ")

   645                        .append(v).append(';');

   646                     break;

   647                 }

   648                     // max int check?

   649                 case opc_l2f: {

   650                     final Variable v = mapper.popL();

   651                     out.append(mapper.pushF()).append(" = ")

   652                        .append(v).append(';');

   653                     break;

   654                 }

   655                 case opc_l2d: {

   656                     final Variable v = mapper.popL();

   657                     out.append(mapper.pushD()).append(" = ")

   658                        .append(v).append(';');

   659                     break;

   660                 }

   661                 case opc_f2d: {

   662                     final Variable v = mapper.popF();

   663                     out.append(mapper.pushD()).append(" = ")

   664                        .append(v).append(';');

   665                     break;

   666                 }

   667                 case opc_d2f: {

   668                     final Variable v = mapper.popD();

   669                     out.append(mapper.pushF()).append(" = ")

   670                        .append(v).append(';');

   671                     break;

   672                 }

   673                 case opc_f2i: {

   674                     final Variable v = mapper.popF();

   675                     out.append(mapper.pushI()).append(" = ")

   676                        .append("Math.floor(").append(v).append(");");

   677                     break;

   678                 }

   679                 case opc_f2l: {

   680                     final Variable v = mapper.popF();

   681                     out.append(mapper.pushL()).append(" = ")

   682                        .append("Math.floor(").append(v).append(");");

   683                     break;

   684                 }

   685                 case opc_d2i: {

   686                     final Variable v = mapper.popD();

   687                     out.append(mapper.pushI()).append(" = ")

   688                        .append("Math.floor(").append(v).append(");");

   689                     break;

   690                 }

   691                 case opc_d2l: {

   692                     final Variable v = mapper.popD();

   693                     out.append(mapper.pushL()).append(" = ")

   694                        .append("Math.floor(").append(v).append(");");

   695                     break;

   696                 }

   697                 case opc_i2b:

   698                 case opc_i2c:

   699                 case opc_i2s:

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

   701                     break;

   702                 case opc_aconst_null:

   703                     out.append(mapper.pushA()).append(" = null;");

   704                     break;

   705                 case opc_iconst_m1:

   706                     out.append(mapper.pushI()).append(" = -1;");

   707                     break;

   708                 case opc_iconst_0:

   709                     out.append(mapper.pushI()).append(" = 0;");

   710                     break;

   711                 case opc_dconst_0:

   712                     out.append(mapper.pushD()).append(" = 0;");

   713                     break;

   714                 case opc_lconst_0:

   715                     out.append(mapper.pushL()).append(" = 0;");

   716                     break;

   717                 case opc_fconst_0:

   718                     out.append(mapper.pushF()).append(" = 0;");

   719                     break;

   720                 case opc_iconst_1:

   721                     out.append(mapper.pushI()).append(" = 1;");

   722                     break;

   723                 case opc_lconst_1:

   724                     out.append(mapper.pushL()).append(" = 1;");

   725                     break;

   726                 case opc_fconst_1:

   727                     out.append(mapper.pushF()).append(" = 1;");

   728                     break;

   729                 case opc_dconst_1:

   730                     out.append(mapper.pushD()).append(" = 1;");

   731                     break;

   732                 case opc_iconst_2:

   733                     out.append(mapper.pushI()).append(" = 2;");

   734                     break;

   735                 case opc_fconst_2:

   736                     out.append(mapper.pushF()).append(" = 2;");

   737                     break;

   738                 case opc_iconst_3:

   739                     out.append(mapper.pushI()).append(" = 3;");

   740                     break;

   741                 case opc_iconst_4:

   742                     out.append(mapper.pushI()).append(" = 4;");

   743                     break;

   744                 case opc_iconst_5:

   745                     out.append(mapper.pushI()).append(" = 5;");

   746                     break;

   747                 case opc_ldc: {

   748                     int indx = readByte(byteCodes, ++i);

   749                     String v = encodeConstant(indx);

   750                     int type = constantToVariableType(jc.getTag(indx));

   751                     out.append(mapper.pushT(type)).append(" = ")

   752                        .append(v).append(';');

   753                     break;

   754                 }

   755                 case opc_ldc_w:

   756                 case opc_ldc2_w: {

   757                     int indx = readIntArg(byteCodes, i);

   758                     i += 2;

   759                     String v = encodeConstant(indx);

   760                     int type = constantToVariableType(jc.getTag(indx));

   761                     out.append(mapper.pushT(type)).append(" = ")

   762                        .append(v).append(';');

   763                     break;

   764                 }

   765                 case opc_lcmp:

   766                     generateCmp(mapper.popL(), mapper.popL(), mapper.pushI());

   767                     break;

   768                 case opc_fcmpl:

   769                 case opc_fcmpg:

   770                     generateCmp(mapper.popF(), mapper.popF(), mapper.pushI());

   771                     break;

   772                 case opc_dcmpl:

   773                 case opc_dcmpg:

   774                     generateCmp(mapper.popD(), mapper.popD(), mapper.pushI());

   775                     break;

   776                 case opc_if_acmpeq:

   777                     i = generateIf(byteCodes, i, mapper.popA(), mapper.popA(),

   778                                    "===");

   779                     break;

   780                 case opc_if_acmpne:

   781                     i = generateIf(byteCodes, i, mapper.popA(), mapper.popA(),

   782                                    "!=");

   783                     break;

   784                 case opc_if_icmpeq: {

   785                     i = generateIf(byteCodes, i, mapper.popI(), mapper.popI(),

   786                                    "==");

   787                     break;

   788                 }

   789                 case opc_ifeq: {

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

   791                     out.append("if (").append(mapper.popI())

   792                                       .append(" == 0) { gt = " + indx);

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

   794                     i += 2;

   795                     break;

   796                 }

   797                 case opc_ifne: {

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

   799                     out.append("if (").append(mapper.popI())

   800                                       .append(" != 0) { gt = " + indx);

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

   802                     i += 2;

   803                     break;

   804                 }

   805                 case opc_iflt: {

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

   807                     out.append("if (").append(mapper.popI())

   808                                       .append(" < 0) { gt = " + indx);

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

   810                     i += 2;

   811                     break;

   812                 }

   813                 case opc_ifle: {

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

   815                     out.append("if (").append(mapper.popI())

   816                                       .append(" <= 0) { gt = " + indx);

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

   818                     i += 2;

   819                     break;

   820                 }

   821                 case opc_ifgt: {

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

   823                     out.append("if (").append(mapper.popI())

   824                                       .append(" > 0) { gt = " + indx);

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

   826                     i += 2;

   827                     break;

   828                 }

   829                 case opc_ifge: {

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

   831                     out.append("if (").append(mapper.popI())

   832                                       .append(" >= 0) { gt = " + indx);

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

   834                     i += 2;

   835                     break;

   836                 }

   837                 case opc_ifnonnull: {

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

   839                     out.append("if (").append(mapper.popA())

   840                                       .append(" !== null) { gt = " + indx);

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

   842                     i += 2;

   843                     break;

   844                 }

   845                 case opc_ifnull: {

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

   847                     out.append("if (").append(mapper.popA())

   848                                       .append(" === null) { gt = " + indx);

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

   850                     i += 2;

   851                     break;

   852                 }

   853                 case opc_if_icmpne:

   854                     i = generateIf(byteCodes, i, mapper.popI(), mapper.popI(),

   855                                    "!=");

   856                     break;

   857                 case opc_if_icmplt:

   858                     i = generateIf(byteCodes, i, mapper.popI(), mapper.popI(),

   859                                    "<");

   860                     break;

   861                 case opc_if_icmple:

   862                     i = generateIf(byteCodes, i, mapper.popI(), mapper.popI(),

   863                                    "<=");

   864                     break;

   865                 case opc_if_icmpgt:

   866                     i = generateIf(byteCodes, i, mapper.popI(), mapper.popI(),

   867                                    ">");

   868                     break;

   869                 case opc_if_icmpge:

   870                     i = generateIf(byteCodes, i, mapper.popI(), mapper.popI(),

   871                                    ">=");

   872                     break;

   873                 case opc_goto: {

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

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

   876                     i += 2;

   877                     break;

   878                 }

   879                 case opc_lookupswitch: {

   880                     int table = i / 4 * 4 + 4;

   881                     int dflt = i + readInt4(byteCodes, table);

   882                     table += 4;

   883                     int n = readInt4(byteCodes, table);

   884                     table += 4;

   885                     out.append("switch (").append(mapper.popI()).append(") {\n");

   886                     while (n-- > 0) {

   887                         int cnstnt = readInt4(byteCodes, table);

   888                         table += 4;

   889                         int offset = i + readInt4(byteCodes, table);

   890                         table += 4;

   891                         out.append("  case " + cnstnt).append(": gt = " + offset).append("; continue;\n");

   892                     }

   893                     out.append("  default: gt = " + dflt).append("; continue;\n}");

   894                     i = table - 1;

   895                     break;

   896                 }

   897                 case opc_tableswitch: {

   898                     int table = i / 4 * 4 + 4;

   899                     int dflt = i + readInt4(byteCodes, table);

   900                     table += 4;

   901                     int low = readInt4(byteCodes, table);

   902                     table += 4;

   903                     int high = readInt4(byteCodes, table);

   904                     table += 4;

   905                     out.append("switch (").append(mapper.popI()).append(") {\n");

   906                     while (low <= high) {

   907                         int offset = i + readInt4(byteCodes, table);

   908                         table += 4;

   909                         out.append("  case " + low).append(": gt = " + offset).append("; continue;\n");

   910                         low++;

   911                     }

   912                     out.append("  default: gt = " + dflt).append("; continue;\n}");

   913                     i = table - 1;

   914                     break;

   915                 }

   916                 case opc_invokeinterface: {

   917                     i = invokeVirtualMethod(byteCodes, i, mapper) + 2;

   918                     break;

   919                 }

   920                 case opc_invokevirtual:

   921                     i = invokeVirtualMethod(byteCodes, i, mapper);

   922                     break;

   923                 case opc_invokespecial:

   924                     i = invokeStaticMethod(byteCodes, i, mapper, false);

   925                     break;

   926                 case opc_invokestatic:

   927                     i = invokeStaticMethod(byteCodes, i, mapper, true);

   928                     break;

   929                 case opc_new: {

   930                     int indx = readIntArg(byteCodes, i);

   931                     String ci = jc.getClassName(indx);

   932                     out.append(mapper.pushA()).append(" = ");

   933                     out.append("new ").append(ci.replace('/','_'));

   934                     out.append(';');

   935                     addReference(ci);

   936                     i += 2;

   937                     break;

   938                 }

   939                 case opc_newarray: {

   940                     ++i; // skip type of array

   941                     final Variable v = mapper.popI();

   942                     out.append(mapper.pushA()).append(" = ")

   943                        .append("new Array(").append(v).append(").fillNulls();");

   944                     break;

   945                 }

   946                 case opc_anewarray: {

   947                     i += 2; // skip type of array

   948                     final Variable v = mapper.popI();

   949                     out.append(mapper.pushA()).append(" = ")

   950                        .append("new Array(").append(v).append(").fillNulls();");

   951                     break;

   952                 }

   953                 case opc_multianewarray: {

   954                     i += 2;

   955                     int dim = readByte(byteCodes, ++i);

   956                     out.append("{ var a0 = new Array(").append(mapper.popI())

   957                        .append(").fillNulls();");

   958                     for (int d = 1; d < dim; d++) {

   959                         out.append("\n  var l" + d).append(" = ")

   960                            .append(mapper.popI()).append(';');

   961                         out.append("\n  for (var i" + d).append (" = 0; i" + d).

   962                             append(" < a" + (d - 1)).

   963                             append(".length; i" + d).append("++) {");

   964                         out.append("\n    var a" + d).

   965                             append (" = new Array(l" + d).append(").fillNulls();");

   966                         out.append("\n    a" + (d - 1)).append("[i" + d).append("] = a" + d).

   967                             append(";");

   968                     }

   969                     for (int d = 1; d < dim; d++) {

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

   971                     }

   972                     out.append("\n").append(mapper.pushA()).append(" = a0; }");

   973                     break;

   974                 }

   975                 case opc_arraylength: {

   976                     final Variable v = mapper.popA();

   977                     out.append(mapper.pushI()).append(" = ")

   978                        .append(v).append(".length;");

   979                     break;

   980                 }

   981                 case opc_lastore: {

   982                     out.append(mapper.getA(2)).append('[')

   983                                               .append(mapper.getI(1))

   984                                               .append(']')

   985                        .append(" = ").append(mapper.getL(0)).append(';');

   986                     mapper.pop(3);

   987                     break;

   988                 }

   989                 case opc_fastore: {

   990                     out.append(mapper.getA(2)).append('[')

   991                                               .append(mapper.getI(1))

   992                                               .append(']')

   993                        .append(" = ").append(mapper.getF(0)).append(';');

   994                     mapper.pop(3);

   995                     break;

   996                 }

   997                 case opc_dastore: {

   998                     out.append(mapper.getA(2)).append('[')

   999                                               .append(mapper.getI(1))

  1000                                               .append(']')

  1001                        .append(" = ").append(mapper.getD(0)).append(';');

  1002                     mapper.pop(3);

  1003                     break;

  1004                 }

  1005                 case opc_aastore: {

  1006                     out.append(mapper.getA(2)).append('[')

  1007                                               .append(mapper.getI(1))

  1008                                               .append(']')

  1009                        .append(" = ").append(mapper.getA(0)).append(';');

  1010                     mapper.pop(3);

  1011                     break;

  1012                 }

  1013                 case opc_iastore:

  1014                 case opc_bastore:

  1015                 case opc_castore:

  1016                 case opc_sastore: {

  1017                     out.append(mapper.getA(2)).append('[')

  1018                                               .append(mapper.getI(1))

  1019                                               .append(']')

  1020                        .append(" = ").append(mapper.getI(0)).append(';');

  1021                     mapper.pop(3);

  1022                     break;

  1023                 }

  1024                 case opc_laload: {

  1025                     final Variable vidx = mapper.popI();

  1026                     final Variable varr = mapper.popA();

  1027                     out.append(mapper.pushL()).append(" = ")

  1028                        .append(varr).append('[').append(vidx).append("];");

  1029                     break;

  1030                 }

  1031                 case opc_faload: {

  1032                     final Variable vidx = mapper.popI();

  1033                     final Variable varr = mapper.popA();

  1034                     out.append(mapper.pushF()).append(" = ")

  1035                        .append(varr).append('[').append(vidx).append("];");

  1036                     break;

  1037                 }

  1038                 case opc_daload: {

  1039                     final Variable vidx = mapper.popI();

  1040                     final Variable varr = mapper.popA();

  1041                     out.append(mapper.pushD()).append(" = ")

  1042                        .append(varr).append('[').append(vidx).append("];");

  1043                     break;

  1044                 }

  1045                 case opc_aaload: {

  1046                     final Variable vidx = mapper.popI();

  1047                     final Variable varr = mapper.popA();

  1048                     out.append(mapper.pushA()).append(" = ")

  1049                        .append(varr).append('[').append(vidx).append("];");

  1050                     break;

  1051                 }

  1052                 case opc_iaload:

  1053                 case opc_baload:

  1054                 case opc_caload:

  1055                 case opc_saload: {

  1056                     final Variable vidx = mapper.popI();

  1057                     final Variable varr = mapper.popA();

  1058                     out.append(mapper.pushI()).append(" = ")

  1059                        .append(varr).append('[').append(vidx).append("];");

  1060                     break;

  1061                 }

  1062                 case opc_pop:

  1063                 case opc_pop2:

  1064                     mapper.pop(1);

  1065                     out.append("/* pop */");

  1066                     break;

  1067                 case opc_dup: {

  1068                     final Variable v = mapper.get(0);

  1069                     out.append(mapper.pushT(v.getType())).append(" = ")

  1070                        .append(v).append(';');

  1071                     break;

  1072                 }

  1073                 case opc_dup2: {

  1074                     if (mapper.get(0).isCategory2()) {

  1075                         final Variable v = mapper.get(0);

  1076                         out.append(mapper.pushT(v.getType())).append(" = ")

  1077                            .append(v).append(';');

  1078                     } else {

  1079                         final Variable v1 = mapper.get(0);

  1080                         final Variable v2 = mapper.get(1);

  1081                         out.append("{ ");

  1082                         out.append(mapper.pushT(v2.getType())).append(" = ")

  1083                            .append(v2).append("; ");

  1084                         out.append(mapper.pushT(v1.getType())).append(" = ")

  1085                            .append(v1).append("; ");

  1086                         out.append('}');

  1087                     }

  1088                     break;

  1089                 }

  1090                 case opc_dup_x1: {

  1091                     final Variable vi1 = mapper.pop();

  1092                     final Variable vi2 = mapper.pop();

  1093                     final Variable vo3 = mapper.pushT(vi1.getType());

  1094                     final Variable vo2 = mapper.pushT(vi2.getType());

  1095                     final Variable vo1 = mapper.pushT(vi1.getType());

  1097                     out.append("{ ");

  1098                     out.append(vo1).append(" = ").append(vi1).append("; ");

  1099                     out.append(vo2).append(" = ").append(vi2).append("; ");

  1100                     out.append(vo3).append(" = ").append(vo1).append("; ");

  1101                     out.append('}');

  1102                     break;

  1103                 }

  1104                 case opc_dup_x2: {

  1105                     if (mapper.get(1).isCategory2()) {

  1106                         final Variable vi1 = mapper.pop();

  1107                         final Variable vi2 = mapper.pop();

  1108                         final Variable vo3 = mapper.pushT(vi1.getType());

  1109                         final Variable vo2 = mapper.pushT(vi2.getType());

  1110                         final Variable vo1 = mapper.pushT(vi1.getType());

  1112                         out.append("{ ");

  1113                         out.append(vo1).append(" = ").append(vi1).append("; ");

  1114                         out.append(vo2).append(" = ").append(vi2).append("; ");

  1115                         out.append(vo3).append(" = ").append(vo1).append("; ");

  1116                         out.append('}');

  1117                     } else {

  1118                         final Variable vi1 = mapper.pop();

  1119                         final Variable vi2 = mapper.pop();

  1120                         final Variable vi3 = mapper.pop();

  1121                         final Variable vo4 = mapper.pushT(vi1.getType());

  1122                         final Variable vo3 = mapper.pushT(vi3.getType());

  1123                         final Variable vo2 = mapper.pushT(vi2.getType());

  1124                         final Variable vo1 = mapper.pushT(vi1.getType());

  1126                         out.append("{ ");

  1127                         out.append(vo1).append(" = ").append(vi1).append("; ");

  1128                         out.append(vo2).append(" = ").append(vi2).append("; ");

  1129                         out.append(vo3).append(" = ").append(vi3).append("; ");

  1130                         out.append(vo4).append(" = ").append(vo1).append("; ");

  1131                         out.append('}');

  1132                     }

  1133                     break;

  1134                 }

  1135                 case opc_bipush:

  1136                     out.append(mapper.pushI()).append(" = ")

  1137                        .append(Integer.toString(byteCodes[++i])).append(';');

  1138                     break;

  1139                 case opc_sipush:

  1140                     out.append(mapper.pushI()).append(" = ")

  1141                        .append(Integer.toString(readIntArg(byteCodes, i)))

  1142                        .append(';');

  1143                     i += 2;

  1144                     break;

  1145                 case opc_getfield: {

  1146                     int indx = readIntArg(byteCodes, i);

  1147                     String[] fi = jc.getFieldInfoName(indx);

  1148                     final int type = fieldToVariableType(fi[2].charAt(0));

  1149                     final Variable v = mapper.popA();

  1150                     out.append(mapper.pushT(type)).append(" = ")

  1151                        .append(v).append(".fld_").append(fi[1]).append(';');

  1152                     i += 2;

  1153                     break;

  1154                 }

  1155                 case opc_getstatic: {

  1156                     int indx = readIntArg(byteCodes, i);

  1157                     String[] fi = jc.getFieldInfoName(indx);

  1158                     final int type = fieldToVariableType(fi[2].charAt(0));

  1159                     out.append(mapper.pushT(type)).append(" = ")

  1160                        .append(fi[0].replace('/', '_'))

  1161                        .append('.').append(fi[1]).append(';');

  1162                     i += 2;

  1163                     addReference(fi[0]);

  1164                     break;

  1165                 }

  1166                 case opc_putfield: {

  1167                     int indx = readIntArg(byteCodes, i);

  1168                     String[] fi = jc.getFieldInfoName(indx);

  1169                     final int type = fieldToVariableType(fi[2].charAt(0));

  1170                     final Variable v = mapper.popT(type);

  1171                     out.append(mapper.popA()).append(".fld_").append(fi[1])

  1172                        .append(" = ").append(v).append(';');

  1173                     i += 2;

  1174                     break;

  1175                 }

  1176                 case opc_putstatic: {

  1177                     int indx = readIntArg(byteCodes, i);

  1178                     String[] fi = jc.getFieldInfoName(indx);

  1179                     final int type = fieldToVariableType(fi[2].charAt(0));

  1180                     out.append(fi[0].replace('/', '_'));

  1181                     out.append('.').append(fi[1]).append(" = ")

  1182                        .append(mapper.popT(type)).append(';');

  1183                     i += 2;

  1184                     addReference(fi[0]);

  1185                     break;

  1186                 }

  1187                 case opc_checkcast: {

  1188                     int indx = readIntArg(byteCodes, i);

  1189                     final String type = jc.getClassName(indx);

  1190                     if (!type.startsWith("[")) {

  1191                         // no way to check arrays right now

  1192                         out.append("if (").append(mapper.getA(0))

  1193                            .append(".$instOf_").append(type.replace('/', '_'))

  1194                            .append(" != 1) throw {};"); // XXX proper exception

  1195                     }

  1196                     i += 2;

  1197                     break;

  1198                 }

  1199                 case opc_instanceof: {

  1200                     int indx = readIntArg(byteCodes, i);

  1201                     final String type = jc.getClassName(indx);

  1202                     final Variable v = mapper.popA();

  1203                     out.append(mapper.pushI()).append(" = ")

  1204                        .append(v).append(".$instOf_")

  1205                                  .append(type.replace('/', '_'))

  1206                        .append(" ? 1 : 0;");

  1207                     i += 2;

  1208                     break;

  1209                 }

  1210                 case opc_athrow: {

  1211                     final Variable v = mapper.popA();

  1212                     mapper.clear();

  1214                     out.append("{ ");

  1215                     out.append(mapper.pushA()).append(" = ")

  1216                        .append(v).append("; ");

  1217                     out.append("throw ").append(v).append("; ");

  1218                     out.append('}');

  1220                     break;

  1221                 }

  1223                 case opc_monitorenter: {

  1224                     out.append("/* monitor enter */");

  1225                     mapper.popA();

  1226                     break;

  1227                 }

  1229                 case opc_monitorexit: {

  1230                     out.append("/* monitor exit */");

  1231                     mapper.popA();

  1232                     break;

  1233                 }

  1235                 default: {

  1236                     out.append("throw 'unknown bytecode " + c + "';");

  1237                 }

  1239             }

  1240             out.append(" //");

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

  1242                 out.append(" ");

  1243                 final int cc = readByte(byteCodes, j);

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

  1245             }

  1246             out.append("\n");

  1247         }

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

  1249     }

  1251     private int generateIf(byte[] byteCodes, int i,

  1252                            final Variable v2, final Variable v1,

  1253                            final String test) throws IOException {

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

  1255         out.append("if (").append(v1)

  1256            .append(' ').append(test).append(' ')

  1257            .append(v2).append(") { gt = " + indx)

  1258            .append("; continue; }");

  1259         return i + 2;

  1260     }

  1262     private void generateCmp(Variable v2, Variable v1, Variable vr)

  1263             throws IOException {

  1264         out.append(vr).append(" = ")

  1265            .append('(').append(v1).append(" == ").append(v2).append(')')

  1266            .append(" ? 0")

  1267            .append(" : ((").append(v1).append(" < ").append(v2).append(')')

  1268            .append(" ? -1 : 1);");

  1269     }

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

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

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

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

  1275     }

  1276     private int readInt4(byte[] byteCodes, int offsetInstruction) {

  1277         final int d = byteCodes[offsetInstruction + 0] << 24;

  1278         final int c = byteCodes[offsetInstruction + 1] << 16;

  1279         final int b = byteCodes[offsetInstruction + 2] << 8;

  1280         final int a = byteCodes[offsetInstruction + 3];

  1281         return (d & 0xff000000) | (c & 0xff0000) | (b & 0xff00) | (a & 0xff);

  1282     }

  1283     private int readByte(byte[] byteCodes, int offsetInstruction) {

  1284         return byteCodes[offsetInstruction] & 0xff;

  1285     }

  1287     private static void countArgs(String descriptor, char[] returnType, StringBuilder sig, StringBuilder cnt) {

  1288         int i = 0;

  1289         Boolean count = null;

  1290         boolean array = false;

  1291         int firstPos = sig.length();

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

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

  1294             switch (ch) {

  1295                 case '(':

  1296                     count = true;

  1297                     continue;

  1298                 case ')':

  1299                     count = false;

  1300                     continue;

  1301                 case 'A':

  1302                     array = true;

  1303                     break;

  1304                 case 'B':

  1305                 case 'C':

  1306                 case 'D':

  1307                 case 'F':

  1308                 case 'I':

  1309                 case 'J':

  1310                 case 'S':

  1311                 case 'Z':

  1312                     if (count) {

  1313                         if (array) {

  1314                             sig.append('A');

  1315                         }

  1316                         sig.append(ch);

  1317                         if (ch == 'J' || ch == 'D') {

  1318                             cnt.append('1');

  1319                         } else {

  1320                             cnt.append('0');

  1321                         }

  1322                     } else {

  1323                         sig.insert(firstPos, ch);

  1324                         if (array) {

  1325                             returnType[0] = '[';

  1326                             sig.insert(firstPos, 'A');

  1327                         } else {

  1328                             returnType[0] = ch;

  1329                         }

  1330                     }

  1331                     array = false;

  1332                     continue;

  1333                 case 'V':

  1334                     assert !count;

  1335                     returnType[0] = 'V';

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

  1337                     continue;

  1338                 case 'L':

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

  1340                     if (count) {

  1341                         if (array) {

  1342                             sig.append('A');

  1343                         }

  1344                         sig.append(ch);

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

  1346                         cnt.append('0');

  1347                     } else {

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

  1349                         sig.insert(firstPos, ch);

  1350                         if (array) {

  1351                             sig.insert(firstPos, 'A');

  1352                         }

  1353                         returnType[0] = 'L';

  1354                     }

  1355                     i = next + 1;

  1356                     continue;

  1357                 case '[':

  1358                     //arrays++;

  1359                     continue;

  1360                 default:

  1361                     break; // invalid character

  1362             }

  1363         }

  1364     }

  1366     private String findMethodName(MethodData m, StringBuilder cnt) {

  1367         StringBuilder name = new StringBuilder();

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

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

  1370         } else if ("<clinit>".equals(m.getName())) { // NOI18N

  1371             name.append("class"); // NOI18N

  1372         } else {

  1373             name.append(m.getName());

  1374         }

  1376         countArgs(findDescriptor(m.getInternalSig()), new char[1], name, cnt);

  1377         return name.toString();

  1378     }

  1380     private String findMethodName(String[] mi, StringBuilder cnt, char[] returnType) {

  1381         StringBuilder name = new StringBuilder();

  1382         String descr = mi[2];//mi.getDescriptor();

  1383         String nm= mi[1];

  1384         if ("<init>".equals(nm)) { // NOI18N

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

  1386         } else {

  1387             name.append(nm);

  1388         }

  1389         countArgs(findDescriptor(descr), returnType, name, cnt);

  1390         return name.toString();

  1391     }

  1393     private int invokeStaticMethod(byte[] byteCodes, int i, final StackToVariableMapper mapper, boolean isStatic)

  1394     throws IOException {

  1395         int methodIndex = readIntArg(byteCodes, i);

  1396         String[] mi = jc.getFieldInfoName(methodIndex);

  1397         char[] returnType = { 'V' };

  1398         StringBuilder cnt = new StringBuilder();

  1399         String mn = findMethodName(mi, cnt, returnType);

  1401         final int numArguments = isStatic ? cnt.length() : cnt.length() + 1;

  1402         final Variable[] vars = new Variable[numArguments];

  1404         for (int j = numArguments - 1; j >= 0; --j) {

  1405             vars[j] = mapper.pop();

  1406         }

  1408         if (returnType[0] != 'V') {

  1409             out.append(mapper.pushT(fieldToVariableType(returnType[0])))

  1410                .append(" = ");

  1411         }

  1413         final String in = mi[0];

  1414         out.append(in.replace('/', '_'));

  1415         out.append("(false).");

  1416         out.append(mn);

  1417         out.append('(');

  1418         if (numArguments > 0) {

  1419             out.append(vars[0]);

  1420             for (int j = 1; j < numArguments; ++j) {

  1421                 out.append(", ");

  1422                 out.append(vars[j]);

  1423             }

  1424         }

  1425         out.append(");");

  1426         i += 2;

  1427         addReference(in);

  1428         return i;

  1429     }

  1430     private int invokeVirtualMethod(byte[] byteCodes, int i, final StackToVariableMapper mapper)

  1431     throws IOException {

  1432         int methodIndex = readIntArg(byteCodes, i);

  1433         String[] mi = jc.getFieldInfoName(methodIndex);

  1434         char[] returnType = { 'V' };

  1435         StringBuilder cnt = new StringBuilder();

  1436         String mn = findMethodName(mi, cnt, returnType);

  1438         final int numArguments = cnt.length() + 1;

  1439         final Variable[] vars = new Variable[numArguments];

  1441         for (int j = numArguments - 1; j >= 0; --j) {

  1442             vars[j] = mapper.pop();

  1443         }

  1445         if (returnType[0] != 'V') {

  1446             out.append(mapper.pushT(fieldToVariableType(returnType[0])))

  1447                .append(" = ");

  1448         }

  1450         out.append(vars[0]).append('.');

  1451         out.append(mn);

  1452         out.append('(');

  1453         out.append(vars[0]);

  1454         for (int j = 1; j < numArguments; ++j) {

  1455             out.append(", ");

  1456             out.append(vars[j]);

  1457         }

  1458         out.append(");");

  1459         i += 2;

  1460         return i;

  1461     }

  1463     private void addReference(String cn) throws IOException {

  1464         if (requireReference(cn)) {

  1465             out.append(" /* needs ").append(cn).append(" */");

  1466         }

  1467     }

  1469     private void outType(String d, StringBuilder out) {

  1470         int arr = 0;

  1471         while (d.charAt(0) == '[') {

  1472             out.append('A');

  1473             d = d.substring(1);

  1474         }

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

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

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

  1478         } else {

  1479             out.append(d);

  1480         }

  1481     }

  1483     private String encodeConstant(int entryIndex) {

  1484         String s = jc.stringValue(entryIndex, true);

  1485         return s;

  1486     }

  1488     private String findDescriptor(String d) {

  1489         return d.replace('[', 'A');

  1490     }

  1492     private boolean javaScriptBody(String prefix, MethodData m, boolean isStatic) throws IOException {

  1493         byte[] arr = m.findAnnotationData(true);

  1494         if (arr == null) {

  1495             return false;

  1496         }

  1497         final String jvmType = "Lorg/apidesign/bck2brwsr/core/JavaScriptBody;";

  1498         class P extends AnnotationParser {

  1499             int cnt;

  1500             String[] args = new String[30];

  1501             String body;

  1503             @Override

  1504             protected void visitAttr(String type, String attr, String value) {

  1505                 if (type.equals(jvmType)) {

  1506                     if ("body".equals(attr)) {

  1507                         body = value;

  1508                     } else if ("args".equals(attr)) {

  1509                         args[cnt++] = value;

  1510                     } else {

  1511                         throw new IllegalArgumentException(attr);

  1512                     }

  1513                 }

  1514             }

  1515         }

  1516         P p = new P();

  1517         p.parse(arr, jc);

  1518         if (p.body == null) {

  1519             return false;

  1520         }

  1521         StringBuilder cnt = new StringBuilder();

  1522         out.append(prefix).append(findMethodName(m, cnt));

  1523         out.append(" = function(");

  1524         String space;

  1525         int index;

  1526         if (!isStatic) {

  1527             out.append(p.args[0]);

  1528             space = ",";

  1529             index = 1;

  1530         } else {

  1531             space = "";

  1532             index = 0;

  1533         }

  1534         for (int i = 0; i < cnt.length(); i++) {

  1535             out.append(space);

  1536             out.append(p.args[index]);

  1537             index++;

  1538             space = ",";

  1539         }

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

  1541         out.append(p.body);

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

  1543         return true;

  1544     }

  1545     private static String className(ClassData jc) {

  1546         //return jc.getName().getInternalName().replace('/', '_');

  1547         return jc.getClassName().replace('/', '_');

  1548     }

  1550     private static String[] findAnnotation(

  1551         byte[] arr, ClassData cd, final String className,

  1552         final String... attrNames

  1553     ) throws IOException {

  1554         if (arr == null) {

  1555             return null;

  1556         }

  1557         final String[] values = new String[attrNames.length];

  1558         final boolean[] found = { false };

  1559         final String jvmType = "L" + className.replace('.', '/') + ";";

  1560         AnnotationParser ap = new AnnotationParser() {

  1561             @Override

  1562             protected void visitAttr(String type, String attr, String value) {

  1563                 if (type.equals(jvmType)) {

  1564                     found[0] = true;

  1565                     for (int i = 0; i < attrNames.length; i++) {

  1566                         if (attrNames[i].equals(attr)) {

  1567                             values[i] = value;

  1568                         }

  1569                     }

  1570                 }

  1571             }

  1573         };

  1574         ap.parse(arr, cd);

  1575         return found[0] ? values : null;

  1576     }

  1578     private CharSequence initField(FieldData v) {

  1579         final String is = v.getInternalSig();

  1580         if (is.length() == 1) {

  1581             switch (is.charAt(0)) {

  1582                 case 'S':

  1583                 case 'J':

  1584                 case 'B':

  1585                 case 'Z':

  1586                 case 'C':

  1587                 case 'I': return " = 0;";

  1588                 case 'F':

  1589                 case 'D': return " = 0.0;";

  1590                 default:

  1591                     throw new IllegalStateException(is);

  1592             }

  1593         }

  1594         return " = null;";

  1595     }

  1597     private static int constantToVariableType(final byte constantTag) {

  1598         switch (constantTag) {

  1599             case CONSTANT_INTEGER:

  1600                 return Variable.TYPE_INT;

  1601             case CONSTANT_FLOAT:

  1602                 return Variable.TYPE_FLOAT;

  1603             case CONSTANT_LONG:

  1604                 return Variable.TYPE_LONG;

  1605             case CONSTANT_DOUBLE:

  1606                 return Variable.TYPE_DOUBLE;

  1608             case CONSTANT_CLASS:

  1609             case CONSTANT_UTF8:

  1610             case CONSTANT_UNICODE:

  1611             case CONSTANT_STRING:

  1612                 return Variable.TYPE_REF;

  1614             case CONSTANT_FIELD:

  1615             case CONSTANT_METHOD:

  1616             case CONSTANT_INTERFACEMETHOD:

  1617             case CONSTANT_NAMEANDTYPE:

  1618                 /* unclear how to handle for now */

  1619             default:

  1620                 throw new IllegalStateException("Unhandled constant tag");

  1621         }

  1622     }

  1624     private static int fieldToVariableType(final char fieldType) {

  1625         switch (fieldType) {

  1626             case 'B':

  1627             case 'C':

  1628             case 'S':

  1629             case 'Z':

  1630             case 'I':

  1631                 return Variable.TYPE_INT;

  1632             case 'J':

  1633                 return Variable.TYPE_LONG;

  1634             case 'F':

  1635                 return Variable.TYPE_FLOAT;

  1636             case 'D':

  1637                 return Variable.TYPE_DOUBLE;

  1638             case 'L':

  1639             case '[':

  1640                 return Variable.TYPE_REF;

  1642             default:

  1643                 throw new IllegalStateException("Unhandled field type");

  1644         }

  1645     }

  1646 }

author	Lubomir Nerad <lubomir.nerad@oracle.com>
	Fri, 07 Dec 2012 15:02:35 +0100
branch	registers
changeset 281	f2352e0b713e
parent 242	8bd4adaf6590
child 282	a98d6c5a545e
permissions	-rw-r--r--