Refine search
@Override public void visitFile(Path file, String relative) throws IOException { if (relative.endsWith(".class")) { byte data[] = Files.readAllBytes(file); new ClassReader(data).accept(collectVisitor, ClassReader.EXPAND_FRAMES); } } });
public DumpClass(InputStream is) throws IOException { super(Constants.KILIM_ASM); ClassReader cr = new ClassReader(is); cr.accept(this, /*flags*/ 0); }
public DumpClass(String className) throws IOException { super(Constants.KILIM_ASM); ClassReader cr; if (className.endsWith(".class")) { FileInputStream fis = new FileInputStream(className); cr = new ClassReader(fis); } else { cr = new ClassReader(className); } cr.accept(this, /*flags*/ClassReader.EXPAND_FRAMES); }
fieldCount = 0; ClassReader cr = new ClassReader(bytes); ClassVisitor cv = new ClassVisitor(Opcodes.ASM4) { String className; cr.accept(cv, 0);
private void compareClass(InputStream input) throws IOException { byte[] buffer = IOUtils.toByteArray(input); ClassReader reader = new ClassReader(buffer); reader.accept(visitor, 0); }
private ClassNode readClassNode(byte[] data) { ClassReader cr = new ClassReader(data); ClassNode cn = new ClassNode(); cr.accept(cn, ClassReader.EXPAND_FRAMES | ClassReader.SKIP_FRAMES); return cn; }
public void wave0(byte[] data, final ClassVisitor cv) throws IOException { new ClassReader(data).accept(wrapper(cv), ClassReader.EXPAND_FRAMES); }
public void init() { try { InputStream in = HydrationScanner.class.getClassLoader().getResourceAsStream(topEntityClass.getName().replace('.', '/') + ".class"); new ClassReader(in).accept(this, ClassReader.SKIP_DEBUG); in = HydrationScanner.class.getClassLoader().getResourceAsStream(entityClass.getName().replace('.', '/') + ".class"); new ClassReader(in).accept(this, ClassReader.SKIP_DEBUG); } catch (IOException e) { throw new RuntimeException(e); } }
private ClassNode loadClassNode(String name) { String classFileName = name.replace('.', '/') + ".class"; ZipEntry entry = jarFile.getEntry(classFileName); if (entry == null) { return null; } try (InputStream inputStream = jarFile.getInputStream(entry)) { ClassReader classReader = new ClassReader(inputStream); ClassNode classNode = new ClassNode(); classReader.accept(classNode, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES); return classNode; } catch (IOException e) { throw new RuntimeException("failed to analyze " + classFileName + " in " + path, e); } }
private static void printClassBytes(byte[] byteCode) { if (DEBUG) { TraceClassVisitor visitor = new TraceClassVisitor(new PrintWriter(System.out)); new ClassReader(byteCode).accept(visitor, 0); } }
public ClassMirror(byte []bytecode) { ClassReader cr = new ClassReader(bytecode); Visitor visitor = new Visitor(); cr.accept(visitor, /*flags*/0); }
private static boolean readDescriptor(ClassLoader classLoader, String className, PluginDescriptor descriptor) throws IOException { try (InputStream input = classLoader.getResourceAsStream(className.replace('.', '/') + ".class")) { if (input == null) { return false; } ClassReader reader = new ClassReader(new BufferedInputStream(input)); PluginDescriptorFiller filler = new PluginDescriptorFiller(descriptor); reader.accept(filler, 0); return true; } }
private ClassNode createClassNode(String internalClassName) throws ClassNotFoundException { byte[] byteCode = getClassBytes(internalClassName); ClassReader classReader = new ClassReader(byteCode); ClassNode classNode = new ClassNode(); classReader.accept(classNode, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES); return classNode; }
private static String getClassName(byte[] bytes) { try { final ClassDesc classDesc = new ClassDesc(); ClassReader cr = new ClassReader(bytes); 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); } }, 0); return classDesc.name.replace('.', '/'); } catch (Throwable t) { return null; } }
public MutableClass analyzeClass( byte[] origClassBytes, final InstrumentationConfiguration config, ClassNodeProvider classNodeProvider) { ClassNode classNode = new ClassNode(Opcodes.ASM4) { @Override public FieldVisitor visitField( int access, String name, String desc, String signature, Object value) { desc = config.remapParamType(desc); return super.visitField(access & ~Opcodes.ACC_FINAL, name, desc, signature, value); } @Override public MethodVisitor visitMethod( int access, String name, String desc, String signature, String[] exceptions) { MethodVisitor methodVisitor = super.visitMethod(access, name, config.remapParams(desc), signature, exceptions); return new JSRInlinerAdapter(methodVisitor, access, name, desc, signature, exceptions); } }; final ClassReader classReader = new ClassReader(origClassBytes); classReader.accept(classNode, 0); return new MutableClass(classNode, config, classNodeProvider); }
ClassReader cr = new ClassReader(new FileInputStream("HelloWorld.class")); cr.accept(new ASMifierClassVisitor(new PrintWriter(System.out)), 0);
private void disassemble1(Path file, Path output) throws IOException { ClassReader r = new ClassReader(Files.readAllBytes(file)); Path jFile = output.resolve(r.getClassName().replace('.', '/') + ".j"); createParentDirectories(jFile); try (BufferedWriter out = Files.newBufferedWriter(jFile, Charset.forName(encoding))) { PrintWriter pw = new PrintWriter(out); ClassNode node = new ClassNode(); r.accept(node, (debugInfo ? 0 : ClassReader.SKIP_DEBUG) | ClassReader.EXPAND_FRAMES | ClassReader.SKIP_FRAMES); new JasminDumper(pw).dump(node); pw.flush(); } } }
if (file.getFileName().toString().endsWith(".class")) { final ClassReader r = new ClassReader(Files.readAllBytes(file)); r.accept(new ClassVisitor(ASM4, cr) {
/** {@inheritDoc} */ @Override public byte[] loadReplace(InputStream in, final String originalName, final String replaceName) { ClassReader rdr; try { rdr = new ClassReader(in); } catch (IOException e) { throw new RuntimeException(e); } ClassWriter w = new ClassWriter(Opcodes.ASM4); rdr.accept(new RemappingClassAdapter(w, new Remapper() { /** */ String replaceType = replaceName.replace('.', '/'); /** */ String nameType = originalName.replace('.', '/'); @Override public String map(String type) { if (type.equals(replaceType)) return nameType; return type; } }), ClassReader.EXPAND_FRAMES); return w.toByteArray(); }
T specialize(ImmutableMap<Class<?>, Class<?>> classRemapping) { String specializedClassName = specializedClassNamePrefix + specializedClassCounter.get(); ClassWriter specializedClassWriter = new ClassWriter(0); SimpleRemapper remapper = new SimpleRemapper(createRemapping(classRemapping, specializedClassName)); ClassVisitor classTransformer = new ClassRemapper(specializedClassWriter, remapper); try { ClassReader prototypeClassReader = new ClassReader(getPrototypeClassBytecode()); prototypeClassReader.accept(classTransformer, 0); byte[] specializedClassBytecode = specializedClassWriter.toByteArray(); Class<T> specializedClass = defineClass(specializedClassName, specializedClassBytecode); specializedClassCounter.incrementAndGet(); return specializedClass.newInstance(); } catch (InstantiationException | IllegalAccessException | IOException e) { throw new RuntimeException(e); } }