Example usage for org.objectweb.asm ClassVisitor ClassVisitor

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

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

Introduction

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

Prototype

public ClassVisitor(final int api)

Source Link

Document

Constructs a new ClassVisitor .

Usage

From source file:org.moe.gradle.internal.AnnotationChecker.java

License:Apache License

/**
 * Checks for the specified annotation.// w  ww .  j a  va 2 s  .c o  m
 */
private void check() {
    ClassReader reader;
    try {
        reader = new ClassReader(inputStream);
    } catch (IOException e) {
        throw new GradleException("Failed to create ClassReader", e);
    }
    reader.accept(new ClassVisitor(Opcodes.ASM5) {
        @Override
        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
            if (AnnotationChecker.this.annotationName.equals(desc)) {
                AnnotationChecker.this.hasAnnotation = true;
            }
            return super.visitAnnotation(desc, visible);
        }

        @Override
        public void visit(int version, int access, String name, String signature, String superName,
                String[] interfaces) {
            AnnotationChecker.this.name = Require.nonNull(name);
            super.visit(version, access, name, signature, superName, interfaces);
        }
    }, 0);
}

From source file:org.moe.gradle.natj.NatJClass.java

License:Apache License

/**
 * Returns a ClassVisitor used to initialize this object.
 *
 * @param api ASM API version//from w w  w .j a va 2 s  .com
 * @param consumer Consumer to invoke post-initialization.
 * @return ClassVisitor instance
 */
public ClassVisitor getInitializingVisitor(int api, Consumer<T> consumer) {
    return new ClassVisitor(api) {
        @Override
        public void visit(int version, int access, String name, String signature, String superName,
                String[] interfaces) {
            NatJClass.this.name = Require.nonNull(name);
            NatJClass.this.superName = superName;
            NatJClass.this.superInterfaces = Arrays.copyOf(Require.nonNull(interfaces), interfaces.length);
            NatJClass.this.isClass = (access & ACC_INTERFACE) == 0;
        }

        @Override
        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
            if ("Lorg/moe/natj/objc/ann/ObjCClassName;".equals(desc)) {
                return new AnnotationVisitor(api) {
                    @Override
                    public void visit(String name, Object value) {
                        if ("value".equals(name)) {
                            objcClassName = (String) value;
                        }
                    }

                    @Override
                    public void visitEnd() {
                        if (objcClassName == null) {
                            throw new GradleException("Found ObjCClassName annotation without a value");
                        }
                    }
                };
            } else if ("Lorg/moe/natj/objc/ann/ObjCClassBinding;".equals(desc)) {
                return new AnnotationVisitor(api) {
                    @Override
                    public void visit(String name, Object value) {
                        if ("value".equals(name)) {
                            objcClassBinding = (String) value;
                        }
                    }

                    @Override
                    public void visitEnd() {
                        if (objcClassBinding == null) {
                            objcClassBinding = name.substring(name.lastIndexOf('/') + 1, name.length());
                        }
                    }
                };
            } else if ("Lorg/moe/natj/objc/ann/ObjCProtocolName;".equals(desc)) {
                return new AnnotationVisitor(api) {
                    @Override
                    public void visit(String name, Object value) {
                        if ("value".equals(name)) {
                            objcProtocolName = (String) value;
                        }
                    }

                    @Override
                    public void visitEnd() {
                        if (objcProtocolName == null) {
                            throw new GradleException("Found ObjCProtocolName annotation without a value");
                        }
                    }
                };
            } else if ("Lorg/moe/natj/objc/ann/ObjCProtocolSourceName;".equals(desc)) {
                return new AnnotationVisitor(api) {
                    @Override
                    public void visit(String name, Object value) {
                        if ("value".equals(name)) {
                            objcProtocolSourceName = (String) value;
                        }
                    }

                    @Override
                    public void visitEnd() {
                        if (objcProtocolSourceName == null) {
                            throw new GradleException(
                                    "Found ObjCProtocolSourceName annotation without a value");
                        }
                    }
                };
            } else if ("Lorg/moe/natj/general/ann/Generated;".equals(desc)) {
                isGenerated = true;
            } else if ("Lorg/moe/natj/general/ann/Library;".equals(desc)) {
                return new AnnotationVisitor(api) {
                    @Override
                    public void visit(String name, Object value) {
                        if ("value".equals(name)) {
                            library = (String) value;
                        }
                    }

                    @Override
                    public void visitEnd() {
                        if (library == null) {
                            throw new GradleException("Found Library annotation without value");
                        }
                    }
                };
            }
            return null;
        }

        @Override
        @SuppressWarnings("unchecked")
        public void visitEnd() {
            if (consumer != null) {
                consumer.accept((T) NatJClass.this);
            }
        }
    };
}

