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

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

    23 import java.util.List;

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

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

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

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

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

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

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

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

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

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

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

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

    37  *

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

    39  */

    40 public final class ByteCodeToJavaScript {

    41     private final ClassFile jc;

    42     private final Appendable out;

    43     private final Collection<? super String> references;

    45     private ByteCodeToJavaScript(

    46         ClassFile jc, Appendable out, Collection<? super String> references

    47     ) {

    48         this.jc = jc;

    49         this.out = out;

    50         this.references = references;

    51     }

    53     /**

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

    55      *

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

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

    58      * @param references a write only collection where the system adds list of

    59      *   other classes that were referenced and should be loaded in order the

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

    61      *   JVM form so String is <code>java/lang/String</code>. Can be <code>null</code>

    62      *   if one is not interested in knowing references

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

    64      */

    66     public static void compile(

    67         InputStream classFile, Appendable out,

    68         Collection<? super String> references

    69     ) throws IOException {

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

    71         ByteCodeToJavaScript compiler = new ByteCodeToJavaScript(

    72             jc, out, references

    73         );

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

    75             if (m.isStatic()) {

    76                 compiler.generateStaticMethod(m);

    77             } else {

    78                 compiler.generateInstanceMethod(m);

    79             }

    80         }

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

    82             if (v.isStatic()) {

    83                 compiler.generateStaticField(v);

    84             }

    85         }

    87         final String className = jc.getName().getInternalName().replace('/', '_');

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

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

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

    91             if (!m.isStatic()) {

    92                 compiler.generateMethodReference(m);

    93             }

    94         }

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

    96             if (!v.isStatic()) {

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

    98             }

    99         }

   100         out.append("\n  this.$instOf_").append(className).append(" = true;");

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

   102         ClassName sc = jc.getSuperClass();

   103         if (sc != null) {

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

   105                .append(".prototype = new ").append(sc.getInternalName().replace('/', '_'));

   106         }

   107     }

   108     private void generateStaticMethod(Method m) throws IOException {

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

   110             jc.getName().getInternalName().replace('/', '_')

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

   112         out.append('(');

   113         String space = "";

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

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

   116             out.append(space);

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

   118             space = ",";

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

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

   121                 index += 2;

   122             } else {

   123                 index++;

   124             }

   125         }

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

   127         final Code code = m.getCode();

   128         if (code != null) {

   129             int len = code.getMaxLocals();

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

   131                 out.append("  var ");

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

   133             }

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

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

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

   137             produceCode(code.getByteCodes());

   138         } else {

   139             out.append("  /* no code found for ").append(m.getTypeSignature()).append(" */\n");

   140         }

   141         out.append("}");

   142     }

   144     private void generateMethodReference(Method m) throws IOException {

   145         final String name = findMethodName(m);

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

   147            .append(jc.getName().getInternalName().replace('/', '_'))

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

   149     }

   151     private void generateInstanceMethod(Method m) throws IOException {

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

   153             jc.getName().getInternalName().replace('/', '_')

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

   155         out.append("(arg0");

   156         String space = ",";

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

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

   159             out.append(space);

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

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

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

   163                 index += 2;

   164             } else {

   165                 index++;

   166             }

   167         }

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

   169         final Code code = m.getCode();

   170         if (code != null) {

   171             int len = code.getMaxLocals();

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

   173                 out.append("  var ");

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

   175             }

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

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

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

   179             produceCode(code.getByteCodes());

   180         } else {

   181             out.append("  /* no code found for ").append(m.getTypeSignature()).append(" */\n");

   182         }

   183         out.append("}");

   184     }

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

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

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

   189             int prev = i;

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

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

   192             switch (c) {

   193                 case bc_aload_0:

   194                 case bc_iload_0:

   195                 case bc_lload_0:

   196                 case bc_fload_0:

   197                 case bc_dload_0:

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

   199                     break;

   200                 case bc_aload_1:

   201                 case bc_iload_1:

   202                 case bc_lload_1:

   203                 case bc_fload_1:

   204                 case bc_dload_1:

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

   206                     break;

   207                 case bc_aload_2:

   208                 case bc_iload_2:

   209                 case bc_lload_2:

   210                 case bc_fload_2:

   211                 case bc_dload_2:

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

   213                     break;

   214                 case bc_aload_3:

   215                 case bc_iload_3:

   216                 case bc_lload_3:

   217                 case bc_fload_3:

   218                 case bc_dload_3:

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

   220                     break;

   221                 case bc_iload:

   222                 case bc_lload:

   223                 case bc_fload:

   224                 case bc_dload:

   225                 case bc_aload: {

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

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

   228                     break;

   229                 }

   230                 case bc_astore_0:

   231                 case bc_istore_0:

   232                 case bc_lstore_0:

   233                 case bc_fstore_0:

   234                 case bc_dstore_0:

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

   236                     break;

   237                 case bc_astore_1:

   238                 case bc_istore_1:

   239                 case bc_lstore_1:

   240                 case bc_fstore_1:

   241                 case bc_dstore_1:

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

   243                     break;

   244                 case bc_astore_2:

   245                 case bc_istore_2:

   246                 case bc_lstore_2:

   247                 case bc_fstore_2:

   248                 case bc_dstore_2:

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

   250                     break;

   251                 case bc_astore_3:

   252                 case bc_istore_3:

   253                 case bc_lstore_3:

   254                 case bc_fstore_3:

   255                 case bc_dstore_3:

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

   257                     break;

   258                 case bc_iadd:

   259                 case bc_ladd:

   260                 case bc_fadd:

   261                 case bc_dadd:

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

   263                     break;

   264                 case bc_isub:

   265                 case bc_lsub:

   266                 case bc_fsub:

   267                 case bc_dsub:

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

   269                     break;

   270                 case bc_imul:

   271                 case bc_lmul:

   272                 case bc_fmul:

   273                 case bc_dmul:

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

   275                     break;

   276                 case bc_idiv:

   277                 case bc_ldiv:

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

   279                     break;

   280                 case bc_fdiv:

   281                 case bc_ddiv:

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

   283                     break;

   284                 case bc_iand:

   285                 case bc_land:

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

   287                     break;

   288                 case bc_ior:

   289                 case bc_lor:

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

   291                     break;

   292                 case bc_ixor:

   293                 case bc_lxor:

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

   295                     break;

   296                 case bc_iinc: {

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

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

   299                     if (incrBy == 1) {

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

   301                     } else {

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

   303                     }

   304                     break;

   305                 }

   306                 case bc_return:

   307                     out.append("return;");

   308                     break;

   309                 case bc_ireturn:

   310                 case bc_lreturn:

   311                 case bc_freturn:

   312                 case bc_dreturn:

   313                 case bc_areturn:

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

   315                     break;

   316                 case bc_i2l:

   317                 case bc_i2f:

   318                 case bc_i2d:

   319                 case bc_l2i:

   320                     // max int check?

   321                 case bc_l2f:

   322                 case bc_l2d:

   323                 case bc_f2d:

   324                 case bc_d2f:

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

   326                     break;

   327                 case bc_f2i:

   328                 case bc_f2l:

   329                 case bc_d2i:

   330                 case bc_d2l:

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

   332                     break;

   333                 case bc_i2b:

   334                 case bc_i2c:

   335                 case bc_i2s:

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

   337                     break;

   338                 case bc_iconst_0:

   339                 case bc_dconst_0:

   340                 case bc_lconst_0:

   341                 case bc_fconst_0:

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

   343                     break;

   344                 case bc_iconst_1:

   345                 case bc_lconst_1:

   346                 case bc_fconst_1:

   347                 case bc_dconst_1:

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

   349                     break;

   350                 case bc_iconst_2:

   351                 case bc_fconst_2:

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

   353                     break;

   354                 case bc_iconst_3:

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

   356                     break;

   357                 case bc_iconst_4:

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

   359                     break;

   360                 case bc_iconst_5:

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

   362                     break;

   363                 case bc_ldc_w:

   364                 case bc_ldc2_w: {

   365                     int indx = readIntArg(byteCodes, i);

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

   367                     i += 2;

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

   369                     break;

   370                 }

   371                 case bc_if_icmpeq: {

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

   373                     break;

   374                 }

   375                 case bc_ifeq: {

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

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

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

   379                     i += 2;

   380                     break;

   381                 }

   382                 case bc_ifnonnull: {

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

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

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

   386                     i += 2;

   387                     break;

   388                 }

   389                 case bc_ifnull: {

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

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

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

   393                     i += 2;

   394                     break;

   395                 }

   396                 case bc_if_icmpne:

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

   398                     break;

   399                 case bc_if_icmplt:

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

   401                     break;

   402                 case bc_if_icmple:

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

   404                     break;

   405                 case bc_if_icmpgt:

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

   407                     break;

   408                 case bc_if_icmpge:

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

   410                     break;

   411                 case bc_goto: {

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

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

   414                     i += 2;

   415                     break;

   416                 }

   417                 case bc_invokeinterface:

   418                 case bc_invokevirtual:

   419                     i = invokeVirtualMethod(byteCodes, i);

   420                     break;

   421                 case bc_invokespecial:

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

   423                     break;

   424                 case bc_invokestatic:

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

   426                     break;

   427                 case bc_new: {

   428                     int indx = readIntArg(byteCodes, i);

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

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

   431                     out.append("new ").append(ci.getClassName().getInternalName().replace('/','_'));

   432                     out.append(");");

   433                     addReference(ci.getClassName().getInternalName());

   434                     i += 2;

   435                     break;

   436                 }

   437                 case bc_dup:

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

   439                     break;

   440                 case bc_bipush:

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

   442                     break;

   443                 case bc_getfield: {

   444                     int indx = readIntArg(byteCodes, i);

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

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

   447                     i += 2;

   448                     break;

   449                 }

   450                 case bc_getstatic: {

   451                     int indx = readIntArg(byteCodes, i);

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

   453                     final String in = fi.getClassName().getInternalName();

   454                     out.append("stack.push(").append(in.replace('/', '_'));

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

   456                     i += 2;

   457                     addReference(in);

   458                     break;

   459                 }

   460                 case bc_putstatic: {

   461                     int indx = readIntArg(byteCodes, i);

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

   463                     final String in = fi.getClassName().getInternalName();

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

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

   466                     i += 2;

   467                     addReference(in);

   468                     break;

   469                 }

   470                 case bc_putfield: {

   471                     int indx = readIntArg(byteCodes, i);

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

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

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

   475                     i += 2;

   476                     break;

   477                 }

   478                 case bc_instanceof: {

   479                     int indx = readIntArg(byteCodes, i);

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

   481                     out.append("stack.push(stack.pop().$instOf_")

   482                        .append(ci.getClassName().getInternalName().replace('/', '_'))

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

   484                     i += 2;

   485                 }

   487             }

   488             out.append(" /*");

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

   490                 out.append(" ");

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

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

   493             }

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

   495         }

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

   497     }

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

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

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

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

   503         return i + 2;

   504     }

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

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

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

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

   510     }

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

   513         int cnt = 0;

   514         int i = 0;

   515         Boolean count = null;

   516         int firstPos = sig.length();

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

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

   519             switch (ch) {

   520                 case '(':

   521                     count = true;

   522                     continue;

   523                 case ')':

   524                     count = false;

   525                     continue;

   526                 case 'B':

   527                 case 'C':

   528                 case 'D':

   529                 case 'F':

   530                 case 'I':

   531                 case 'J':

   532                 case 'S':

   533                 case 'Z':

   534                     if (count) {

   535                         cnt++;

   536                         sig.append(ch);

   537                     } else {

   538                         hasReturnType[0] = true;

   539                         sig.insert(firstPos, ch);

   540                     }

   541                     continue;

   542                 case 'V':

   543                     assert !count;

   544                     hasReturnType[0] = false;

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

   546                     continue;

   547                 case 'L':

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

   549                     if (count) {

   550                         cnt++;

   551                         sig.append(ch);

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

   553                     } else {

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

   555                         sig.insert(firstPos, ch);

   556                         hasReturnType[0] = true;

   557                     }

   558                     i = next + 1;

   559                     continue;

   560                 case '[':

   561                     //arrays++;

   562                     continue;

   563                 default:

   564                     break; // invalid character

   565             }

   566         }

   567         return cnt;

   568     }

   570     private void generateStaticField(Variable v) throws IOException {

   571         out.append("\nvar ")

   572            .append(jc.getName().getInternalName().replace('/', '_'))

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

   574     }

   576     private String findMethodName(Method m) {

   577         StringBuilder tmp = new StringBuilder();

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

   579             tmp.append("consV"); // NOI18N

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

   581             tmp.append("classV"); // NOI18N

   582         } else {

   583             tmp.append(m.getName());

   584             outType(m.getReturnType(), tmp);

   585         }

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

   587         for (Parameter t : args) {

   588             outType(t.getDescriptor(), tmp);

   589         }

   590         return tmp.toString();

   591     }

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

   594         StringBuilder name = new StringBuilder();

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

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

   597         } else {

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

   599         }

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

   601         return name.toString();

   602     }

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

   605     throws IOException {

   606         int methodIndex = readIntArg(byteCodes, i);

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

   608         boolean[] hasReturn = { false };

   609         int[] cnt = { 0 };

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

   611         out.append("{ ");

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

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

   614         }

   616         if (hasReturn[0]) {

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

   618         }

   619         final String in = mi.getClassName().getInternalName();

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

   621         out.append('_');

   622         out.append(mn);

   623         out.append('(');

   624         String sep = "";

   625         if (!isStatic) {

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

   627             sep = ", ";

   628         }

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

   630             out.append(sep);

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

   632             sep = ", ";

   633         }

   634         out.append(")");

   635         if (hasReturn[0]) {

   636             out.append(")");

   637         }

   638         out.append("; }");

   639         i += 2;

   640         addReference(in);

   641         return i;

   642     }

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

   644     throws IOException {

   645         int methodIndex = readIntArg(byteCodes, i);

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

   647         boolean[] hasReturn = { false };

   648         int[] cnt = { 0 };

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

   650         out.append("{ ");

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

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

   653         }

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

   655         if (hasReturn[0]) {

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

   657         }

   658         out.append("self.");

   659         out.append(mn);

   660         out.append('(');

   661         out.append("self");

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

   663             out.append(", ");

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

   665         }

   666         out.append(")");

   667         if (hasReturn[0]) {

   668             out.append(")");

   669         }

   670         out.append("; }");

   671         i += 2;

   672         return i;

   673     }

   675     private void addReference(String cn) {

   676         if (references != null) {

   677             references.add(cn);

   678         }

   679     }

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

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

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

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

   685         } else {

   686             out.append(d);

   687         }

   688     }

   689 }

author	Jaroslav Tulach <jaroslav.tulach@apidesign.org>
	Thu, 20 Sep 2012 14:35:21 +0200
changeset 19	2291e553464a
parent 18	361b76189f8d
child 20	0e7dd9e2e31e
permissions	-rw-r--r--