Example usage for org.objectweb.asm ClassWriter ClassWriter

List of usage examples for org.objectweb.asm ClassWriter ClassWriter

  1. HOME
  2. Java
  3. org.objectweb.asm
  4. org.objectweb.asm.*
  5. ClassWriter
  6. ClassWriter

Introduction

In this page you can find the example usage for org.objectweb.asm ClassWriter ClassWriter.

Prototype

public ClassWriter(final int flags)

Source Link

Document

Constructs a new ClassWriter object.

Usage

From source file:ModuleInfoGenerator.java

License:Open Source License

public static void main(String[] args) throws Exception {
    File dest = new File(args[0]);
    ClassWriter cw = new ClassWriter(0);
    cw.visit(V9, Opcodes.ACC_MODULE, "module-info", null, null, null);
    ModuleVisitor mv = cw.visitModule("org.joml", 0, args[1]);
    mv.visitRequire("java.base", ACC_MANDATED, "9");
    mv.visitRequire("jdk.unsupported", ACC_STATIC_PHASE, null);
    mv.visitExport("org/joml", 0, (String[]) null);
    mv.visitExport("org/joml/sampling", 0, (String[]) null);
    mv.visitEnd();/* w w  w .  j a  v a2s  . c  om*/
    cw.visitEnd();
    FileOutputStream fos = new FileOutputStream(new File(dest, "module-info.class"));
    fos.write(cw.toByteArray());
    fos.close();
}

From source file:Test1.java

License:Apache License

private static void implementInterface(ClassNode cn) throws Exception {

    // MethodNode fromMethod = new MethodNode(ACC_PUBLIC, "fromData",
    // "(Ljava/io/DataInput;)V", null, new String[] {
    // "java/io/IOException",
    // "java/lang/ClassNotFoundException" });
    // mv = cw.visitMethod(ACC_PUBLIC, "toData", "(Ljava/io/DataOutput;)V",
    // null, new String[] { "java/io/IOException" });
    MethodNode toMethod = new MethodNode(ACC_PUBLIC, "toData", "(Ljava/io/DataOutput;)V", null,
            new String[] { "java/io/IOException" });
    InsnList instToMethod = toMethod.instructions;
    for (int i = 0; i < cn.fields.size(); i++) {
        FieldNode fn = (FieldNode) cn.fields.get(i);
        toMethod(cn.name, fn, instToMethod);
    }/* w w w  .  j  av a  2 s.  com*/
    instToMethod.add(new InsnNode(RETURN));
    cn.methods.add(toMethod);

    ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
    cn.accept(cw);
    byte[] bt = cw.toByteArray();

    ClassReader cr = new ClassReader(bt);
    CheckClassAdapter ca = new CheckClassAdapter(cw);
    FileOutputStream fo = new FileOutputStream("d:/x1.log");
    PrintWriter pw = new PrintWriter(fo);
    ca.verify(cr, true, pw);

    ByteArrayClassLoader bacl = new ByteArrayClassLoader(bt);

    Class cls = bacl.loadClass("ynd.test.Ac01");
    DataSerializable di = (DataSerializable) cls.newInstance();
    di.toData(null);
}

From source file:Java6to2.java

License:Open Source License

