new TryCatchBlockNode(tryStart, tryEnd, catchStart, Type.getInternalName(BaseBaseException.class)) );
tryCatchBlockNode.accept(mv); try { pw.print(" " + buf.get(t));
void visitTryCatchBlocks(MethodVisitor mv) { MethodFlow mf = methodFlow; ArrayList<BasicBlock> bbs = mf.getBasicBlocks(); ArrayList<Handler> allHandlers = new ArrayList<Handler>(bbs.size() * 2); for (BasicBlock bb : bbs) { allHandlers.addAll(bb.handlers); } allHandlers = Handler.consolidate(allHandlers); for (Handler h : allHandlers) { new TryCatchBlockNode(mf.getLabelAt(h.from), mf.getOrCreateLabelAtPos(h.to+1), h.catchBB.startLabel, h.type).accept(mv); } }
tryCatchBlocks.get(i).updateIndex(i); tryCatchBlocks.get(i).accept(mv);
@Override public void visitEnd() { // Sort the TryCatchBlockNode elements by the length of their "try" block. Collections.sort( tryCatchBlocks, new Comparator<TryCatchBlockNode>() { @Override public int compare( final TryCatchBlockNode tryCatchBlockNode1, final TryCatchBlockNode tryCatchBlockNode2) { return blockLength(tryCatchBlockNode1) - blockLength(tryCatchBlockNode2); } private int blockLength(final TryCatchBlockNode tryCatchBlockNode) { int startIndex = instructions.indexOf(tryCatchBlockNode.start); int endIndex = instructions.indexOf(tryCatchBlockNode.end); return endIndex - startIndex; } }); // Update the 'target' of each try catch block annotation. for (int i = 0; i < tryCatchBlocks.size(); ++i) { tryCatchBlocks.get(i).updateIndex(i); } if (mv != null) { accept(mv); } } }
tryCatchBlocks.get(i).updateIndex(i); tryCatchBlocks.get(i).accept(methodVisitor);
@Override public void visitEnd() { // Compares TryCatchBlockNodes by the length of their "try" block. Comparator<TryCatchBlockNode> comp = new Comparator<TryCatchBlockNode>() { public int compare(TryCatchBlockNode t1, TryCatchBlockNode t2) { int len1 = blockLength(t1); int len2 = blockLength(t2); return len1 - len2; } private int blockLength(TryCatchBlockNode block) { int startidx = instructions.indexOf(block.start); int endidx = instructions.indexOf(block.end); return endidx - startidx; } }; Collections.sort(tryCatchBlocks, comp); // Updates the 'target' of each try catch block annotation. for (int i = 0; i < tryCatchBlocks.size(); ++i) { tryCatchBlocks.get(i).updateIndex(i); } if (mv != null) { accept(mv); } } }
public CodeBlock visitTryCatchBlock(final LabelNode scopeStart, final LabelNode scopeEnd, final LabelNode handler, final String exceptionType) { tryCatchBlockList.add(new TryCatchBlockNode(scopeStart, scopeEnd, handler, exceptionType)); return this; }
static void printAnalyzerResult(MethodNode method, Analyzer a, final PrintWriter pw) throws IllegalArgumentException, IllegalAccessException { Frame[] frames = a.getFrames(); Textifier t = new Textifier(); TraceMethodVisitor mv = new TraceMethodVisitor(t); String format = "%05d %-" + (method.maxStack + method.maxLocals + 6) + "s|%s"; for (int j = 0; j < method.instructions.size(); ++j) { method.instructions.get(j).accept(mv); StringBuffer s = new StringBuffer(); Frame f = frames[j]; if (f == null) { s.append('?'); } else { for (int k = 0; k < f.getLocals(); ++k) { s.append(getShortName(f.getLocal(k).toString())); } s.append(" : "); for (int k = 0; k < f.getStackSize(); ++k) { s.append(getShortName(f.getStack(k).toString())); } } pw.printf(format, j, s, buf.get(t)); // mv.text.get(j)); } for (int j = 0; j < method.tryCatchBlocks.size(); ++j) { ((TryCatchBlockNode) method.tryCatchBlocks.get(j)).accept(mv); pw.print(" " + buf.get(t)); } pw.println(); pw.flush(); }
@Override public void visitEnd() { // Sort the TryCatchBlockNode elements by the length of their "try" block. Collections.sort( tryCatchBlocks, new Comparator<TryCatchBlockNode>() { @Override public int compare( final TryCatchBlockNode tryCatchBlockNode1, final TryCatchBlockNode tryCatchBlockNode2) { return blockLength(tryCatchBlockNode1) - blockLength(tryCatchBlockNode2); } private int blockLength(final TryCatchBlockNode tryCatchBlockNode) { int startIndex = instructions.indexOf(tryCatchBlockNode.start); int endIndex = instructions.indexOf(tryCatchBlockNode.end); return endIndex - startIndex; } }); // Update the 'target' of each try catch block annotation. for (int i = 0; i < tryCatchBlocks.size(); ++i) { tryCatchBlocks.get(i).updateIndex(i); } if (mv != null) { accept(mv); } } }
public CodeBlock trycatch(final LabelNode scopeStart, final LabelNode scopeEnd, final LabelNode handler, final String exceptionType) { tryCatchBlockList.add(new TryCatchBlockNode(scopeStart, scopeEnd, handler, exceptionType)); return this; }
/** * Marks all labels of the method with control flow information. * * @param method * Method to mark labels */ public static void markLabels(final MethodNode method) { // We do not use the accept() method as ASM resets labels after every // call to accept() final MethodVisitor lfa = new LabelFlowAnalyzer(); for (int i = method.tryCatchBlocks.size(); --i >= 0;) { method.tryCatchBlocks.get(i).accept(lfa); } method.instructions.accept(lfa); }
@Override public void visitEnd() { // Sort the TryCatchBlockNode elements by the length of their "try" block. Collections.sort( tryCatchBlocks, new Comparator<TryCatchBlockNode>() { @Override public int compare( final TryCatchBlockNode tryCatchBlockNode1, final TryCatchBlockNode tryCatchBlockNode2) { return blockLength(tryCatchBlockNode1) - blockLength(tryCatchBlockNode2); } private int blockLength(final TryCatchBlockNode tryCatchBlockNode) { int startIndex = instructions.indexOf(tryCatchBlockNode.start); int endIndex = instructions.indexOf(tryCatchBlockNode.end); return endIndex - startIndex; } }); // Update the 'target' of each try catch block annotation. for (int i = 0; i < tryCatchBlocks.size(); ++i) { tryCatchBlocks.get(i).updateIndex(i); } if (mv != null) { accept(mv); } } }
public CodeBlock trycatch(final LabelNode scopeStart, final LabelNode scopeEnd, final LabelNode handler, @Nullable final String exceptionType) { tryCatchBlockList.add(new TryCatchBlockNode(scopeStart, scopeEnd, handler, exceptionType)); return this; }
@Override public void accept(final MethodNode methodNode, final MethodVisitor methodVisitor) { methodVisitor.visitCode(); for (final TryCatchBlockNode n : methodNode.tryCatchBlocks) { n.accept(methodVisitor); } currentNode = methodNode.instructions.getFirst(); while (currentNode != null) { currentNode.accept(methodVisitor); currentNode = currentNode.getNext(); } methodVisitor.visitEnd(); }
public CodeBlock visitTryCatchBlock(final LabelNode scopeStart, final LabelNode scopeEnd, final LabelNode handler, @Nullable final String exceptionType) { tryCatchBlockList.add(new TryCatchBlockNode(scopeStart, scopeEnd, handler, exceptionType)); return this; }
method.tryCatchBlocks.get(j).accept(mv); pw.print(" " + t.text.get(t.text.size() - 1));
public static List<TryCatchBlockNode> cloneTryCatchBlockNodes(List<TryCatchBlockNode> originalBlocks, CloneMap cloneMap) { List<TryCatchBlockNode> result = new LinkedList<TryCatchBlockNode>(); for (TryCatchBlockNode originalBlock : originalBlocks) { TryCatchBlockNode clonedBlock = new TryCatchBlockNode( cloneMap.get(originalBlock.start), cloneMap.get(originalBlock.end), cloneMap.get(originalBlock.handler), originalBlock.type ); result.add(clonedBlock); } return result; }
tryCatchBlock.accept(traceMethodVisitor); printWriter.print(" " + textifier.text.get(textifier.text.size() - 1));
@Override public void visitTryCatchBlock(final Label start, final Label end, final Label handler, final String type) { tryCatchBlocks.add(new TryCatchBlockNode(getLabelNode(start), getLabelNode(end), getLabelNode(handler), type)); }