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

     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         }

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

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

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

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

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

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

    93             if (!m.isStatic()) {

    94                 compiler.generateMethodReference(m);

    95             }

    96         }

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

    98             if (!v.isStatic()) {

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

   100             }

   101         }

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

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

   104         ClassName sc = jc.getSuperClass();

   105         if (sc != null) {

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

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

   108         }

   109     }

   110     private void generateStaticMethod(Method m) throws IOException {

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

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

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

   114         out.append('(');

   115         String space = "";

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

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

   118             out.append(space);

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

   120             space = ",";

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

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

   123                 index += 2;

   124             } else {

   125                 index++;

   126             }

   127         }

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

   129         final Code code = m.getCode();

   130         if (code != null) {

   131             int len = code.getMaxLocals();

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

   133                 out.append("  var ");

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

   135             }

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

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

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

   139             produceCode(code.getByteCodes());

   140         } else {

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

   142         }

   143         out.append("}");

   144     }

   146     private void generateMethodReference(Method m) throws IOException {

   147         final String name = findMethodName(m);

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

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

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

   151     }

   153     private void generateInstanceMethod(Method m) throws IOException {

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

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

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

   157         out.append("(arg0");

   158         String space = ",";

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

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

   161             out.append(space);

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

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

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

   165                 index += 2;

   166             } else {

   167                 index++;

   168             }

   169         }

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

   171         final Code code = m.getCode();

   172         if (code != null) {

   173             int len = code.getMaxLocals();

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

   175                 out.append("  var ");

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

   177             }

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

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

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

   181             produceCode(code.getByteCodes());

   182         } else {

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

   184         }

   185         out.append("}");

   186     }

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

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

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

   191             int prev = i;

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

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

   194             switch (c) {

   195                 case bc_aload_0:

   196                 case bc_iload_0:

   197                 case bc_lload_0:

   198                 case bc_fload_0:

   199                 case bc_dload_0:

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

   201                     break;

   202                 case bc_aload_1:

   203                 case bc_iload_1:

   204                 case bc_lload_1:

   205                 case bc_fload_1:

   206                 case bc_dload_1:

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

   208                     break;

   209                 case bc_aload_2:

   210                 case bc_iload_2:

   211                 case bc_lload_2:

   212                 case bc_fload_2:

   213                 case bc_dload_2:

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

   215                     break;

   216                 case bc_aload_3:

   217                 case bc_iload_3:

   218                 case bc_lload_3:

   219                 case bc_fload_3:

   220                 case bc_dload_3:

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

   222                     break;

   223                 case bc_iload:

   224                 case bc_lload:

   225                 case bc_fload:

   226                 case bc_dload:

   227                 case bc_aload: {

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

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

   230                     break;

   231                 }

   232                 case bc_astore_0:

   233                 case bc_istore_0:

   234                 case bc_lstore_0:

   235                 case bc_fstore_0:

   236                 case bc_dstore_0:

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

   238                     break;

   239                 case bc_astore_1:

   240                 case bc_istore_1:

   241                 case bc_lstore_1:

   242                 case bc_fstore_1:

   243                 case bc_dstore_1:

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

   245                     break;

   246                 case bc_astore_2:

   247                 case bc_istore_2:

   248                 case bc_lstore_2:

   249                 case bc_fstore_2:

   250                 case bc_dstore_2:

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

   252                     break;

   253                 case bc_astore_3:

   254                 case bc_istore_3:

   255                 case bc_lstore_3:

   256                 case bc_fstore_3:

   257                 case bc_dstore_3:

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

   259                     break;

   260                 case bc_iadd:

   261                 case bc_ladd:

   262                 case bc_fadd:

   263                 case bc_dadd:

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

   265                     break;

   266                 case bc_isub:

   267                 case bc_lsub:

   268                 case bc_fsub:

   269                 case bc_dsub:

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

   271                     break;

   272                 case bc_imul:

   273                 case bc_lmul:

   274                 case bc_fmul:

   275                 case bc_dmul:

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

   277                     break;

   278                 case bc_idiv:

   279                 case bc_ldiv:

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

   281                     break;

   282                 case bc_fdiv:

   283                 case bc_ddiv:

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

   285                     break;

   286                 case bc_iand:

   287                 case bc_land:

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

   289                     break;

   290                 case bc_ior:

   291                 case bc_lor:

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

   293                     break;

   294                 case bc_ixor:

   295                 case bc_lxor:

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

   297                     break;

   298                 case bc_iinc: {

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

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

   301                     if (incrBy == 1) {

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

   303                     } else {

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

   305                     }

   306                     break;

   307                 }

   308                 case bc_return:

   309                     out.append("return;");

   310                     break;

   311                 case bc_ireturn:

   312                 case bc_lreturn:

   313                 case bc_freturn:

   314                 case bc_dreturn:

   315                 case bc_areturn:

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

   317                     break;

   318                 case bc_i2l:

   319                 case bc_i2f:

   320                 case bc_i2d:

   321                 case bc_l2i:

   322                     // max int check?

   323                 case bc_l2f:

   324                 case bc_l2d:

   325                 case bc_f2d:

   326                 case bc_d2f:

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

   328                     break;

   329                 case bc_f2i:

   330                 case bc_f2l:

   331                 case bc_d2i:

   332                 case bc_d2l:

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

   334                     break;

   335                 case bc_i2b:

   336                 case bc_i2c:

   337                 case bc_i2s:

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

   339                     break;

   340                 case bc_iconst_0:

   341                 case bc_dconst_0:

   342                 case bc_lconst_0:

   343                 case bc_fconst_0:

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

   345                     break;

   346                 case bc_iconst_1:

   347                 case bc_lconst_1:

   348                 case bc_fconst_1:

   349                 case bc_dconst_1:

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

   351                     break;

   352                 case bc_iconst_2:

   353                 case bc_fconst_2:

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

   355                     break;

   356                 case bc_iconst_3:

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

   358                     break;

   359                 case bc_iconst_4:

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

   361                     break;

   362                 case bc_iconst_5:

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

   364                     break;

   365                 case bc_ldc_w:

   366                 case bc_ldc2_w: {

   367                     int indx = readIntArg(byteCodes, i);

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

   369                     i += 2;

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

   371                     break;

   372                 }

   373                 case bc_if_icmpeq: {

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

   375                     break;

   376                 }

   377                 case bc_ifeq: {

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

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

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

   381                     i += 2;

   382                     break;

   383                 }

   384                 case bc_ifnonnull: {

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

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

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

   388                     i += 2;

   389                     break;

   390                 }

   391                 case bc_ifnull: {

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

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

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

   395                     i += 2;

   396                     break;

   397                 }

   398                 case bc_if_icmpne:

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

   400                     break;

   401                 case bc_if_icmplt:

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

   403                     break;

   404                 case bc_if_icmple:

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

   406                     break;

   407                 case bc_if_icmpgt:

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

   409                     break;

   410                 case bc_if_icmpge:

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

   412                     break;

   413                 case bc_goto: {

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

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

   416                     i += 2;

   417                     break;

   418                 }

   419                 case bc_invokeinterface:

   420                 case bc_invokevirtual:

   421                     i = invokeVirtualMethod(byteCodes, i);

   422                     break;

   423                 case bc_invokespecial:

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

   425                     break;

   426                 case bc_invokestatic:

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

   428                     break;

   429                 case bc_new: {

   430                     int indx = readIntArg(byteCodes, i);

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

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

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

   434                     out.append(");");

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

   436                     i += 2;

   437                     break;

   438                 }

   439                 case bc_dup:

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

   441                     break;

   442                 case bc_bipush:

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

   444                     break;

   445                 case bc_getfield: {

   446                     int indx = readIntArg(byteCodes, i);

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

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

   449                     i += 2;

   450                     break;

   451                 }

   452                 case bc_getstatic: {

   453                     int indx = readIntArg(byteCodes, i);

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

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

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

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

   458                     i += 2;

   459                     addReference(in);

   460                     break;

   461                 }

   462                 case bc_putstatic: {

   463                     int indx = readIntArg(byteCodes, i);

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

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

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

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

   468                     i += 2;

   469                     addReference(in);

   470                     break;

   471                 }

   472                 case bc_putfield: {

   473                     int indx = readIntArg(byteCodes, i);

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

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

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

   477                     i += 2;

   478                     break;

   479                 }

   480                 case bc_instanceof: {

   481                     int indx = readIntArg(byteCodes, i);

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

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

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

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

   486                     i += 2;

   487                 }

   489             }

   490             out.append(" /*");

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

   492                 out.append(" ");

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

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

   495             }

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

   497         }

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

   499     }

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

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

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

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

   505         return i + 2;

   506     }

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

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

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

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

   512     }

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

   515         int cnt = 0;

   516         int i = 0;

   517         Boolean count = null;

   518         int firstPos = sig.length();

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

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

   521             switch (ch) {

   522                 case '(':

   523                     count = true;

   524                     continue;

   525                 case ')':

   526                     count = false;

   527                     continue;

   528                 case 'B':

   529                 case 'C':

   530                 case 'D':

   531                 case 'F':

   532                 case 'I':

   533                 case 'J':

   534                 case 'S':

   535                 case 'Z':

   536                     if (count) {

   537                         cnt++;

   538                         sig.append(ch);

   539                     } else {

   540                         hasReturnType[0] = true;

   541                         sig.insert(firstPos, ch);

   542                     }

   543                     continue;

   544                 case 'V':

   545                     assert !count;

   546                     hasReturnType[0] = false;

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

   548                     continue;

   549                 case 'L':

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

   551                     if (count) {

   552                         cnt++;

   553                         sig.append(ch);

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

   555                     } else {

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

   557                         sig.insert(firstPos, ch);

   558                         hasReturnType[0] = true;

   559                     }

   560                     i = next + 1;

   561                     continue;

   562                 case '[':

   563                     //arrays++;

   564                     continue;

   565                 default:

   566                     break; // invalid character

   567             }

   568         }

   569         return cnt;

   570     }

   572     private void generateStaticField(Variable v) throws IOException {

   573         out.append("\nvar ")

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

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

   576     }

   578     private String findMethodName(Method m) {

   579         StringBuilder out = new StringBuilder();

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

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

   582         } else {

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

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

   585         }

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

   587         for (Parameter t : args) {

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

   589         }

   590         return out.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:20:01 +0200
changeset 18	361b76189f8d
parent 17	cb0cfba1b863
child 19	2291e553464a
permissions	-rw-r--r--