From source file:org.mutabilitydetector.checkers.CollectionFieldTest.java

License:Apache License

private String[] descAndSignatureOfSingleFieldIn(Class<?> class1) throws IOException {
    final String[] fieldDescSignature = new String[2];

    ClassReader classReader = new ClassReader(class1.getName());
    classReader.accept(new ClassVisitor(Opcodes.ASM4) {
        @Override//from  ww w.j av a  2s . c  o  m
        public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {
            fieldDescSignature[0] = desc;
            fieldDescSignature[1] = signature;
            return super.visitField(access, name, desc, signature, value);

        };
    }, 0);
    return fieldDescSignature;
}

From source file:org.powerassert.JavaCompilerHelper.java

License:Apache License

public void traceMethod(String className, final String method) {
    new ClassReader(inMemoryClassFileManager.classBytes(className)).accept(new ClassVisitor(Opcodes.ASM5) {
        PrintWriter pw = new PrintWriter(System.out);
        Textifier p = new Textifier();

        @Override//from   ww w.ja v  a  2s. co m
        public MethodVisitor visitMethod(int access, String name, String desc, String signature,
                String[] exceptions) {
            if (name.equals(method)) {
                p.visitMethod(access, name, desc, signature, exceptions);
                return new TraceMethodVisitor(p);
            }
            return null;
        }

        @Override
        public void visitEnd() {
            p.visitClassEnd();
            if (pw != null) {
                p.print(pw);
                pw.flush();
            }
        }
    }, ClassReader.SKIP_FRAMES);

}

From source file:org.revapi.java.compilation.ClassTreeInitializer.java

License:Apache License