private static byte[] transform(InputStream classfile) throws IOException {
    ClassReader cr = new ClassReader(classfile);
    ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
    ClassVisitor cv = new ClassVisitor(ASM7, cw) {
        String internalName;//from  ww w.j a va2 s.  c  o m
        boolean classLookupMethodGenerated;
        Set fieldsGenerated = new HashSet();

        public void visit(int version, int access, String name, String signature, String superName,
                String[] interfaces) {
            /* Change class file version to 1.2 */
            cv.visit(V1_2, access, name, signature, superName, interfaces);
            this.internalName = name;
        }

        /**
         * Generates the synthetic "class$" method, used to lookup classes via Class.forName(). This uses the exact same code as does JDK8 javac for target 1.2.
         */
        void generateSyntheticClassLookupMethod() {
            MethodVisitor mv = cv.visitMethod(ACC_PRIVATE | ACC_STATIC | ACC_SYNTHETIC, "class$",
                    "(Ljava/lang/String;)Ljava/lang/Class;", null, null);
            {
                Label start = new Label();
                Label end = new Label();
                Label handler = new Label();
                mv.visitTryCatchBlock(start, end, handler, "java/lang/ClassNotFoundException");
                mv.visitLabel(start);
                mv.visitVarInsn(ALOAD, 0);
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/Class", "forName",
                        "(Ljava/lang/String;)Ljava/lang/Class;", false);
                mv.visitLabel(end);
                mv.visitInsn(ARETURN);
                mv.visitLabel(handler);
                mv.visitVarInsn(ASTORE, 1);
                mv.visitTypeInsn(NEW, "java/lang/NoClassDefFoundError");
                mv.visitInsn(DUP);
                mv.visitMethodInsn(INVOKESPECIAL, "java/lang/NoClassDefFoundError", "<init>", "()V", false);
                mv.visitVarInsn(ALOAD, 1);
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/NoClassDefFoundError", "initCause",
                        "(Ljava/lang/Throwable;)Ljava/lang/Throwable;", false);
                mv.visitInsn(ATHROW);
            }
            mv.visitMaxs(2, 2);
            mv.visitEnd();
        }

        public MethodVisitor visitMethod(int access, String name, String desc, String signature,
                String[] exceptions) {
            MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
            final ClassVisitor cv = this.cv;
            return new MethodVisitor(ASM7, mv) {
                /**
                 * Intercepts class instantiations to see whether they instantiate a StringBuilder. Those instructions were generated by javac for string concatenations. But
                 * StringBuilder is not available on JRE1.2, so we just replace it with StringBuffer.
                 */
                public void visitTypeInsn(int opcode, String type) {
                    if (opcode == NEW && "java/lang/StringBuilder".equals(type)) {
                        mv.visitTypeInsn(opcode, "java/lang/StringBuffer");
                    } else {
                        mv.visitTypeInsn(opcode, type);
                    }
                }

                /**
                 * Intercepts method invocations to see whether they do something with StringBuilder. Those instructions were generated by javac for string concatenations. But
                 * StringBuilder is not available on JRE1.2, so we just replace it with StringBuffer.
                 */
                public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
                    if ("java/lang/StringBuilder".equals(owner)) {
                        mv.visitMethodInsn(opcode, "java/lang/StringBuffer", name,
                                desc.replace("java/lang/StringBuilder", "java/lang/StringBuffer"), itf);
                    } else {
                        mv.visitMethodInsn(opcode, owner, name, desc, itf);
                    }
                }

                /**
                 * Intercepts LDC instructions and check whether they are used to load a class. This is not supported on Java 1.2, so we convert it to the same code used by the
                 * JDK8 javac:
                 * <ul>
                 * <li>create synthetic fields holding the resolved class objects
                 * <li>create a synthetic method called "class$" which does Class.forName
                 * </ul>
                 */
                public void visitLdcInsn(Object cst) {
                    if (cst instanceof Type) {
                        Type t = (Type) cst;
                        String syntheticField = "class$"
                                + t.getInternalName().replace('/', '$').replace("[", "");
                        if (!classLookupMethodGenerated) {
                            /* Emit the synthetic "class$" method, used to lookup classes via Class.forName() */
                            generateSyntheticClassLookupMethod();
                            classLookupMethodGenerated = true;
                        }
                        if (!fieldsGenerated.contains(syntheticField)) {
                            /* Generate a synthetic field holding the resolved Class object */
                            cv.visitField(ACC_PRIVATE | ACC_STATIC | ACC_SYNTHETIC, syntheticField,
                                    "Ljava/lang/Class;", null, null);
                            fieldsGenerated.add(syntheticField);
                        }
                        mv.visitFieldInsn(GETSTATIC, internalName, syntheticField, "Ljava/lang/Class;");
                        Label nonNull = new Label();
                        mv.visitJumpInsn(IFNONNULL, nonNull);
                        mv.visitLdcInsn(t.getInternalName().replace('/', '.'));
                        mv.visitMethodInsn(INVOKESTATIC, internalName, "class$",
                                "(Ljava/lang/String;)Ljava/lang/Class;", false);
                        mv.visitInsn(DUP);
                        mv.visitFieldInsn(PUTSTATIC, internalName, syntheticField, "Ljava/lang/Class;");
                        Label cnt = new Label();
                        mv.visitJumpInsn(GOTO, cnt);
                        mv.visitLabel(nonNull);
                        mv.visitFieldInsn(GETSTATIC, internalName, syntheticField, "Ljava/lang/Class;");
                        mv.visitLabel(cnt);
                    } else {
                        mv.visitLdcInsn(cst);
                    }
                }
            };
        }
    };
    cr.accept(cv, ClassReader.SKIP_FRAMES); // <- Frames are not used in Java 1.2, so skip them
    return cw.toByteArray();
}

