Java tutorial
/* * Copyright (c) 2012, Codename One and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Codename One designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Codename One through http://www.codenameone.com/ if you * need additional information or have any questions. */ package com.codename1.tools.translator; import java.io.*; import java.util.ArrayList; import java.util.List; import org.objectweb.asm.AnnotationVisitor; import org.objectweb.asm.Attribute; import org.objectweb.asm.ClassReader; import org.objectweb.asm.ClassVisitor; import org.objectweb.asm.FieldVisitor; import org.objectweb.asm.Handle; import org.objectweb.asm.Label; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; import org.objectweb.asm.TypePath; import org.objectweb.asm.commons.JSRInlinerAdapter; /** * * @author Shai Almog */ public class Parser extends ClassVisitor { private ByteCodeClass cls; private String clsName; private static String[] nativeSources; private static List<ByteCodeClass> classes = new ArrayList<ByteCodeClass>(); public static void parse(File sourceFile) throws Exception { if (ByteCodeTranslator.verbose) { System.out.println("Parsing: " + sourceFile.getAbsolutePath()); } ClassReader r = new ClassReader(new FileInputStream(sourceFile)); /*if(ByteCodeTranslator.verbose) { System.out.println("Class: " + r.getClassName() + " derives from: " + r.getSuperName() + " interfaces: " + Arrays.asList(r.getInterfaces())); }*/ Parser p = new Parser(); p.clsName = r.getClassName().replace('/', '_').replace('$', '_'); if (p.clsName.startsWith("java_lang_annotation") || p.clsName.startsWith("java_lang_Deprecated") || p.clsName.startsWith("java_lang_Override") || p.clsName.startsWith("java_lang_SuppressWarnings")) { return; } p.cls = new ByteCodeClass(p.clsName); r.accept(p, ClassReader.EXPAND_FRAMES); classes.add(p.cls); } private static ByteCodeClass getClassByName(String name) { name = name.replace('/', '_').replace('$', '_'); for (ByteCodeClass bc : classes) { if (bc.getClsName().equals(name)) { return bc; } } return null; } private static void appendClassOffset(ByteCodeClass bc, List<Integer> clsIds) { if (bc.getBaseClassObject() != null) { if (!clsIds.contains(bc.getBaseClassObject().getClassOffset())) { clsIds.add(bc.getBaseClassObject().getClassOffset()); appendClassOffset(bc.getBaseClassObject(), clsIds); } } if (bc.getBaseInterfacesObject() != null) { for (ByteCodeClass c : bc.getBaseInterfacesObject()) { if (c != null && !clsIds.contains(c.getClassOffset())) { clsIds.add(c.getClassOffset()); if (c.getBaseClassObject() != null) { appendClassOffset(c, clsIds); } } } } } private static ArrayList<String> constantPool = new ArrayList<String>(); public static ByteCodeClass getClassObject(String name) { for (ByteCodeClass cls : classes) { if (cls.getClsName().equals(name)) { return cls; } } return null; } /** * Adds the given string to the hardcoded constant pool strings returns the offset in the pool */ public static int addToConstantPool(String s) { int i = constantPool.indexOf(s); if (i < 0) { constantPool.add(s); return constantPool.size() - 1; } return i; } private static void generateClassAndMethodIndexHeader(File outputDirectory) throws Exception { int classOffset = 0; int methodOffset = 0; ArrayList<BytecodeMethod> methods = new ArrayList<BytecodeMethod>(); for (ByteCodeClass bc : classes) { bc.setClassOffset(classOffset); classOffset++; methodOffset = bc.updateMethodOffsets(methodOffset); methods.addAll(bc.getMethods()); } StringBuilder bld = new StringBuilder(); StringBuilder bldM = new StringBuilder(); bldM.append("#include \"cn1_class_method_index.h\"\n"); bldM.append("#include \"cn1_globals.h\"\n\n"); bld.append("#ifndef __CN1_CLASS_METHOD_INDEX_H__\n#define __CN1_CLASS_METHOD_INDEX_H__\n\n"); bld.append("// maps to offsets in the constant pool below\nextern int classNameLookup[];\n"); bldM.append("// maps to offsets in the constant pool below\nint classNameLookup[] = {"); boolean first = true; for (ByteCodeClass bc : classes) { if (first) { bldM.append("\n "); } else { bldM.append(",\n "); } first = false; bldM.append(addToConstantPool(bc.getClsName().replace('_', '.'))); bldM.append(""); } bldM.append("};\n\n"); for (ByteCodeClass bc : classes) { bld.append("#define cn1_class_id_"); bld.append(bc.getClsName()); bld.append(" "); bld.append(bc.getClassOffset()); bld.append("\n"); } int arrayId = classes.size() + 1; bld.append("#define cn1_array_start_offset "); bld.append(arrayId); bld.append("\n"); // leave space for primitive arrays arrayId += 100; for (ByteCodeClass bc : classes) { bld.append("#define cn1_array_1_id_"); bld.append(bc.getClsName()); bld.append(" "); bld.append(arrayId); bld.append("\n"); arrayId++; bld.append("#define cn1_array_2_id_"); bld.append(bc.getClsName()); bld.append(" "); bld.append(arrayId); bld.append("\n"); arrayId++; bld.append("#define cn1_array_3_id_"); bld.append(bc.getClsName()); bld.append(" "); bld.append(arrayId); bld.append("\n"); arrayId++; /*bld.append("#define cn1_array_4_id_"); bld.append(bc.getClsName()); bld.append(" "); bld.append(arrayId); bld.append("\n"); arrayId++;*/ } bld.append("\n\n"); bld.append("// maps to offsets in the constant pool below\nextern int methodNameLookup[];\n"); bldM.append("// maps to offsets in the constant pool below\nint methodNameLookup[] = {"); first = true; for (BytecodeMethod m : methods) { if (first) { bldM.append("\n "); } else { bldM.append(",\n "); } first = false; bldM.append(addToConstantPool(m.getMethodName())); bldM.append(""); } bldM.append("};\n\n"); ArrayList<Integer> instances = new ArrayList<Integer>(); int counter = 0; for (ByteCodeClass bc : classes) { /*bld.append("extern int classInstanceOfArr"); bld.append(counter); bld.append("[];\n");*/ bldM.append("int classInstanceOfArr"); bldM.append(counter); bldM.append("[] = {"); counter++; appendClassOffset(bc, instances); for (Integer i : instances) { bldM.append(i); bldM.append(", "); } instances.clear(); bldM.append("-1};\n"); } bld.append("extern int *classInstanceOf[];\n"); bldM.append("int *classInstanceOf["); bldM.append(classes.size()); bldM.append("] = {"); first = true; counter = 0; for (ByteCodeClass bc : classes) { if (first) { bldM.append("\n "); } else { bldM.append(",\n "); } first = false; bldM.append("classInstanceOfArr"); bldM.append(counter); counter++; } bldM.append("};\n\n"); bld.append("#define CN1_CONSTANT_POOL_SIZE "); bld.append(constantPool.size()); bld.append("\n\nextern const char * const constantPool[];\n"); bldM.append("\n\nconst char * const constantPool[] = {\n"); first = true; int offset = 0; for (String con : constantPool) { if (first) { bldM.append("\n \""); } else { bldM.append(",\n \""); } first = false; try { bldM.append(encodeString(con)); } catch (Throwable t) { t.printStackTrace(); System.out.println("Error writing the constant pool string: '" + con + "'"); System.exit(1); } bldM.append("\" /* "); bldM.append(offset); offset++; bldM.append(" */"); } bldM.append("};\n\nint classListSize = "); bldM.append(classes.size()); bldM.append(";\n"); for (ByteCodeClass bc : classes) { bldM.append("extern struct clazz class__"); bldM.append(bc.getClsName().replace('/', '_').replace('$', '_')); bldM.append(";\n"); } bldM.append("\n\nstruct clazz* classesList[] = {"); first = true; for (ByteCodeClass bc : classes) { if (first) { bldM.append("\n "); } else { bldM.append(",\n "); } first = false; bldM.append(" &class__"); bldM.append(bc.getClsName().replace('/', '_').replace('$', '_')); } bldM.append("};\n\n\n"); // generate the markStatics method for (ByteCodeClass bc : classes) { bc.appendStaticFieldsExtern(bldM); } bldM.append( "\n\nextern int recursionKey;\nvoid markStatics(CODENAME_ONE_THREAD_STATE) {\n recursionKey++;\n"); for (ByteCodeClass bc : classes) { bc.appendStaticFieldsMark(bldM); } bldM.append("}\n\n"); bld.append("\n\n#endif // __CN1_CLASS_METHOD_INDEX_H__\n"); FileOutputStream fos = new FileOutputStream(new File(outputDirectory, "cn1_class_method_index.h")); fos.write(bld.toString().getBytes("UTF-8")); fos.close(); fos = new FileOutputStream(new File(outputDirectory, "cn1_class_method_index.m")); fos.write(bldM.toString().getBytes("UTF-8")); fos.close(); } private static String encodeString(String con) { String str = con.replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n").replace("\r", "\\r") .replace("\t", "\\t"); return encodeStringSlashU(str); } private static String encodeStringSlashU(String str) { int len = str.length(); char[] chr = str.toCharArray(); for (int iter = 0; iter < len; iter++) { char c = chr[iter]; if (c > 127) { // needs encoding... Verify there are no more characters to encode StringBuilder d = new StringBuilder(); for (int internal = 0; internal < len; internal++) { c = chr[internal]; if (c > 127) { d.append("~~u"); d.append(fourChars(Integer.toHexString(c))); } else { d.append(c); } } return d.toString(); } } return str; } private static String fourChars(String s) { switch (s.length()) { case 1: return "000" + s; case 2: return "00" + s; case 3: return "0" + s; } return s; } public static void writeOutput(File outputDirectory) throws Exception { System.out.println("outputDirectory is: " + outputDirectory.getAbsolutePath()); if (ByteCodeClass.getMainClass() == null) { System.out.println( "Error main class is not defined. The main class name is expected to have a public static void main(String[]) method and it is assumed to reside in the com.package.name directory"); System.exit(1); } String file = "Unknown File"; try { for (ByteCodeClass bc : classes) { // special case for object if (bc.getClsName().equals("java_lang_Object")) { continue; } file = bc.getClsName(); bc.setBaseClassObject(getClassByName(bc.getBaseClass())); List<ByteCodeClass> lst = new ArrayList<ByteCodeClass>(); for (String s : bc.getBaseInterfaces()) { ByteCodeClass bcode = getClassByName(s); if (bcode == null) { System.out.println("Error while working with the class: " + s + " file:" + file + " no class definition"); } else { lst.add(getClassByName(s)); } } bc.setBaseInterfacesObject(lst); } boolean foundNewUnitTests = true; while (foundNewUnitTests) { foundNewUnitTests = false; for (ByteCodeClass bc : classes) { if (!bc.isUnitTest() && bc.getBaseClassObject() != null && bc.getBaseClassObject().isUnitTest()) { bc.setIsUnitTest(true); foundNewUnitTests = true; } } } for (ByteCodeClass bc : classes) { file = bc.getClsName(); bc.updateAllDependencies(); } ByteCodeClass.markDependencies(classes); classes = ByteCodeClass.clearUnmarked(classes); // load the native sources (including user native code) readNativeFiles(outputDirectory); // loop over methods and start eliminating the body of unused methods eliminateUnusedMethods(); generateClassAndMethodIndexHeader(outputDirectory); boolean concatenate = "true".equals(System.getProperty("concatenateFiles", "false")); ConcatenatingFileOutputStream cos = concatenate ? new ConcatenatingFileOutputStream(outputDirectory) : null; for (ByteCodeClass bc : classes) { file = bc.getClsName(); writeFile(bc, outputDirectory, cos); } if (cos != null) cos.realClose(); } catch (Throwable t) { System.out.println("Error while working with the class: " + file); t.printStackTrace(); if (t instanceof Exception) { throw (Exception) t; } if (t instanceof RuntimeException) { throw (RuntimeException) t; } } } private static void readNativeFiles(File outputDirectory) throws IOException { File[] mFiles = outputDirectory.listFiles(new FileFilter() { @Override public boolean accept(File file) { return file.getName().endsWith(".m"); } }); nativeSources = new String[mFiles.length]; for (int iter = 0; iter < mFiles.length; iter++) { DataInputStream di = new DataInputStream(new FileInputStream(mFiles[iter])); byte[] dat = new byte[(int) mFiles[iter].length()]; di.readFully(dat); nativeSources[iter] = new String(dat, "UTF-8"); } } private static void eliminateUnusedMethods() { usedByNativeCheck(); eliminateUnusedMethods(0); } private static void eliminateUnusedMethods(int depth) { boolean found = false; found = cullMethods(found); cullClasses(found, depth); } private static boolean cullMethods(boolean found) { for (ByteCodeClass bc : classes) { bc.unmark(); if (bc.isIsInterface() || bc.getBaseClass() == null) { continue; } for (BytecodeMethod mtd : bc.getMethods()) { if (mtd.isEliminated() || mtd.isUsedByNative() || mtd.isMain() || mtd.getMethodName().equals("__CLINIT__") || mtd.getMethodName().equals("finalize") || mtd.isNative()) { continue; } if (!isMethodUsed(mtd)) { if (isMethodUsedByBaseClassOrInterface(mtd, bc)) { continue; } found = true; mtd.setEliminated(true); /*if(ByteCodeTranslator.verbose) { System.out.println("Eliminating method: " + mtd.getClsName() + "." + mtd.getMethodName()); }*/ } } } return found; } private static boolean isMethodUsedByBaseClassOrInterface(BytecodeMethod mtd, ByteCodeClass cls) { boolean b = checkMethodUsedByBaseClassOrInterface(mtd, cls.getBaseClassObject()); if (b) { return true; } for (ByteCodeClass bc : cls.getBaseInterfacesObject()) { b = checkMethodUsedByBaseClassOrInterface(mtd, bc); if (b) { return true; } } return false; } private static boolean checkMethodUsedByBaseClassOrInterface(BytecodeMethod mtd, ByteCodeClass cls) { if (cls == null) { return false; } if (cls.getBaseInterfacesObject() != null) { for (ByteCodeClass bc : cls.getBaseInterfacesObject()) { for (BytecodeMethod m : bc.getMethods()) { if (m.getMethodName().equals(mtd.getMethodName())) { if (m.isUsedByNative()) { return true; } break; } } } } for (BytecodeMethod m : cls.getMethods()) { if (m.getMethodName().equals(mtd.getMethodName())) { if (m.isUsedByNative()) { return true; } break; } } return false; } private static void cullClasses(boolean found, int depth) { if (found && depth < 3) { for (ByteCodeClass bc : classes) { bc.updateAllDependencies(); } //int classCount = classes.size(); ByteCodeClass.markDependencies(classes); List<ByteCodeClass> tmp = ByteCodeClass.clearUnmarked(classes); /*if(ByteCodeTranslator.verbose) { System.out.println("Classes removed from: " + classCount + " to " + classes.size()); for(ByteCodeClass bc : classes) { if(!tmp.contains(bc)) { System.out.println("Removed class: " + bc.getClsName()); } } }*/ classes = tmp; eliminateUnusedMethods(depth + 1); } } private static void usedByNativeCheck() { for (ByteCodeClass bc : classes) { //java_lang_Thread_runImpl___long for (BytecodeMethod mtd : bc.getMethods()) { // check native code StringBuilder b = new StringBuilder(); mtd.appendFunctionPointer(b); String str = b.toString(); for (String s : nativeSources) { if (s.contains(str)) { mtd.setUsedByNative(true); break; } } } } } private static boolean isMethodUsed(BytecodeMethod m) { for (ByteCodeClass bc : classes) { for (BytecodeMethod mtd : bc.getMethods()) { if (mtd.isEliminated() || mtd == m) { continue; } if (mtd.isMethodUsed(m)) { return true; } } } // check native code StringBuilder b = new StringBuilder(); m.appendFunctionPointer(b); String str = b.toString(); for (String s : nativeSources) { if (s.contains(str)) { return true; } } return false; } private static void writeFile(ByteCodeClass cls, File outputDir, ConcatenatingFileOutputStream writeBufferInstead) throws Exception { OutputStream outMain = writeBufferInstead != null && ByteCodeTranslator.output == ByteCodeTranslator.OutputType.OUTPUT_TYPE_IOS ? writeBufferInstead : new FileOutputStream(new File(outputDir, cls.getClsName() + "." + ByteCodeTranslator.output.extension())); if (outMain instanceof ConcatenatingFileOutputStream) { ((ConcatenatingFileOutputStream) outMain).beginNextFile(cls.getClsName()); } if (ByteCodeTranslator.output == ByteCodeTranslator.OutputType.OUTPUT_TYPE_IOS) { outMain.write(cls.generateCCode(classes).getBytes()); outMain.close(); // we also need to write the header file for iOS String headerName = cls.getClsName() + ".h"; FileOutputStream outHeader = new FileOutputStream(new File(outputDir, headerName)); outHeader.write(cls.generateCHeader().getBytes()); outHeader.close(); } else { outMain.write(cls.generateCSharpCode().getBytes()); outMain.close(); } } public Parser() { super(Opcodes.ASM5); } @Override public void visitEnd() { super.visitEnd(); } @Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { BytecodeMethod mtd = new BytecodeMethod(clsName, access, name, desc, signature, exceptions); cls.addMethod(mtd); JSRInlinerAdapter a = new JSRInlinerAdapter( new MethodVisitorWrapper(super.visitMethod(access, name, desc, signature, exceptions), mtd), access, name, desc, signature, exceptions); return a; } @Override public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { ByteCodeField fld = new ByteCodeField(clsName, access, name, desc, signature, value); cls.addField(fld); return new FieldVisitorWrapper(super.visitField(access, name, desc, signature, value)); } @Override public void visitInnerClass(String name, String outerName, String innerName, int access) { super.visitInnerClass(name, outerName, innerName, access); } @Override public void visitAttribute(Attribute attr) { super.visitAttribute(attr); } @Override public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) { return new AnnotationVisitorWrapper(super.visitTypeAnnotation(typeRef, typePath, desc, visible)); } @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { return new AnnotationVisitorWrapper(super.visitAnnotation(desc, visible)); } @Override public void visitOuterClass(String owner, String name, String desc) { super.visitOuterClass(owner, name, desc); } @Override public void visitSource(String source, String debug) { cls.setSourceFile(source); super.visitSource(source, debug); } @Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { cls.setBaseClass(superName); cls.setBaseInterfaces(interfaces); if ((access & Opcodes.ACC_ABSTRACT) == Opcodes.ACC_ABSTRACT) { cls.setIsAbstract(true); } if ((access & Opcodes.ACC_INTERFACE) == Opcodes.ACC_INTERFACE) { cls.setIsInterface(true); } if ((access & Opcodes.ACC_FINAL) == Opcodes.ACC_FINAL) { cls.setFinalClass(true); } if ("com/codename1/testing/UnitTest".equals(superName) || "com/codename1/testing/AbstractTest".equals(superName)) { cls.setIsUnitTest(true); } if ((access & Opcodes.ACC_ENUM) == Opcodes.ACC_ENUM) { cls.setIsEnum(true); } super.visit(version, access, name, signature, superName, interfaces); } class MethodVisitorWrapper extends MethodVisitor { private BytecodeMethod mtd; public MethodVisitorWrapper(MethodVisitor mv, BytecodeMethod mtd) { super(Opcodes.ASM5, mv); this.mtd = mtd; } @Override public void visitEnd() { super.visitEnd(); } @Override public void visitMaxs(int maxStack, int maxLocals) { mtd.setMaxes(maxStack, maxLocals); super.visitMaxs(maxStack, maxLocals); } @Override public void visitLineNumber(int line, Label start) { mtd.addDebugInfo(line); super.visitLineNumber(line, start); } @Override public AnnotationVisitor visitLocalVariableAnnotation(int typeRef, TypePath typePath, Label[] start, Label[] end, int[] index, String desc, boolean visible) { return new AnnotationVisitorWrapper( super.visitLocalVariableAnnotation(typeRef, typePath, start, end, index, desc, visible)); } @Override public void visitLocalVariable(String name, String desc, String signature, Label start, Label end, int index) { mtd.addLocalVariable(name, desc, signature, start, end, index); super.visitLocalVariable(name, desc, signature, start, end, index); } @Override public AnnotationVisitor visitTryCatchAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) { return new AnnotationVisitorWrapper(super.visitTryCatchAnnotation(typeRef, typePath, desc, visible)); } @Override public void visitTryCatchBlock(Label start, Label end, Label handler, String type) { mtd.addTryCatchBlock(start, end, handler, type); super.visitTryCatchBlock(start, end, handler, type); } @Override public AnnotationVisitor visitInsnAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) { return new AnnotationVisitorWrapper(super.visitInsnAnnotation(typeRef, typePath, desc, visible)); } @Override public void visitMultiANewArrayInsn(String desc, int dims) { mtd.addMultiArray(desc, dims); super.visitMultiANewArrayInsn(desc, dims); } @Override public void visitLookupSwitchInsn(Label dflt, int[] keys, Label[] labels) { mtd.addSwitch(dflt, keys, labels); super.visitLookupSwitchInsn(dflt, keys, labels); } @Override public void visitTableSwitchInsn(int min, int max, Label dflt, Label... labels) { int[] keys = new int[labels.length]; int counter = min; for (int iter = 0; iter < keys.length; iter++) { keys[iter] = counter; counter++; } mtd.addSwitch(dflt, keys, labels); super.visitTableSwitchInsn(min, max, dflt, labels); } @Override public void visitIincInsn(int var, int increment) { mtd.addIInc(var, increment); super.visitIincInsn(var, increment); } @Override public void visitLdcInsn(Object cst) { mtd.addLdc(cst); super.visitLdcInsn(cst); } @Override public void visitLabel(Label label) { mtd.addLabel(label); super.visitLabel(label); } @Override public void visitJumpInsn(int opcode, Label label) { mtd.addJump(opcode, label); super.visitJumpInsn(opcode, label); } @Override public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) { super.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs); } @Override public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) { mtd.addInvoke(opcode, owner, name, desc, itf); super.visitMethodInsn(opcode, owner, name, desc, itf); } @Override public void visitMethodInsn(int opcode, String owner, String name, String desc) { super.visitMethodInsn(opcode, owner, name, desc); } @Override public void visitFieldInsn(int opcode, String owner, String name, String desc) { mtd.addField(opcode, owner, name, desc); super.visitFieldInsn(opcode, owner, name, desc); } @Override public void visitTypeInsn(int opcode, String type) { mtd.addTypeInstruction(opcode, type); super.visitTypeInsn(opcode, type); } @Override public void visitVarInsn(int opcode, int var) { mtd.addVariableOperation(opcode, var); super.visitVarInsn(opcode, var); } @Override public void visitIntInsn(int opcode, int operand) { mtd.addVariableOperation(opcode, operand); super.visitIntInsn(opcode, operand); } @Override public void visitInsn(int opcode) { mtd.addInstruction(opcode); super.visitInsn(opcode); } @Override public void visitFrame(int type, int nLocal, Object[] local, int nStack, Object[] stack) { super.visitFrame(type, nLocal, local, nStack, stack); } @Override public void visitCode() { super.visitCode(); } @Override public void visitAttribute(Attribute attr) { super.visitAttribute(attr); } @Override public AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) { if (mv == null) return null; return new AnnotationVisitorWrapper(super.visitParameterAnnotation(parameter, desc, visible)); } @Override public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) { if (mv == null) return null; return new AnnotationVisitorWrapper(super.visitTypeAnnotation(typeRef, typePath, desc, visible)); } @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { if (mv == null) return null; return new AnnotationVisitorWrapper(super.visitAnnotation(desc, visible)); } @Override public AnnotationVisitor visitAnnotationDefault() { if (mv == null) return null; return new AnnotationVisitorWrapper(super.visitAnnotationDefault()); } @Override public void visitParameter(String name, int access) { super.visitParameter(name, access); } } class FieldVisitorWrapper extends FieldVisitor { public FieldVisitorWrapper(FieldVisitor fv) { super(Opcodes.ASM5, fv); } @Override public void visitEnd() { super.visitEnd(); } @Override public void visitAttribute(Attribute attr) { super.visitAttribute(attr); } @Override public AnnotationVisitor visitTypeAnnotation(int typeRef, TypePath typePath, String desc, boolean visible) { return super.visitTypeAnnotation(typeRef, typePath, desc, visible); } @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { return super.visitAnnotation(desc, visible); } } class AnnotationVisitorWrapper extends AnnotationVisitor { public AnnotationVisitorWrapper(AnnotationVisitor av) { super(Opcodes.ASM5, av); } @Override public void visitEnd() { super.visitEnd(); } @Override public AnnotationVisitor visitArray(String name) { if (av == null) return null; return super.visitArray(name); } @Override public AnnotationVisitor visitAnnotation(String name, String desc) { if (av == null) return null; return super.visitAnnotation(name, desc); } @Override public void visitEnum(String name, String desc, String value) { super.visitEnum(name, desc, value); } @Override public void visit(String name, Object value) { super.visit(name, value); } } }