private void processClassBytes(final Archive currentArchive, InputStream data, final InitTreeContext context)
        throws IOException {

    ClassReader classReader = new ClassReader(data);

    classReader.accept(new ClassVisitor(Opcodes.ASM5) {

        private String visitedClassInternalName;
        private String visitedClassBinaryName;
        private String[] visitedClassOwners;
        private boolean isInnerClass;
        private int visitedInnerClassAccess;

        private TypeTreeConstructor.ClassProcessor classProcessor;

        @Override//  w  ww  .j av  a2s.  co  m
        public void visit(int version, int access, String name, String signature, String superName,
                String[] interfaces) {

            visitedClassInternalName = name;
            visitedClassBinaryName = Type.getObjectType(name).getClassName();

            boolean visible = isAccessible(access);
            boolean isPublicAPI = !context.processingSupplementaryArchives && visible;

            classProcessor = context.typeTreeConstructor.createApiClassProcessor(currentArchive,
                    visitedClassBinaryName, isPublicAPI);

            //add the superclass and interface use sites
            reportUse(Type.getObjectType(superName), UseSite.Type.IS_INHERITED, RawUseSite.SiteType.CLASS, null,
                    null, -1);

            for (String iface : interfaces) {
                reportUse(Type.getObjectType(iface), UseSite.Type.IS_IMPLEMENTED, RawUseSite.SiteType.CLASS,
                        null, null, -1);
            }

            if (name.indexOf('$') >= 0) {
                visitedClassOwners = name.split("\\$");
            }

            if (LOG.isTraceEnabled()) {
                LOG.trace("visit(): name={}, signature={}, access=0x{}", name, signature,
                        Integer.toHexString(access));
            }
        }

        @Override
        public FieldVisitor visitField(int access, final String name, final String desc, String signature,
                Object value) {
            //only consider public or protected fields - only those contribute to the API
            if (isAccessible(access)) {
                reportUse(Type.getType(desc), UseSite.Type.HAS_TYPE, RawUseSite.SiteType.FIELD, name, desc, -1);

                return new FieldVisitor(Opcodes.ASM5) {
                    @Override
                    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
                        reportUse(Type.getType(desc), UseSite.Type.ANNOTATES, RawUseSite.SiteType.FIELD, name,
                                desc, -1);
                        return null;
                    }
                };
            }

            return null;
        }

        @Override
        public void visitInnerClass(String name, String outerName, String innerName, int access) {
            LOG.trace("Visiting inner class spec {} {}", innerName, outerName);

            boolean isThisClass = visitedClassInternalName.equals(name);

            if (isThisClass) {
                visitedInnerClassAccess = access;
            }

            isInnerClass = isInnerClass || isThisClass;

            if (isThisClass || isTransitiveOwnerOfVisitedClass(name)) {
                //visiting some outer class of the currently processed class
                classProcessor.getInnerClassHierarchyConstructor().addName(outerName, innerName);
            }
        }

        @Override
        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
            reportUse(Type.getType(desc), UseSite.Type.ANNOTATES, RawUseSite.SiteType.CLASS, null, null, -1);

            return null;
        }

        @Override
        public MethodVisitor visitMethod(int access, final String name, final String desc, String signature,
                String[] exceptions) {

            LOG.trace("Visiting method {} {}", name, desc);

            //only consider public or protected methods - only those contribute to the API
            if (isAccessible(access)) {

                Type[] argumentTypes = Type.getArgumentTypes(desc);

                reportUse(Type.getReturnType(desc), UseSite.Type.RETURN_TYPE, RawUseSite.SiteType.METHOD, name,
                        desc, -1);

                //instance inner classes synthesize their constructors to always have the enclosing type as the
                //first parameter. Ignore that parameter for usage reporting.
                int ai = isInnerClass && "<init>".equals(name)
                        && (visitedInnerClassAccess & Opcodes.ACC_STATIC) == 0 ? 1 : 0;

                while (ai < argumentTypes.length) {
                    Type t = argumentTypes[ai];
                    reportUse(t, UseSite.Type.PARAMETER_TYPE, RawUseSite.SiteType.METHOD_PARAMETER, name, desc,
                            ai++);
                }

                if (exceptions != null && exceptions.length > 0) {
                    for (String ex : exceptions) {
                        reportUse(Type.getObjectType(ex), UseSite.Type.IS_THROWN, RawUseSite.SiteType.METHOD,
                                name, desc, -1);
                    }
                }

                return new MethodVisitor(Opcodes.ASM5) {
                    @Override
                    public AnnotationVisitor visitAnnotation(String annotationDesc, boolean visible) {
                        reportUse(Type.getType(annotationDesc), UseSite.Type.ANNOTATES,
                                RawUseSite.SiteType.METHOD, name, desc, -1);
                        return null;
                    }

                    @Override
                    public AnnotationVisitor visitParameterAnnotation(int parameter, String parameterDesc,
                            boolean visible) {
                        reportUse(Type.getType(parameterDesc), UseSite.Type.ANNOTATES,
                                RawUseSite.SiteType.METHOD_PARAMETER, name, desc, parameter);
                        return null;
                    }
                };
            }

            return null;
        }

        @Override
        public void visitEnd() {
            if (LOG.isTraceEnabled()) {
                LOG.trace("Visited {}, isInner={}, onlyAdditional={}", visitedClassInternalName, isInnerClass,
                        context.processingSupplementaryArchives);
            }

            classProcessor.commitClass();
        }

        private void reportUse(Type t, UseSite.Type useType, RawUseSite.SiteType siteType, String siteName,
                String siteDescriptor, int sitePosition) {

            if (skipUseTracking) {
                return;
            }

            if (t.getSort() < Type.ARRAY) {
                //primitive type
                return;
            }

            if (ignoreMissingAnnotations && useType == UseSite.Type.ANNOTATES) {
                return;
            }

            String binaryName = t.getClassName();
            RawUseSite useSite = new RawUseSite(useType, siteType, visitedClassBinaryName, siteName,
                    siteDescriptor, sitePosition);

            switch (t.getSort()) {
            case Type.OBJECT:
                classProcessor.addUse(binaryName, useSite);
                break;
            case Type.ARRAY:
                String desc = t.getDescriptor();
                desc = desc.substring(desc.lastIndexOf('[') + 1);
                reportUse(Type.getType(desc), useType, siteType, siteName, siteDescriptor, sitePosition);
                break;
            case Type.METHOD:
                throw new AssertionError("A method type should not enter here.");
                //all other cases are primitive types that we don't need to consider
            }
        }

        private boolean isTransitiveOwnerOfVisitedClass(String owningClass) {
            if (visitedClassOwners == null) {
                return false;
            }

            if (owningClass.length() > visitedClassInternalName.length()) {
                return false;
            }

            int startIdx = 0;
            int dollarIdx = owningClass.indexOf('$');
            int ownerIdx = 0;

            while (dollarIdx >= 0 && ownerIdx < visitedClassOwners.length) {
                String owner = owningClass.substring(startIdx, dollarIdx);
                if (!visitedClassOwners[ownerIdx++].equals(owner)) {
                    return false;
                }

                startIdx = dollarIdx + 1;
                dollarIdx = owningClass.indexOf('$', startIdx);
            }

            if (ownerIdx < visitedClassOwners.length) {
                return visitedClassOwners[ownerIdx].equals(owningClass.substring(startIdx));
            } else {
                return dollarIdx == -1;
            }
        }
    }, ClassReader.SKIP_CODE);
}

