Examples with ClassVisitor org.objectweb.asm.ClassVisitor used on opensource projects

Example 16 with ClassVisitor

use of org.objectweb.asm.ClassVisitor in project bazel by bazelbuild.

the class IjarTests method innerClasses.

static Map<String, String> innerClasses(byte[] bytes) {
    final Map<String, String> innerClasses = new HashMap<>();
    new ClassReader(bytes).accept(new ClassVisitor(Opcodes.ASM5) {

        @Override
        public void visitInnerClass(String name, String outerName, String innerName, int access) {
            innerClasses.put(name, String.valueOf(outerName));
        }
    }, /*flags=*/
    0);
    return innerClasses;
}

Example 17 with ClassVisitor

use of org.objectweb.asm.ClassVisitor in project groovy-core by groovy.

the class MetaClassImpl method getClassNode.

/**
     * Obtains a reference to the original AST for the MetaClass if it is available at runtime
     *
     * @return The original AST or null if it cannot be returned
     */
public ClassNode getClassNode() {
    if (classNode == null && GroovyObject.class.isAssignableFrom(theClass)) {
        // let's try load it from the classpath
        String groovyFile = theClass.getName();
        int idx = groovyFile.indexOf('$');
        if (idx > 0) {
            groovyFile = groovyFile.substring(0, idx);
        }
        groovyFile = groovyFile.replace('.', '/') + ".groovy";
        //System.out.println("Attempting to load: " + groovyFile);
        URL url = theClass.getClassLoader().getResource(groovyFile);
        if (url == null) {
            url = Thread.currentThread().getContextClassLoader().getResource(groovyFile);
        }
        if (url != null) {
            try {
                /**
                     * todo there is no CompileUnit in scope so class name
                     * checking won't work but that mostly affects the bytecode
                     * generation rather than viewing the AST
                     */
                CompilationUnit.ClassgenCallback search = new CompilationUnit.ClassgenCallback() {

                    public void call(ClassVisitor writer, ClassNode node) {
                        if (node.getName().equals(theClass.getName())) {
                            MetaClassImpl.this.classNode = node;
                        }
                    }
                };
                final ClassLoader parent = theClass.getClassLoader();
                CompilationUnit unit = new CompilationUnit();
                unit.setClassgenCallback(search);
                unit.addSource(url);
                unit.compile(Phases.CLASS_GENERATION);
            } catch (Exception e) {
                throw new GroovyRuntimeException("Exception thrown parsing: " + groovyFile + ". Reason: " + e, e);
            }
        }
    }
    return classNode;
}

Example 18 with ClassVisitor

use of org.objectweb.asm.ClassVisitor in project gradle by gradle.

the class RuntimeShadedJarCreator method remapClass.

private byte[] remapClass(String className, byte[] bytes) {
    ClassReader classReader = new ClassReader(bytes);
    ClassWriter classWriter = new ClassWriter(0);
    ClassVisitor remappingVisitor = new ShadingClassRemapper(classWriter, remapper);
    try {
        classReader.accept(remappingVisitor, ClassReader.EXPAND_FRAMES);
    } catch (Exception e) {
        throw new GradleException("Error in ASM processing class: " + className, e);
    }
    return classWriter.toByteArray();
}

Example 19 with ClassVisitor

use of org.objectweb.asm.ClassVisitor in project gwt-test-utils by gwt-test-utils.

the class OverlayTypesRewriter method rewrite.

/**
     * Performs rewriting transformations on a class.
     *
     * @param className  the name of the class
     * @param classBytes the bytes of the class
     */
