private byte[] toByteArray(ClassNode cn) { ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); cn.accept(cw); return cw.toByteArray(); }
public void accept(ClassVisitor cv) throws RecognitionException{ sFile(); cn.accept(cv); } public ClassNode parse() throws RecognitionException {
byte[] instrumentToBytes(MutableClass mutableClass) { instrument(mutableClass); ClassNode classNode = mutableClass.classNode; ClassWriter writer = new InstrumentingClassWriter(mutableClass.classNodeProvider, classNode); Remapper remapper = new Remapper() { @Override public String map(final String internalName) { return mutableClass.config.mappedTypeName(internalName); } }; ClassRemapper visitor = new ClassRemapper(writer, remapper); classNode.accept(visitor); return writer.toByteArray(); }
private void assemble1(Path file, Path output) throws IOException { try (BufferedReader bufferedReader = Files.newBufferedReader(file, Charset.forName(encoding))) { ANTLRStringStream is = new ANTLRReaderStream(bufferedReader); is.name = file.toString(); JasminLexer lexer = new JasminLexer(is); CommonTokenStream ts = new CommonTokenStream(lexer); JasminParser parser = new JasminParser(ts); parser.rebuildLine = autogenLines; ClassWriter cw = new ClassWriter(noComputeMax?0:ClassWriter.COMPUTE_MAXS); ClassNode cn = parser.parse(); if (cn.version == 0) { cn.version = versions[classVersion]; } if (dump) { new JasminDumper(new PrintWriter(new OutputStreamWriter(System.out, StandardCharsets.UTF_8), true)).dump(cn); } cn.accept(cw); Path clzFile = output.resolve(cn.name.replace('.', '/') + ".class"); createParentDirectories(clzFile); Files.write(clzFile, cw.toByteArray()); } catch (RecognitionException e) { System.err.println("Fail to assemble " + file); e.printStackTrace(); } } }
public static String toStd(ClassNode expected) throws IOException { expected.access &= ~Opcodes.ACC_SUPER; ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); expected.accept(LdcOptimizeAdapter.wrap(cw)); ClassReader cr = new ClassReader(cw.toByteArray()); ClassNode n = new ClassNode(Opcodes.ASM4); cr.accept(n, ClassReader.EXPAND_FRAMES | ClassReader.SKIP_FRAMES); StringWriter stringWriter = new StringWriter(); new JasminDumper(new PrintWriter(stringWriter, true)).dump(n); return stringWriter.toString(); }
private void test0(InvocationWeaver iw, String prefix) throws IOException, RecognitionException { ClassNode before = Jasmins .parse(prefix + "-before.j", getClass().getResourceAsStream("/weave/" + prefix + "-before.j")); ClassNode expectedAfter = Jasmins .parse(prefix + "-after.j", getClass().getResourceAsStream("/weave/" + prefix + "-after.j")); ClassNode expectedGen = Jasmins .parse(prefix + "-gen.j", getClass().getResourceAsStream("/weave/" + prefix + "-gen.j")); ClassNode after = new ClassNode(); before.accept(iw.wrapper(after)); assertEqual(expectedAfter, after); ClassNode gen = new ClassNode(); iw.buildInvocationClz(LdcOptimizeAdapter.wrap(gen)); assertEqual(expectedGen, gen); }
@Override public String toString() { final StringWriter writer = new StringWriter(); this.rawNode.accept(new TraceClassVisitor(null, new Textifier(), new PrintWriter( writer))); return writer.toString(); }
public Class<?> defineClass(ClassNode def) { ClassWriter cw = new ClassWriter(0); def.accept(cw); byte[] bytes = cw.toByteArray(); if (DEBUG_DIR != null) { logger.debug("writing class {}", def.name); try { Path fn = DEBUG_DIR.resolve(def.name + ".class"); Files.createDirectories(fn.getParent()); Files.write(fn, bytes); } catch (IOException e) { logger.error("error writing class file " + def.name, e); } } String name = def.name.replace('/', '.'); logger.debug("defining class {} (internal name {})", name, def.name); try { Class<?> cls = defineClass(name, bytes, 0, bytes.length); logger.debug("defined class {}", cls); return cls; } catch (ClassFormatError e) { throw new IllegalArgumentException("Format error in class " + name, e); } } }
remapper.inputOutput.put( "appeng/api/parts/LayerBase", n.superName ); remapper.inputOutput.put( originalName, n.name ); n.accept( new RemappingClassAdapter( cw, remapper ) );
node.accept(cw);
public static byte[] writeClassToBytes(ClassNode classNode) { ClassWriter classWriter = new ClassWriter(0); classNode.accept(classWriter); return classWriter.toByteArray(); }
public static byte[] toBytecode(ClassNode classNode) { if (classNode == null) { throw new NullPointerException(); } ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); classNode.accept(cw); return cw.toByteArray(); }
void serialize(IConstructor c,OutputStream output) throws IOException { ClassNode cn = buildClass(c); ClassWriter cw = new ClassWriter(COMPUTE_FRAMES); cn.accept(cw); output.write(cw.toByteArray()); output.close(); }
private static void traceClassNode(String message, ClassNode cn) { if (logger.isTraceEnabled()) { ClassWriter cw = new ClassWriter(0); cn.accept(cw); traceBytes(message, cw.toByteArray()); } }
public static ClassNode clone(ClassNode node) { ClassNode cloned = new ClassNode(); node.accept(cloned); return cloned; }
public static byte[] transform(byte[] bytecode) { ClassNode classNode= new ClassNode(Opcodes.ASM5); InvokeDynamicConverter invokeDynamicConverter= new InvokeDynamicConverter(classNode); new ClassReader(bytecode).accept(invokeDynamicConverter, 0); ClassWriter cw= new ClassWriter(ClassWriter.COMPUTE_MAXS); classNode.accept(cw); return cw.toByteArray(); }
public byte[] inject(ClassReader cr) { ClassNode cn = new ClassNode(ASM4); cr.accept(cn, 0); if (shouldInject(cn)) { inject(cn); } ClassWriter classWriter = new ClassWriter(ASM4); cn.accept(classWriter); return classWriter.toByteArray(); }
public byte[] processClass(byte[] cIn, byte[] sIn) { ClassNode cClassNode = getClassNode(cIn); ClassNode sClassNode = getClassNode(sIn); processFields(cClassNode, sClassNode); processMethods(cClassNode, sClassNode); processInners(cClassNode, sClassNode); ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS); cClassNode.accept(writer); return writer.toByteArray(); }
public Tuple<Boolean, byte[]> modifyClass() { val ok = interceptor.interceptClass(classNode, className); if (!ok) return new Tuple(false, classFileBuffer); int count = modifyMethodCount(classNode.methods); if (count == 0) return new Tuple(false, classFileBuffer); val cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); classNode.accept(cw); val bytes = cw.toByteArray(); Debugs.writeClassFile(classNode, className, bytes); return new Tuple(true, bytes); }
private byte[] getInstrumentedBytes(ClassNode classNode, boolean containsStubs) throws ClassNotFoundException { if (InvokeDynamic.ENABLED) { new InvokeDynamicClassInstrumentor(classNode, containsStubs).instrument(); } else { new OldClassInstrumentor(classNode, containsStubs).instrument(); } ClassWriter writer = new InstrumentingClassWriter(classNode); classNode.accept(writer); return writer.toByteArray(); }