From source file:org.sonar.java.bytecode.cfg.Instructions.java

License:Open Source License

static BytecodeCFG getBytecodeCFG(byte[] bytes) {
    ClassReader cr = new ClassReader(bytes);
    BytecodeCFGMethodVisitor cfgMethodVisitor = new BytecodeCFGMethodVisitor();
    cr.accept(new ClassVisitor(ASM_API_VERSION) {
        @Override/*from  w  w  w  .  ja  v  a  2s  .  co  m*/
        public MethodVisitor visitMethod(int access, String name, String desc, String signature,
                String[] exceptions) {
            return cfgMethodVisitor;
        }
    }, 0);
    return cfgMethodVisitor.getCfg();
}

From source file:org.sonar.java.resolve.AsmExample.java

License:Open Source License

public static void main(String[] args) throws Exception {
    ClassVisitor cv = new ClassVisitor(Opcodes.ASM5) {
        @Override/*from  ww w.j  a  v a  2 s.c  om*/
        public void visit(int version, int access, String name, String signature, String superName,
                String[] interfaces) {
            System.out.println("CLASS");
            System.out.println("access: " + asFlagSet(access));
            System.out.println("name: " + name);
            System.out.println("signature: " + signature);
            System.out.println("superName: " + superName);
            System.out.println("interfaces: " + Arrays.toString(interfaces));
            System.out.println();
        }

        @Override
        public void visitSource(String source, String debug) {
            System.out.println("SOURCE");
            System.out.println();
        }

        @Override
        public void visitOuterClass(String owner, String name, String desc) {
            System.out.println("OUTER CLASS");
            System.out.println("owner: " + owner);
            System.out.println("name: " + name);
            System.out.println("desc: " + desc);
            System.out.println();
        }

        @Override
        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
            System.out.println("ANNOTATION");
            System.out.println("desc: " + desc);
            System.out.println("visible: " + visible);
            return null;
        }

        @Override
        public void visitAttribute(Attribute attr) {
            System.out.println("ATTRIBUTE");
            System.out.println();
        }

        @Override
        public void visitInnerClass(String name, String outerName, String innerName, int access) {
            System.out.println("INNER CLASS");
            System.out.println("access: " + asFlagSet(access));
            System.out.println("name: " + name);
            System.out.println("outerName: " + outerName);
            System.out.println("innerName: " + innerName);
            System.out.println();
        }

        @Override
        public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {
            System.out.println("FIELD");
            System.out.println("access: " + asFlagSet(access));
            System.out.println("name: " + name);
            System.out.println("desc: " + desc);
            System.out.println("signature: " + desc);
            System.out.println();
            return null;
        }

        @Override
        public MethodVisitor visitMethod(int access, String name, String desc, String signature,
                String[] exceptions) {
            System.out.println("METHOD");
            System.out.println("access: " + asFlagSet(access));
            System.out.println("name: " + name);
            System.out.println("desc: " + desc);
            System.out.println("signature: " + desc);
            System.out.println("exceptions: " + Arrays.toString(exceptions));
            System.out.println();
            return null;
        }

        @Override
        public void visitEnd() {
            System.out.println("END");
        }

        public EnumSet<Flag> asFlagSet(int flags) {
            EnumSet<Flag> result = EnumSet.noneOf(Flag.class);
            int mask = 1;
            for (int i = 0; i < 15; i++) {
                if ((flags & mask) != 0) {
                    result.add(Flag.values()[i]);
                }
                mask = mask << 1;
            }
            return result;
        }

    };

    InputStream in = AsmExample.class.getResourceAsStream("/org/sonar/java/resolve/AsmExample.class");
    ClassReader classReader = new ClassReader(in);
    classReader.accept(cv, 0);
}

