diff -r 45184b2f9697 -r 40f95fe90cdc vm/src/main/java/org/apidesign/vm4brwsr/ByteCodeToJavaScript.java
--- a/vm/src/main/java/org/apidesign/vm4brwsr/ByteCodeToJavaScript.java	Thu Nov 08 18:34:12 2012 +0100
+++ b/vm/src/main/java/org/apidesign/vm4brwsr/ByteCodeToJavaScript.java	Sun Nov 11 13:23:52 2012 +0100
@@ -24,35 +24,22 @@
 import java.util.List;
 import org.apidesign.bck2brwsr.core.ExtraJavaScript;
 import org.apidesign.bck2brwsr.core.JavaScriptBody;
-import org.netbeans.modules.classfile.Annotation;
-import org.netbeans.modules.classfile.AnnotationComponent;
-import org.netbeans.modules.classfile.ArrayElementValue;
-import static org.netbeans.modules.classfile.ByteCodes.*;
-import org.netbeans.modules.classfile.CPClassInfo;
-import org.netbeans.modules.classfile.CPEntry;
-import org.netbeans.modules.classfile.CPFieldInfo;
-import org.netbeans.modules.classfile.CPMethodInfo;
-import org.netbeans.modules.classfile.CPStringInfo;
-import org.netbeans.modules.classfile.ClassFile;
-import org.netbeans.modules.classfile.ClassName;
-import org.netbeans.modules.classfile.Code;
-import org.netbeans.modules.classfile.ElementValue;
-import org.netbeans.modules.classfile.Method;
-import org.netbeans.modules.classfile.Parameter;
-import org.netbeans.modules.classfile.PrimitiveElementValue;
-import org.netbeans.modules.classfile.Variable;
+import sun.tools.javap.ClassData;
+import sun.tools.javap.FieldData;
+import sun.tools.javap.MethodData;
+import static sun.tools.javap.RuntimeConstants.*;
 
 /** Translator of the code inside class files to JavaScript.
  *
  * @author Jaroslav Tulach <jtulach@netbeans.org>
  */
 public final class ByteCodeToJavaScript {
-    private final ClassFile jc;
+    private final ClassData jc;
     private final Appendable out;
     private final Collection<? super String> references;
 
     private ByteCodeToJavaScript(
-        ClassFile jc, Appendable out, Collection<? super String> references
+        ClassData jc, Appendable out, Collection<? super String> references
     ) {
         this.jc = jc;
         this.out = out;
@@ -80,7 +67,8 @@
         Collection<? super String> references,
         Collection<? super String> scripts
     ) throws IOException {
-        ClassFile jc = new ClassFile(classFile, true);
+        ClassData jc = new ClassData(classFile);
+        /*
         final ClassName extraAnn = ClassName.getClassName(ExtraJavaScript.class.getName().replace('.', '/'));
         Annotation a = jc.getAnnotation(extraAnn);
         if (a != null) {
@@ -92,28 +80,28 @@
                 return null;
             }
         }
-        
+        */
         ByteCodeToJavaScript compiler = new ByteCodeToJavaScript(
             jc, out, references
         );
         List<String> toInitilize = new ArrayList<String>();
-        for (Method m : jc.getMethods()) {
+        for (MethodData m : jc.getMethods()) {
             if (m.isStatic()) {
                 compiler.generateStaticMethod(m, toInitilize);
             } else {
                 compiler.generateInstanceMethod(m);
             }
         }
-        for (Variable v : jc.getVariables()) {
+        for (FieldData v : jc.getFields()) {
             if (v.isStatic()) {
                 compiler.generateStaticField(v);
             }
         }
         
-        final String className = jc.getName().getInternalName().replace('/', '_');
+        final String className = className(jc);
         out.append("\nfunction ").append(className);
         out.append("() {");
-        for (Variable v : jc.getVariables()) {
+        for (FieldData v : jc.getFields()) {
             if (!v.isStatic()) {
                 out.append("\n  this.fld_").
                     append(v.getName()).append(" = 0;");
@@ -124,22 +112,23 @@
             append(".prototype.$instOf_").append(className).append(") {");
         out.append("\n    return new ").append(className).append(";");
         out.append("\n  }");
-        ClassName sc = jc.getSuperClass();
+        // ClassName sc = jc.getSuperClass();
+        String sc = jc.getSuperClassName(); // with _
         if (sc != null) {
             out.append("\n  var p = ").append(className)
                .append(".prototype = ").
-                append(sc.getInternalName().replace('/', '_')).append("_proto();");
+                append(sc.replace('/', '_')).append("_proto();");
         } else {
             out.append("\n  var p = ").append(className).append(".prototype;");
         }
-        for (Method m : jc.getMethods()) {
+        for (MethodData m : jc.getMethods()) {
             if (!m.getName().contains("<init>") && !m.getName().contains("<cinit>")) {
                 compiler.generateMethodReference("\n  p.", m);
             }
         }
         out.append("\n  p.$instOf_").append(className).append(" = true;");
-        for (ClassName superInterface : jc.getInterfaces()) {
-            out.append("\n  p.$instOf_").append(superInterface.getInternalName().replace('/', '_')).append(" = true;");
+        for (String superInterface : jc.getSuperInterfaces()) {
+            out.append("\n  p.$instOf_").append(superInterface.replace('/', '_')).append(" = true;");
         }
         out.append("\n  return new ").append(className).append(";");
         out.append("\n}");
@@ -150,25 +139,25 @@
         }
         return sb.toString();
     }
-    private void generateStaticMethod(Method m, List<String> toInitilize) throws IOException {
+    private void generateStaticMethod(MethodData m, List<String> toInitilize) throws IOException {
         if (javaScriptBody(m, true)) {
             return;
         }
-        final String mn = findMethodName(m);
+        int[] argsCnt = { -1 };
+        final String mn = findMethodName(m, argsCnt);
         out.append("\nfunction ").append(
-            jc.getName().getInternalName().replace('/', '_')
+            className(jc)
         ).append('_').append(mn);
         if (mn.equals("classV")) {
-            toInitilize.add(jc.getName().getInternalName().replace('/', '_') + '_' + mn);
+            toInitilize.add(className(jc) + '_' + mn);
         }
         out.append('(');
         String space = "";
-        List<Parameter> args = m.getParameters();
-        for (int index = 0, i = 0; i < args.size(); i++) {
+        for (int index = 0, i = 0; i < argsCnt[0]; i++) {
             out.append(space);
             out.append("arg").append(String.valueOf(index));
             space = ",";
-            final String desc = findDescriptor(args.get(i).getDescriptor());
+            final String desc = null;// XXX findDescriptor(args.get(i).getDescriptor());
             if ("D".equals(desc) || "J".equals(desc)) {
                 index += 2;
             } else {
@@ -176,42 +165,42 @@
             }
         }
         out.append(") {").append("\n");
-        final Code code = m.getCode();
+        final byte[] code = m.getCode();
         if (code != null) {
-            int len = code.getMaxLocals();
-            for (int index = args.size(), i = args.size(); i < len; i++) {
+            int len = m.getMaxLocals();
+            for (int index = argsCnt[0], i = argsCnt[0]; i < len; i++) {
                 out.append("  var ");
                 out.append("arg").append(String.valueOf(i)).append(";\n");
             }
             out.append("  var stack = new Array();\n");
-            produceCode(code.getByteCodes());
+            produceCode(code);
         } else {
-            out.append("  /* no code found for ").append(m.getTypeSignature()).append(" */\n");
+            out.append("  /* no code found for ").append(m.getInternalSig()).append(" */\n");
         }
         out.append("}");
     }
     
-    private void generateMethodReference(String prefix, Method m) throws IOException {
-        final String name = findMethodName(m);
+    private void generateMethodReference(String prefix, MethodData m) throws IOException {
+        final String name = findMethodName(m, null);
         out.append(prefix).append(name).append(" = ")
-           .append(jc.getName().getInternalName().replace('/', '_'))
+           .append(className(jc))
            .append('_').append(name).append(";");
     }
     
-    private void generateInstanceMethod(Method m) throws IOException {
+    private void generateInstanceMethod(MethodData m) throws IOException {
         if (javaScriptBody(m, false)) {
             return;
         }
+        int[] argsCnt = { -1 };
         out.append("\nfunction ").append(
-            jc.getName().getInternalName().replace('/', '_')
-        ).append('_').append(findMethodName(m));
+            className(jc)
+        ).append('_').append(findMethodName(m, argsCnt));
         out.append("(arg0");
         String space = ",";
-        List<Parameter> args = m.getParameters();
-        for (int index = 1, i = 0; i < args.size(); i++) {
+        for (int index = 1, i = 0; i < argsCnt[0]; i++) {
             out.append(space);
             out.append("arg").append(String.valueOf(index));
-            final String desc = findDescriptor(args.get(i).getDescriptor());
+            final String desc = null;// XXX findDescriptor(args.get(i).getDescriptor());
             if ("D".equals(desc) || "J".equals(desc)) {
                 index += 2;
             } else {
@@ -219,17 +208,17 @@
             }
         }
         out.append(") {").append("\n");
-        final Code code = m.getCode();
+        final byte[] code = m.getCode();
         if (code != null) {
-            int len = code.getMaxLocals();
-            for (int index = args.size(), i = args.size(); i < len; i++) {
+            int len = m.getMaxLocals();
+            for (int index = argsCnt[0], i = argsCnt[0]; i < len; i++) {
                 out.append("  var ");
                 out.append("arg").append(String.valueOf(i + 1)).append(";\n");
             }
             out.append(";\n  var stack = new Array();\n");
-            produceCode(code.getByteCodes());
+            produceCode(code);
         } else {
-            out.append("  /* no code found for ").append(m.getTypeSignature()).append(" */\n");
+            out.append("  /* no code found for ").append(m.getInternalSig()).append(" */\n");
         }
         out.append("}");
     }
@@ -241,137 +230,137 @@
             out.append("    case " + i).append(": ");
             final int c = readByte(byteCodes, i);
             switch (c) {
-                case bc_aload_0:
-                case bc_iload_0:
-                case bc_lload_0:
-                case bc_fload_0:
-                case bc_dload_0:
+                case opc_aload_0:
+                case opc_iload_0:
+                case opc_lload_0:
+                case opc_fload_0:
+                case opc_dload_0:
                     out.append("stack.push(arg0);");
                     break;
-                case bc_aload_1:
-                case bc_iload_1:
-                case bc_lload_1:
-                case bc_fload_1:
-                case bc_dload_1:
+                case opc_aload_1:
+                case opc_iload_1:
+                case opc_lload_1:
+                case opc_fload_1:
+                case opc_dload_1:
                     out.append("stack.push(arg1);");
                     break;
-                case bc_aload_2:
-                case bc_iload_2:
-                case bc_lload_2:
-                case bc_fload_2:
-                case bc_dload_2:
+                case opc_aload_2:
+                case opc_iload_2:
+                case opc_lload_2:
+                case opc_fload_2:
+                case opc_dload_2:
                     out.append("stack.push(arg2);");
                     break;
-                case bc_aload_3:
-                case bc_iload_3:
-                case bc_lload_3:
-                case bc_fload_3:
-                case bc_dload_3:
+                case opc_aload_3:
+                case opc_iload_3:
+                case opc_lload_3:
+                case opc_fload_3:
+                case opc_dload_3:
                     out.append("stack.push(arg3);");
                     break;
-                case bc_iload:
-                case bc_lload:
-                case bc_fload:
-                case bc_dload:
-                case bc_aload: {
+                case opc_iload:
+                case opc_lload:
+                case opc_fload:
+                case opc_dload:
+                case opc_aload: {
                     final int indx = readByte(byteCodes, ++i);
                     out.append("stack.push(arg").append(indx + ");");
                     break;
                 }
-                case bc_istore:
-                case bc_lstore:
-                case bc_fstore:
-                case bc_dstore:
-                case bc_astore: {
+                case opc_istore:
+                case opc_lstore:
+                case opc_fstore:
+                case opc_dstore:
+                case opc_astore: {
                     final int indx = readByte(byteCodes, ++i);
-                    out.append("arg" + indx).append(" = stack.pop()");
+                    out.append("arg" + indx).append(" = stack.pop();");
                     break;
                 }
-                case bc_astore_0:
-                case bc_istore_0:
-                case bc_lstore_0:
-                case bc_fstore_0:
-                case bc_dstore_0:
+                case opc_astore_0:
+                case opc_istore_0:
+                case opc_lstore_0:
+                case opc_fstore_0:
+                case opc_dstore_0:
                     out.append("arg0 = stack.pop();");
                     break;
-                case bc_astore_1:
-                case bc_istore_1:
-                case bc_lstore_1:
-                case bc_fstore_1:
-                case bc_dstore_1:
+                case opc_astore_1:
+                case opc_istore_1:
+                case opc_lstore_1:
+                case opc_fstore_1:
+                case opc_dstore_1:
                     out.append("arg1 = stack.pop();");
                     break;
-                case bc_astore_2:
-                case bc_istore_2:
-                case bc_lstore_2:
-                case bc_fstore_2:
-                case bc_dstore_2:
+                case opc_astore_2:
+                case opc_istore_2:
+                case opc_lstore_2:
+                case opc_fstore_2:
+                case opc_dstore_2:
                     out.append("arg2 = stack.pop();");
                     break;
-                case bc_astore_3:
-                case bc_istore_3:
-                case bc_lstore_3:
-                case bc_fstore_3:
-                case bc_dstore_3:
+                case opc_astore_3:
+                case opc_istore_3:
+                case opc_lstore_3:
+                case opc_fstore_3:
+                case opc_dstore_3:
                     out.append("arg3 = stack.pop();");
                     break;
-                case bc_iadd:
-                case bc_ladd:
-                case bc_fadd:
-                case bc_dadd:
+                case opc_iadd:
+                case opc_ladd:
+                case opc_fadd:
+                case opc_dadd:
                     out.append("stack.push(stack.pop() + stack.pop());");
                     break;
-                case bc_isub:
-                case bc_lsub:
-                case bc_fsub:
-                case bc_dsub:
+                case opc_isub:
+                case opc_lsub:
+                case opc_fsub:
+                case opc_dsub:
                     out.append("{ var tmp = stack.pop(); stack.push(stack.pop() - tmp); }");
                     break;
-                case bc_imul:
-                case bc_lmul:
-                case bc_fmul:
-                case bc_dmul:
+                case opc_imul:
+                case opc_lmul:
+                case opc_fmul:
+                case opc_dmul:
                     out.append("stack.push(stack.pop() * stack.pop());");
                     break;
-                case bc_idiv:
-                case bc_ldiv:
+                case opc_idiv:
+                case opc_ldiv:
                     out.append("{ var tmp = stack.pop(); stack.push(Math.floor(stack.pop() / tmp)); }");
                     break;
-                case bc_fdiv:
-                case bc_ddiv:
+                case opc_fdiv:
+                case opc_ddiv:
                     out.append("{ var tmp = stack.pop(); stack.push(stack.pop() / tmp); }");
                     break;
-                case bc_iand:
-                case bc_land:
+                case opc_iand:
+                case opc_land:
                     out.append("stack.push(stack.pop() & stack.pop());");
                     break;
-                case bc_ior:
-                case bc_lor:
+                case opc_ior:
+                case opc_lor:
                     out.append("stack.push(stack.pop() | stack.pop());");
                     break;
-                case bc_ixor:
-                case bc_lxor:
+                case opc_ixor:
+                case opc_lxor:
                     out.append("stack.push(stack.pop() ^ stack.pop());");
                     break;
-                case bc_ineg:
-                case bc_lneg:
-                case bc_fneg:
-                case bc_dneg:
+                case opc_ineg:
+                case opc_lneg:
+                case opc_fneg:
+                case opc_dneg:
                     out.append("stack.push(- stack.pop());");
                     break;
-                case bc_ishl:
-                case bc_lshl:
+                case opc_ishl:
+                case opc_lshl:
                     out.append("{ var v = stack.pop(); stack.push(stack.pop() << v); }");
                     break;
-                case bc_ishr:
-                case bc_lshr:
+                case opc_ishr:
+                case opc_lshr:
                     out.append("{ var v = stack.pop(); stack.push(stack.pop() >> v); }");
                     break;
-                case bc_iushr:
-                case bc_lushr:
+                case opc_iushr:
+                case opc_lushr:
                     out.append("{ var v = stack.pop(); stack.push(stack.pop() >>> v); }");
                     break;
-                case bc_iinc: {
+                case opc_iinc: {
                     final int varIndx = readByte(byteCodes, ++i);
                     final int incrBy = byteCodes[++i];
                     if (incrBy == 1) {
@@ -381,181 +370,179 @@
                     }
                     break;
                 }
-                case bc_return:
+                case opc_return:
                     out.append("return;");
                     break;
-                case bc_ireturn:
-                case bc_lreturn:
-                case bc_freturn:
-                case bc_dreturn:
-                case bc_areturn:
+                case opc_ireturn:
+                case opc_lreturn:
+                case opc_freturn:
+                case opc_dreturn:
+                case opc_areturn:
                     out.append("return stack.pop();");
                     break;
-                case bc_i2l:
-                case bc_i2f:
-                case bc_i2d:
-                case bc_l2i:
+                case opc_i2l:
+                case opc_i2f:
+                case opc_i2d:
+                case opc_l2i:
                     // max int check?
-                case bc_l2f:
-                case bc_l2d:
-                case bc_f2d:
-                case bc_d2f:
+                case opc_l2f:
+                case opc_l2d:
+                case opc_f2d:
+                case opc_d2f:
                     out.append("/* number conversion */");
                     break;
-                case bc_f2i:
-                case bc_f2l:
-                case bc_d2i:
-                case bc_d2l:
+                case opc_f2i:
+                case opc_f2l:
+                case opc_d2i:
+                case opc_d2l:
                     out.append("stack.push(Math.floor(stack.pop()));");
                     break;
-                case bc_i2b:
-                case bc_i2c:
-                case bc_i2s:
+                case opc_i2b:
+                case opc_i2c:
+                case opc_i2s:
                     out.append("/* number conversion */");
                     break;
-                case bc_aconst_null:
+                case opc_aconst_null:
                     out.append("stack.push(null);");
                     break;
-                case bc_iconst_m1:
+                case opc_iconst_m1:
                     out.append("stack.push(-1);");
                     break;
-                case bc_iconst_0:
-                case bc_dconst_0:
-                case bc_lconst_0:
-                case bc_fconst_0:
+                case opc_iconst_0:
+                case opc_dconst_0:
+                case opc_lconst_0:
+                case opc_fconst_0:
                     out.append("stack.push(0);");
                     break;
-                case bc_iconst_1:
-                case bc_lconst_1:
-                case bc_fconst_1:
-                case bc_dconst_1:
+                case opc_iconst_1:
+                case opc_lconst_1:
+                case opc_fconst_1:
+                case opc_dconst_1:
                     out.append("stack.push(1);");
                     break;
-                case bc_iconst_2:
-                case bc_fconst_2:
+                case opc_iconst_2:
+                case opc_fconst_2:
                     out.append("stack.push(2);");
                     break;
-                case bc_iconst_3:
+                case opc_iconst_3:
                     out.append("stack.push(3);");
                     break;
-                case bc_iconst_4:
+                case opc_iconst_4:
                     out.append("stack.push(4);");
                     break;
-                case bc_iconst_5:
+                case opc_iconst_5:
                     out.append("stack.push(5);");
                     break;
-                case bc_ldc: {
+                case opc_ldc: {
                     int indx = readByte(byteCodes, ++i);
-                    CPEntry entry = jc.getConstantPool().get(indx);
-                    String v = encodeConstant(entry);
+                    String v = encodeConstant(indx);
                     out.append("stack.push(").append(v).append(");");
                     break;
                 }
-                case bc_ldc_w:
-                case bc_ldc2_w: {
+                case opc_ldc_w:
+                case opc_ldc2_w: {
                     int indx = readIntArg(byteCodes, i);
-                    CPEntry entry = jc.getConstantPool().get(indx);
                     i += 2;
-                    String v = encodeConstant(entry);
+                    String v = encodeConstant(indx);
                     out.append("stack.push(").append(v).append(");");
                     break;
                 }
-                case bc_lcmp:
-                case bc_fcmpl:
-                case bc_fcmpg:
-                case bc_dcmpl:
-                case bc_dcmpg: {
+                case opc_lcmp:
+                case opc_fcmpl:
+                case opc_fcmpg:
+                case opc_dcmpl:
+                case opc_dcmpg: {
                     out.append("{ var delta = stack.pop() - stack.pop(); stack.push(delta < 0 ?-1 : (delta == 0 ? 0 : 1)); }");
                     break;
                 }
-                case bc_if_acmpeq:
+                case opc_if_acmpeq:
                     i = generateIf(byteCodes, i, "===");
                     break;
-                case bc_if_acmpne:
+                case opc_if_acmpne:
                     i = generateIf(byteCodes, i, "!=");
                     break;
-                case bc_if_icmpeq: {
+                case opc_if_icmpeq: {
                     i = generateIf(byteCodes, i, "==");
                     break;
                 }
-                case bc_ifeq: {
+                case opc_ifeq: {
                     int indx = i + readIntArg(byteCodes, i);
                     out.append("if (stack.pop() == 0) { gt = " + indx);
                     out.append("; continue; }");
                     i += 2;
                     break;
                 }
-                case bc_ifne: {
+                case opc_ifne: {
                     int indx = i + readIntArg(byteCodes, i);
                     out.append("if (stack.pop() != 0) { gt = " + indx);
                     out.append("; continue; }");
                     i += 2;
                     break;
                 }
-                case bc_iflt: {
+                case opc_iflt: {
                     int indx = i + readIntArg(byteCodes, i);
                     out.append("if (stack.pop() < 0) { gt = " + indx);
                     out.append("; continue; }");
                     i += 2;
                     break;
                 }
-                case bc_ifle: {
+                case opc_ifle: {
                     int indx = i + readIntArg(byteCodes, i);
                     out.append("if (stack.pop() <= 0) { gt = " + indx);
                     out.append("; continue; }");
                     i += 2;
                     break;
                 }
-                case bc_ifgt: {
+                case opc_ifgt: {
                     int indx = i + readIntArg(byteCodes, i);
                     out.append("if (stack.pop() > 0) { gt = " + indx);
                     out.append("; continue; }");
                     i += 2;
                     break;
                 }
-                case bc_ifge: {
+                case opc_ifge: {
                     int indx = i + readIntArg(byteCodes, i);
                     out.append("if (stack.pop() >= 0) { gt = " + indx);
                     out.append("; continue; }");
                     i += 2;
                     break;
                 }
-                case bc_ifnonnull: {
+                case opc_ifnonnull: {
                     int indx = i + readIntArg(byteCodes, i);
                     out.append("if (stack.pop()) { gt = " + indx);
                     out.append("; continue; }");
                     i += 2;
                     break;
                 }
-                case bc_ifnull: {
+                case opc_ifnull: {
                     int indx = i + readIntArg(byteCodes, i);
                     out.append("if (!stack.pop()) { gt = " + indx);
                     out.append("; continue; }");
                     i += 2;
                     break;
                 }
-                case bc_if_icmpne:
+                case opc_if_icmpne:
                     i = generateIf(byteCodes, i, "!=");
                     break;
-                case bc_if_icmplt:
+                case opc_if_icmplt:
                     i = generateIf(byteCodes, i, ">");
                     break;
-                case bc_if_icmple:
+                case opc_if_icmple:
                     i = generateIf(byteCodes, i, ">=");
                     break;
-                case bc_if_icmpgt:
+                case opc_if_icmpgt:
                     i = generateIf(byteCodes, i, "<");
                     break;
-                case bc_if_icmpge:
+                case opc_if_icmpge:
                     i = generateIf(byteCodes, i, "<=");
                     break;
-                case bc_goto: {
+                case opc_goto: {
                     int indx = i + readIntArg(byteCodes, i);
                     out.append("gt = " + indx).append("; continue;");
                     i += 2;
                     break;
                 }
-                case bc_lookupswitch: {
+                case opc_lookupswitch: {
                     int table = i / 4 * 4 + 4;
                     int dflt = i + readInt4(byteCodes, table);
                     table += 4;
@@ -573,7 +560,7 @@
                     i = table - 1;
                     break;
                 }
-                case bc_tableswitch: {
+                case opc_tableswitch: {
                     int table = i / 4 * 4 + 4;
                     int dflt = i + readInt4(byteCodes, table);
                     table += 4;
@@ -592,40 +579,40 @@
                     i = table - 1;
                     break;
                 }
-                case bc_invokeinterface: {
+                case opc_invokeinterface: {
                     i = invokeVirtualMethod(byteCodes, i) + 2;
                     break;
                 }
-                case bc_invokevirtual:
+                case opc_invokevirtual:
                     i = invokeVirtualMethod(byteCodes, i);
                     break;
-                case bc_invokespecial:
+                case opc_invokespecial:
                     i = invokeStaticMethod(byteCodes, i, false);
                     break;
-                case bc_invokestatic:
+                case opc_invokestatic:
                     i = invokeStaticMethod(byteCodes, i, true);
                     break;
-                case bc_new: {
+                case opc_new: {
                     int indx = readIntArg(byteCodes, i);
-                    CPClassInfo ci = jc.getConstantPool().getClass(indx);
+                    String ci = jc.getClassName(indx);
                     out.append("stack.push(");
-                    out.append("new ").append(ci.getClassName().getInternalName().replace('/','_'));
+                    out.append("new ").append(ci.replace('/','_'));
                     out.append(");");
-                    addReference(ci.getClassName().getInternalName());
+                    addReference(ci);
                     i += 2;
                     break;
                 }
-                case bc_newarray: {
+                case opc_newarray: {
                     int type = byteCodes[i++];
                     out.append("stack.push(new Array(stack.pop()));");
                     break;
                 }
-                case bc_anewarray: {
+                case opc_anewarray: {
                     i += 2; // skip type of array
                     out.append("stack.push(new Array(stack.pop()));");
                     break;
                 }
-                case bc_multianewarray: {
+                case opc_multianewarray: {
                     i += 2;
                     int dim = readByte(byteCodes, ++i);
                     out.append("{ var a0 = new Array(stack.pop());");
@@ -645,86 +632,83 @@
                     out.append("\nstack.push(a0); }");
                     break;
                 }
-                case bc_arraylength:
+                case opc_arraylength:
                     out.append("stack.push(stack.pop().length);");
                     break;
-                case bc_iastore:
-                case bc_lastore:
-                case bc_fastore:
-                case bc_dastore:
-                case bc_aastore:
-                case bc_bastore:
-                case bc_castore:
-                case bc_sastore: {
+                case opc_iastore:
+                case opc_lastore:
+                case opc_fastore:
+                case opc_dastore:
+                case opc_aastore:
+                case opc_bastore:
+                case opc_castore:
+                case opc_sastore: {
                     out.append("{ var value = stack.pop(); var indx = stack.pop(); stack.pop()[indx] = value; }");
                     break;
                 }
-                case bc_iaload:
-                case bc_laload:
-                case bc_faload:
-                case bc_daload:
-                case bc_aaload:
-                case bc_baload:
-                case bc_caload:
-                case bc_saload: {
+                case opc_iaload:
+                case opc_laload:
+                case opc_faload:
+                case opc_daload:
+                case opc_aaload:
+                case opc_baload:
+                case opc_caload:
+                case opc_saload: {
                     out.append("{ var indx = stack.pop(); stack.push(stack.pop()[indx]); }");
                     break;
                 }
-                case bc_pop2:
+                case opc_pop2:
                     out.append("stack.pop();");
-                case bc_pop:
+                case opc_pop:
                     out.append("stack.pop();");
                     break;
-                case bc_dup:
+                case opc_dup:
                     out.append("stack.push(stack[stack.length - 1]);");
                     break;
-                case bc_bipush:
+                case opc_bipush:
                     out.append("stack.push(" + byteCodes[++i] + ");");
                     break;
-                case bc_sipush:
+                case opc_sipush:
                     out.append("stack.push(" + readIntArg(byteCodes, i) + ");");
                     i += 2;
                     break;
-                case bc_getfield: {
+                case opc_getfield: {
                     int indx = readIntArg(byteCodes, i);
-                    CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);
+                    String[] fi = jc.getFieldInfoName(indx);
                     out.append("stack.push(stack.pop().fld_").
-                        append(fi.getFieldName()).append(");");
+                        append(fi[1]).append(");");
                     i += 2;
                     break;
                 }
-                case bc_getstatic: {
+                case opc_getstatic: {
                     int indx = readIntArg(byteCodes, i);
-                    CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);
-                    final String in = fi.getClassName().getInternalName();
-                    out.append("stack.push(").append(in.replace('/', '_'));
-                    out.append('_').append(fi.getFieldName()).append(");");
+                    String[] fi = jc.getFieldInfoName(indx);
+                    out.append("stack.push(").append(fi[0].replace('/', '_'));
+                    out.append('_').append(fi[1]).append(");");
                     i += 2;
-                    addReference(in);
+                    addReference(fi[0]);
                     break;
                 }
-                case bc_putstatic: {
+                case opc_putstatic: {
                     int indx = readIntArg(byteCodes, i);
-                    CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);
-                    final String in = fi.getClassName().getInternalName();
-                    out.append(in.replace('/', '_'));
-                    out.append('_').append(fi.getFieldName()).append(" = stack.pop();");
+                    String[] fi = jc.getFieldInfoName(indx);
+                    out.append(fi[0].replace('/', '_'));
+                    out.append('_').append(fi[1]).append(" = stack.pop();");
                     i += 2;
-                    addReference(in);
+                    addReference(fi[0]);
                     break;
                 }
-                case bc_putfield: {
+                case opc_putfield: {
                     int indx = readIntArg(byteCodes, i);
-                    CPFieldInfo fi = (CPFieldInfo) jc.getConstantPool().get(indx);
+                    String[] fi = jc.getFieldInfoName(indx);
                     out.append("{ var v = stack.pop(); stack.pop().fld_")
-                       .append(fi.getFieldName()).append(" = v; }");
+                       .append(fi[1]).append(" = v; }");
                     i += 2;
                     break;
                 }
-                case bc_checkcast: {
+                case opc_checkcast: {
                     int indx = readIntArg(byteCodes, i);
-                    CPClassInfo ci = jc.getConstantPool().getClass(indx);
-                    final String type = ci.getClassName().getType();
+                    final String type = jc.getClassName(indx);
                     if (!type.startsWith("[")) {
                         // no way to check arrays right now
                         out.append("if(stack[stack.length - 1].$instOf_")
@@ -734,16 +718,16 @@
                     i += 2;
                     break;
                 }
-                case bc_instanceof: {
+                case opc_instanceof: {
                     int indx = readIntArg(byteCodes, i);
-                    CPClassInfo ci = jc.getConstantPool().getClass(indx);
+                    final String type = jc.getClassName(indx);
                     out.append("stack.push(stack.pop().$instOf_")
-                       .append(ci.getClassName().getInternalName().replace('/', '_'))
+                       .append(type.replace('/', '_'))
                        .append(" ? 1 : 0);");
                     i += 2;
                     break;
                 }
-                case bc_athrow: {
+                case opc_athrow: {
                     out.append("{ var t = stack.pop(); stack = new Array(1); stack[0] = t; throw t; }");
                     break;
                 }
@@ -861,15 +845,14 @@
         return cnt;
     }
 
-    private void generateStaticField(Variable v) throws IOException {
+    private void generateStaticField(FieldData v) throws IOException {
         out.append("\nvar ")
-           .append(jc.getName().getInternalName().replace('/', '_'))
+           .append(className(jc))
            .append('_').append(v.getName()).append(" = 0;");
     }
 
-    private String findMethodName(Method m) {
+    private String findMethodName(MethodData m, int[] cnt) {
         StringBuilder name = new StringBuilder();
-        String descr = m.getDescriptor();
         if ("<init>".equals(m.getName())) { // NOI18N
             name.append("cons"); // NOI18N
         } else if ("<clinit>".equals(m.getName())) { // NOI18N
@@ -879,26 +862,30 @@
         } 
         
         boolean hasReturn[] = { false };
-        countArgs(findDescriptor(m.getDescriptor()), hasReturn, name);
+        int argsCnt = countArgs(findDescriptor(m.getInternalSig()), hasReturn, name);
+        if (cnt != null) {
+            cnt[0] = argsCnt;
+        }
         return name.toString();
     }
 
-    private String findMethodName(CPMethodInfo mi, int[] cnt, boolean[] hasReturn) {
+    private String findMethodName(String[] mi, int[] cnt, boolean[] hasReturn) {
         StringBuilder name = new StringBuilder();
-        String descr = mi.getDescriptor();
-        if ("<init>".equals(mi.getName())) { // NOI18N
+        String descr = mi[2];//mi.getDescriptor();
+        String nm= mi[1];
+        if ("<init>".equals(nm)) { // NOI18N
             name.append("cons"); // NOI18N
         } else {
-            name.append(mi.getName());
+            name.append(nm);
         }
-        cnt[0] = countArgs(findDescriptor(mi.getDescriptor()), hasReturn, name);
+        cnt[0] = countArgs(findDescriptor(descr), hasReturn, name);
         return name.toString();
     }
 
     private int invokeStaticMethod(byte[] byteCodes, int i, boolean isStatic)
     throws IOException {
         int methodIndex = readIntArg(byteCodes, i);
-        CPMethodInfo mi = (CPMethodInfo) jc.getConstantPool().get(methodIndex);
+        String[] mi = jc.getFieldInfoName(methodIndex);
         boolean[] hasReturn = { false };
         int[] cnt = { 0 };
         String mn = findMethodName(mi, cnt, hasReturn);
@@ -910,7 +897,7 @@
         if (hasReturn[0]) {
             out.append("stack.push(");
         }
-        final String in = mi.getClassName().getInternalName();
+        final String in = mi[0];
         out.append(in.replace('/', '_'));
         if (isStatic) {
             out.append(".prototype.");
@@ -941,7 +928,7 @@
     private int invokeVirtualMethod(byte[] byteCodes, int i)
     throws IOException {
         int methodIndex = readIntArg(byteCodes, i);
-        CPMethodInfo mi = (CPMethodInfo) jc.getConstantPool().get(methodIndex);
+        String[] mi = jc.getFieldInfoName(methodIndex);
         boolean[] hasReturn = { false };
         int[] cnt = { 0 };
         String mn = findMethodName(mi, cnt, hasReturn);
@@ -992,29 +979,18 @@
         }
     }
 
-    private String encodeConstant(CPEntry entry) {
-        final String v;
-        if (entry instanceof CPClassInfo) {
-            v = "new java_lang_Class";
-        } else if (entry instanceof CPStringInfo) {
-            v = "\"" + entry.getValue().toString().
-                replace("\\", "\\\\").
-                replace("\n", "\\n").
-                replace("\r", "\\r").
-                replace("\t", "\\t").
-                replace("\"", "\\\"")
-                + "\"";
-        } else {
-            v = entry.getValue().toString();
-        }
-        return v;
+    private String encodeConstant(int entryIndex) {
+        String s = jc.stringValue(entryIndex, true);
+        return s;
     }
 
     private String findDescriptor(String d) {
         return d.replace('[', 'A');
     }
 
-    private boolean javaScriptBody(Method m, boolean isStatic) throws IOException {
+    private boolean javaScriptBody(MethodData m, boolean isStatic) throws IOException {
+        return false;
+        /*
         final ClassName extraAnn = ClassName.getClassName(JavaScriptBody.class.getName().replace('.', '/'));
         Annotation a = m.getAnnotation(extraAnn);
         if (a != null) {
@@ -1054,5 +1030,10 @@
             return true;
         }
         return false;
+        */
+    }
+    private static String className(ClassData jc) {
+        //return jc.getName().getInternalName().replace('/', '_');
+        return jc.getClassName().replace('/', '_');
     }
 }