From source file:Asm.java

License:Apache License

private static void modify(String clazz) throws Exception {
    ClassNode classNode = new ClassNode();
    ClassReader cr = new ClassReader(clazz);
    cr.accept(classNode, 0);//  w ww  . j av a2 s  .c  o  m

    modify(classNode);

    ClassWriter cw = new ClassWriter(0);
    classNode.accept(cw);
    byte[] b = cw.toByteArray();
    OutputStream out = new FileOutputStream(clazz + ".out");
    out.write(b, 0, b.length);
    out.close();
}

From source file:analysis.RuntimeTemplateGenerator.java

License:Open Source License

public JarClasses generateTemplate() {
    ClassReader classReader;/*from ww  w.j a  va2  s.c o m*/
    ClassVisitor classVisitor;
    ClassWriter classWriter;

    Map<String, JarClasses.Entry> entries = new HashMap<String, JarClasses.Entry>();

    for (ClassReference ref : references) {
        classReader = classes.get(ref.getName());

        classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
        classVisitor = getClassTransformer(ref, classWriter);

        classReader.accept(classVisitor, ClassReader.SKIP_FRAMES);

        entries.put(ref.getName(), new JarClasses.Entry(classWriter.toByteArray(), ref.getName()));
    }

    return new JarClasses(entries);
}

From source file:appeng.core.api.ApiPart.java

License:Open Source License

public Class getClassByDesc(String addendum, String fullPath, String root, String next) {
    if (this.roots.get(fullPath) != null) {
        return this.roots.get(fullPath);
    }//from   w  w  w .  j a v  a 2s  .c  o m

    ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
    ClassNode n = this.getReader(next);
    String originalName = n.name;

    try {
        n.name = n.name + '_' + addendum;
        n.superName = Class.forName(root).getName().replace(".", "/");
    } catch (Throwable t) {
        AELog.error(t);
    }

    for (MethodNode mn : n.methods) {
        Iterator<AbstractInsnNode> i = mn.instructions.iterator();
        while (i.hasNext()) {
            this.processNode(i.next(), n.superName);
        }
    }

    DefaultPackageClassNameRemapper remapper = new DefaultPackageClassNameRemapper();
    remapper.inputOutput.put("appeng/api/parts/LayerBase", n.superName);
    remapper.inputOutput.put(originalName, n.name);
    n.accept(new RemappingClassAdapter(cw, remapper));
    // n.accept( cw );

    // n.accept( new TraceClassVisitor( new PrintWriter( System.out ) ) );
    byte[] byteArray = cw.toByteArray();
    int size = byteArray.length;
    Class clazz = this.loadClass(n.name.replace("/", "."), byteArray);

    try {
        Object fish = clazz.newInstance();
        Class rootC = Class.forName(root);

        boolean hasError = false;

        if (!rootC.isInstance(fish)) {
            hasError = true;
            AELog.severe("Error, Expected layer to implement " + root + " did not.");
        }

        if (fish instanceof LayerBase) {
            hasError = true;
            AELog.severe("Error, Expected layer to NOT implement LayerBase but it DID.");
        }

        if (!fullPath.contains(".fmp.")) {
            if (!(fish instanceof TileCableBus)) {
                hasError = true;
                AELog.severe("Error, Expected layer to implement TileCableBus did not.");
            }

            if (!(fish instanceof TileEntity)) {
                hasError = true;
                AELog.severe("Error, Expected layer to implement TileEntity did not.");
            }
        }

        if (!hasError) {
            AELog.info("Layer: " + n.name + " loaded successfully - " + size + " bytes");
        }
    } catch (Throwable t) {
        AELog.severe("Layer: " + n.name + " Failed.");
        AELog.error(t);
    }

    this.roots.put(fullPath, clazz);
    return clazz;
}

From source file:appeng.coremod.asm.ASMIntegration.java

License:Open Source License

@Nullable
@Override/*from w  w w. jav a 2s .  c  om*/
public byte[] transform(final String name, final String transformedName, final byte[] basicClass) {
    if (basicClass == null || transformedName.startsWith("appeng.coremod")) {
        return basicClass;
    }

    if (transformedName.startsWith("appeng.")) {
        final ClassNode classNode = new ClassNode();
        final ClassReader classReader = new ClassReader(basicClass);
        classReader.accept(classNode, 0);

        try {
            final boolean reWrite = this.removeOptionals(classNode);

            if (reWrite) {
                final ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
                classNode.accept(writer);
                return writer.toByteArray();
            }
        } catch (final Throwable t) {
            t.printStackTrace();
        }
    }
    return basicClass;
}