From source file:org.tomitribe.crest.maven.CrestCommandLoaderDescriptorGeneratorMojo.java

License:Apache License

private String commandName(final File classFile) throws IOException {
    try (InputStream stream = new FileInputStream(classFile)) {
        final ClassReader reader = new ClassReader(stream);
        reader.accept(new ClassVisitor(ASM5) {
            private String className;

            @Override// w w w. j  a  va2 s  . com
            public void visit(final int version, final int access, final String name, final String signature,
                    final String superName, final String[] interfaces) {
                className = name.replace('/', '.');
            }

            @Override
            public AnnotationVisitor visitAnnotation(final String desc, final boolean visible) {
                checkAnnotation(desc);
                return super.visitAnnotation(desc, visible);
            }

            @Override
            public MethodVisitor visitMethod(final int access, final String name, final String desc,
                    final String signature, final String[] exceptions) {
                return new MethodVisitor(ASM5) {
                    @Override
                    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
                        checkAnnotation(desc);
                        return super.visitAnnotation(desc, visible);
                    }
                };
            }

            private void checkAnnotation(final String desc) {
                if (COMMAND_MARKER.equals(desc) || INTERCEPTOR_MARKER.equals(desc)) {
                    throw new CommandFoundException(className);
                }
            }
        }, SKIP_CODE + SKIP_DEBUG + SKIP_FRAMES);
    } catch (final CommandFoundException cfe) {
        return cfe.getMessage(); // class name
    }
    return null;
}

From source file:rubah.update.ProgramUpdate.java

License:Open Source License