public byte[] rewrite(String className, byte[] classBytes) {
    Event classBytesRewriteEvent = SpeedTracerLogger.start(DevModeEventType.CLASS_BYTES_REWRITE, "Class Name", className);
    String desc = toDescriptor(className);
    assert !jsoIntfDescs.contains(desc);
    // The ASM model is to chain a bunch of visitors together.
    ClassWriter writer = new ClassWriter(0);
    ClassVisitor v = writer;
    // v = new CheckClassAdapter(v);
    // v = new TraceClassVisitor(v, new PrintWriter(System.out));
    v = new UseMirroredClasses(v, className);
    v = new RewriteSingleJsoImplDispatches(v, typeOracle, jsoData);
    v = new RewriteRefsToJsoClasses(v, jsoIntfDescs, mapper);
    if (jsoImplDescs.contains(desc)) {
        v = WriteJsoImpl.create(v, desc, jsoIntfDescs, mapper, jsoData);
    }
    if (Double.parseDouble(System.getProperty("java.class.version")) < Opcodes.V1_6) {
        v = new ForceClassVersion15(v);
    }
    new ClassReader(classBytes).accept(v, 0);
    classBytesRewriteEvent.end();
    return writer.toByteArray();
}

Example 20 with ClassVisitor

use of org.objectweb.asm.ClassVisitor in project android_frameworks_base by DirtyUnicorns.

the class AsmGenerator method transform.

/**
     * Transforms a class.
     * <p/>
     * There are 3 kind of transformations:
     *
     * 1- For "mock" dependencies classes, we want to remove all code from methods and replace
     * by a stub. Native methods must be implemented with this stub too. Abstract methods are
     * left intact. Modified classes must be overridable (non-private, non-final).
     * Native methods must be made non-final, non-private.
     *
     * 2- For "keep" classes, we want to rewrite all native methods as indicated above.
     * If a class has native methods, it must also be made non-private, non-final.
     *
     * Note that unfortunately static methods cannot be changed to non-static (since static and
     * non-static are invoked differently.)
     */
byte[] transform(ClassReader cr, boolean stubNativesOnly) {
    boolean hasNativeMethods = hasNativeMethods(cr);
    // Get the class name, as an internal name (e.g. com/android/SomeClass$InnerClass)
    String className = cr.getClassName();
    String newName = transformName(className);
    // transformName returns its input argument if there's no need to rename the class
    if (!newName.equals(className)) {
        mRenameCount++;
        // This class is being renamed, so remove it from the list of classes not renamed.
        mClassesNotRenamed.remove(className);
    }
    mLog.debug("Transform %s%s%s%s", className, newName.equals(className) ? "" : " (renamed to " + newName + ")", hasNativeMethods ? " -- has natives" : "", stubNativesOnly ? " -- stub natives only" : "");
    // Rewrite the new class from scratch, without reusing the constant pool from the
    // original class reader.
    ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
    ClassVisitor cv = cw;
    // FIXME Generify
    if ("android/content/res/Resources".equals(className)) {
        cv = new FieldInjectorAdapter(cv);
    }
    if (mReplaceMethodCallsClasses.contains(className)) {
        cv = new ReplaceMethodCallsAdapter(cv, className);
    }
    cv = new RefactorClassAdapter(cv, mRefactorClasses);
    if (!newName.equals(className)) {
        cv = new RenameClassAdapter(cv, className, newName);
    }
    String binaryNewName = newName.replace('/', '.');
    if (mInjectedMethodsMap.keySet().contains(binaryNewName)) {
        cv = new InjectMethodsAdapter(cv, mInjectedMethodsMap.get(binaryNewName));
    }
    cv = new TransformClassAdapter(mLog, mStubMethods, mDeleteReturns.get(className), newName, cv, stubNativesOnly);
    Set<String> delegateMethods = mDelegateMethods.get(className);
    if (delegateMethods != null && !delegateMethods.isEmpty()) {
        // known to have no native methods, just skip this step.
        if (hasNativeMethods || !(delegateMethods.size() == 1 && delegateMethods.contains(DelegateClassAdapter.ALL_NATIVES))) {
            cv = new DelegateClassAdapter(mLog, cv, className, delegateMethods);
        }
    }
    Set<String> promoteFields = mPromotedFields.get(className);
    if (promoteFields != null && !promoteFields.isEmpty()) {
        cv = new PromoteFieldClassAdapter(cv, promoteFields);
    }
    cr.accept(cv, 0);
    return cw.toByteArray();
}