From source file:appeng.coremod.transformer.IntegrationTransformer.java

License:Open Source License

@Nullable
@Override//from   ww  w.  j a  v a 2s.  c  o m
public byte[] transform(final String name, final String transformedName, final byte[] basicClass) {
    if (basicClass == null) {
        return basicClass;
    }

    if (transformedName.startsWith("appeng.")) {
        final ClassNode classNode = new ClassNode();
        final ClassReader classReader = new ClassReader(basicClass);
        classReader.accept(classNode, 0);

        try {
            final boolean reWrite = this.removeOptionals(classNode);

            if (reWrite) {
                final ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
                classNode.accept(writer);
                return writer.toByteArray();
            }
        } catch (final Throwable t) {
            t.printStackTrace();
        }
    }
    return basicClass;
}

From source file:appeng.transformer.asm.ASMIntegration.java

License:Open Source License

@Nullable
@Override//  www. ja v  a2s.c om
public byte[] transform(String name, String transformedName, byte[] basicClass) {
    if (basicClass == null || transformedName.startsWith("appeng.transformer")) {
        return basicClass;
    }

    if (transformedName.startsWith("appeng.")) {
        ClassNode classNode = new ClassNode();
        ClassReader classReader = new ClassReader(basicClass);
        classReader.accept(classNode, 0);

        try {
            boolean reWrite = this.removeOptionals(classNode);

            if (reWrite) {
                ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
                classNode.accept(writer);
                return writer.toByteArray();
            }
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }
    return basicClass;
}

From source file:appeng.transformer.asm.ASMTweaker.java

License:Open Source License

@Nullable
@Override//www  .j av a 2 s. com
public byte[] transform(String name, String transformedName, byte[] basicClass) {
    if (basicClass == null) {
        return null;
    }

    try {
        if (transformedName != null && this.privateToPublicMethods.containsKey(transformedName)) {
            ClassNode classNode = new ClassNode();
            ClassReader classReader = new ClassReader(basicClass);
            classReader.accept(classNode, 0);

            for (PublicLine set : this.privateToPublicMethods.get(transformedName)) {
                this.makePublic(classNode, set);
            }

            // CALL VIRTUAL!
            if (transformedName.equals("net.minecraft.client.gui.inventory.GuiContainer")) {
                for (MethodNode mn : classNode.methods) {
                    if (mn.name.equals("func_146977_a") || (mn.name.equals("a") && mn.desc.equals("(Lzk;)V"))) {
                        MethodNode newNode = new MethodNode(Opcodes.ACC_PUBLIC, "func_146977_a_original",
                                mn.desc, mn.signature, EXCEPTIONS);
                        newNode.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
                        newNode.instructions.add(new VarInsnNode(Opcodes.ALOAD, 1));
                        newNode.instructions.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, classNode.name,
                                mn.name, mn.desc, false));
                        newNode.instructions.add(new InsnNode(Opcodes.RETURN));
                        this.log(newNode.name + newNode.desc + " - New Method");
                        classNode.methods.add(newNode);
                        break;
                    }
                }

                for (MethodNode mn : classNode.methods) {
                    if (mn.name.equals("func_73863_a") || mn.name.equals("drawScreen")
                            || (mn.name.equals("a") && mn.desc.equals("(IIF)V"))) {
                        Iterator<AbstractInsnNode> i = mn.instructions.iterator();
                        while (i.hasNext()) {
                            AbstractInsnNode in = i.next();
                            if (in.getOpcode() == Opcodes.INVOKESPECIAL) {
                                MethodInsnNode n = (MethodInsnNode) in;
                                if (n.name.equals("func_146977_a")
                                        || (n.name.equals("a") && n.desc.equals("(Lzk;)V"))) {
                                    this.log(n.name + n.desc + " - Invoke Virtual");
                                    mn.instructions.insertBefore(n, new MethodInsnNode(Opcodes.INVOKEVIRTUAL,
                                            n.owner, n.name, n.desc, false));
                                    mn.instructions.remove(in);
                                    break;
                                }
                            }
                        }
                    }
                }
            }

            ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
            classNode.accept(writer);
            return writer.toByteArray();
        }
    } catch (Throwable ignored) {
    }

    return basicClass;
}