private void findConverted(UpdateClass updateClass, final Namespace n0) {
    new ClassReader(updateClass.getBytes()).accept(new ClassVisitor(Opcodes.ASM5) {
        @Override//  ww w  .j  a  v a 2s.  c o  m
        public MethodVisitor visitMethod(int access, String name, String desc, String signature,
                String[] exceptions) {

            Clazz c0;

            if (name.equals(UpdateClassGenerator.METHOD_NAME)) {
                String c0Name = Type.getArgumentTypes(desc)[0].getClassName();
                c0Name = c0Name.replaceFirst(UpdateClassGenerator.V0_PREFFIX + "\\.", "");
                c0 = n0.getClass(Type.getObjectType(c0Name.replace('.', '/')));

                String c1Name = Type.getArgumentTypes(desc)[1].getClassName();
                c1Name = c1Name.replaceFirst(UpdateClassGenerator.V1_PREFFIX + "\\.", "");

                ProgramUpdate.this.converted.add(c0);
            } else if (name.equals(UpdateClassGenerator.METHOD_NAME_STATIC)) {
                String c1Name = Type.getArgumentTypes(desc)[0].getClassName();
                c1Name = c1Name.replaceFirst(UpdateClassGenerator.V1_PREFFIX + "\\.", "");
                c0 = n0.getClass(Type.getObjectType(c1Name.replace('.', '/')));

                ProgramUpdate.this.converted.add(c0);
            }

            return null;
        }
    }, ClassReader.SKIP_CODE);
}

From source file:scouter.agent.AgentTransformer.java

License:Apache License

public byte[] transform(final ClassLoader loader, String className, final Class classBeingRedefined,
        ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
    try {//from  w  w w  . jav  a 2  s  .c o  m
        hookingCtx.set(loader);

        //            if(className != null && (className.indexOf("http") >= 0 || className.indexOf("Http") >= 0)) {
        //                System.out.println("[!!!!!!!!] loading ...http className = " + className);
        //            }

        if (className == null)
            return null;
        if (classBeingRedefined == null) {
            if (asynchook.contains(className.hashCode())) {
                AsyncRunner.getInstance().add(loader, className, classfileBuffer);
                return null;
            }
            if (loader == null) {
                if (conf._hook_boot_prefix == null || conf._hook_boot_prefix.length() == 0
                        || false == className.startsWith(conf._hook_boot_prefix)) {
                    return null;
                }
            }
        }
        if (className.startsWith("scouter/")) {
            return null;
        }
        //
        classfileBuffer = DirectPatch.patch(className, classfileBuffer);
        ObjTypeDetector.check(className);
        final ClassDesc classDesc = new ClassDesc();
        ClassReader cr = new ClassReader(classfileBuffer);
        cr.accept(new ClassVisitor(Opcodes.ASM7) {
            public void visit(int version, int access, String name, String signature, String superName,
                    String[] interfaces) {
                classDesc.set(version, access, name, signature, superName, interfaces);
                if (conf._hook_map_impl_enabled) {
                    classDesc.isMapImpl = isMapImpl(superName, interfaces, loader);
                }
                super.visit(version, access, name, signature, superName, interfaces);
            }

            @Override
            public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
                classDesc.anotation += desc;
                return super.visitAnnotation(desc, visible);
            }
        }, 0);
        if (AsmUtil.isInterface(classDesc.access)) {
            return null;
        }
        classDesc.classBeingRedefined = classBeingRedefined;
        ClassWriter cw = getClassWriter(classDesc);
        ClassVisitor cv = cw;
        List<IASM> workAsms = asms;
        for (int i = workAsms.size() - 1; i >= 0; i--) {
            cv = workAsms.get(i).transform(cv, className, classDesc);
            if (cv != cw) {
                cr = new ClassReader(classfileBuffer);
                cr.accept(cv, ClassReader.EXPAND_FRAMES);
                classfileBuffer = cw.toByteArray();
                cv = cw = getClassWriter(classDesc);
                if (conf._log_asm_enabled) {
                    if (this.bciOut == null) {
                        this.bciOut = new Logger.FileLog("./scouter.bci");
                    }
                    this.bciOut.println(className + "\t\t[" + loader + "]");
                }
            }
        }
        return classfileBuffer;
    } catch (Throwable t) {
        Logger.println("A101", "Transformer Error : " + className, t);
        t.printStackTrace();
    } finally {
        hookingCtx.set(null);
    }
    return null;
}