| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.OutputStream; |
| import java.io.PrintWriter; |
| import java.util.Date; |
| import java.util.Hashtable; |
| import java.util.StringTokenizer; |
| |
| import org.apache.commons.bcel6.Constants; |
| import org.apache.commons.bcel6.Repository; |
| import org.apache.commons.bcel6.classfile.Attribute; |
| import org.apache.commons.bcel6.classfile.ClassParser; |
| import org.apache.commons.bcel6.classfile.Code; |
| import org.apache.commons.bcel6.classfile.ConstantValue; |
| import org.apache.commons.bcel6.classfile.Deprecated; |
| import org.apache.commons.bcel6.classfile.ExceptionTable; |
| import org.apache.commons.bcel6.classfile.Field; |
| import org.apache.commons.bcel6.classfile.JavaClass; |
| import org.apache.commons.bcel6.classfile.Method; |
| import org.apache.commons.bcel6.classfile.Synthetic; |
| import org.apache.commons.bcel6.classfile.Utility; |
| import org.apache.commons.bcel6.generic.BranchHandle; |
| import org.apache.commons.bcel6.generic.BranchInstruction; |
| import org.apache.commons.bcel6.generic.CodeExceptionGen; |
| import org.apache.commons.bcel6.generic.ConstantPoolGen; |
| import org.apache.commons.bcel6.generic.Instruction; |
| import org.apache.commons.bcel6.generic.InstructionHandle; |
| import org.apache.commons.bcel6.generic.InstructionList; |
| import org.apache.commons.bcel6.generic.LineNumberGen; |
| import org.apache.commons.bcel6.generic.LocalVariableGen; |
| import org.apache.commons.bcel6.generic.MethodGen; |
| import org.apache.commons.bcel6.generic.ObjectType; |
| import org.apache.commons.bcel6.generic.Select; |
| import org.apache.commons.bcel6.generic.TABLESWITCH; |
| |
| /** |
| * Disassemble Java class object into the <a href="http://jasmin.sourceforge.net"> |
| * Jasmin</a> format. |
| * |
| * @author <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A> |
| * @version $Id$ |
| */ |
| public class JasminVisitor extends org.apache.commons.bcel6.classfile.EmptyVisitor { |
| private JavaClass clazz; |
| private PrintWriter out; |
| private String class_name; |
| private ConstantPoolGen cp; |
| |
| public JasminVisitor(JavaClass clazz, OutputStream out) { |
| this.clazz = clazz; |
| this.out = new PrintWriter(out); |
| this.class_name = clazz.getClassName(); |
| this.cp = new ConstantPoolGen(clazz.getConstantPool()); |
| } |
| |
| /** |
| * Start traversal using DefaultVisitor pattern. |
| */ |
| public void disassemble() { |
| new org.apache.commons.bcel6.classfile.DescendingVisitor(clazz, this).visit(); |
| out.close(); |
| } |
| |
| @Override |
| public void visitJavaClass(JavaClass clazz) { |
| out.println(";; Produced by JasminVisitor (BCEL)"); |
| out.println(";; http://commons.apache.org/bcel/"); |
| out.println(";; " + new Date() + "\n"); |
| |
| out.println(".source " + clazz.getSourceFileName()); |
| out.println("." + Utility.classOrInterface(clazz.getAccessFlags()) + " " + |
| Utility.accessToString(clazz.getAccessFlags(), true) + |
| " " + clazz.getClassName().replace('.', '/')); |
| out.println(".super " + clazz.getSuperclassName().replace('.', '/')); |
| |
| for (String iface : clazz.getInterfaceNames()) { |
| out.println(".implements " + iface.replace('.', '/')); |
| } |
| |
| out.print("\n"); |
| } |
| |
| @Override |
| public void visitField(Field field) { |
| out.print(".field " + Utility.accessToString(field.getAccessFlags()) + |
| " \"" + field.getName() + "\"" + field.getSignature()); |
| if (field.getAttributes().length == 0) { |
| out.print("\n"); |
| } |
| } |
| |
| @Override |
| public void visitConstantValue(ConstantValue cv) { |
| out.println(" = " + cv); |
| } |
| |
| private Method _method; |
| |
| /** |
| * Unfortunately Jasmin expects ".end method" after each method. Thus we've to check |
| * for every of the method's attributes if it's the last one and print ".end method" |
| * then. |
| */ |
| private void printEndMethod(Attribute attr) { |
| Attribute[] attributes = _method.getAttributes(); |
| |
| if (attr == attributes[attributes.length - 1]) { |
| out.println(".end method"); |
| } |
| } |
| |
| @Override |
| public void visitDeprecated(Deprecated attribute) { |
| printEndMethod(attribute); |
| } |
| |
| @Override |
| public void visitSynthetic(Synthetic attribute) { |
| if (_method != null) { |
| printEndMethod(attribute); |
| } |
| } |
| |
| @Override |
| public void visitMethod(Method method) { |
| this._method = method; // Remember for use in subsequent visitXXX calls |
| |
| out.println("\n.method " + Utility.accessToString(_method.getAccessFlags()) + |
| " " + _method.getName() + _method.getSignature()); |
| |
| Attribute[] attributes = _method.getAttributes(); |
| if ((attributes == null) || (attributes.length == 0)) { |
| out.println(".end method"); |
| } |
| } |
| |
| @Override |
| public void visitExceptionTable(ExceptionTable e) { |
| for (String name : e.getExceptionNames()) { |
| out.println(".throws " + name.replace('.', '/')); |
| } |
| |
| printEndMethod(e); |
| } |
| |
| private Hashtable<InstructionHandle, String> map; |
| |
| @Override |
| public void visitCode(Code code) { |
| int label_counter = 0; |
| |
| out.println(".limit stack " + code.getMaxStack()); |
| out.println(".limit locals " + code.getMaxLocals()); |
| |
| MethodGen mg = new MethodGen(_method, class_name, cp); |
| InstructionList il = mg.getInstructionList(); |
| InstructionHandle[] ihs = il.getInstructionHandles(); |
| |
| /* Pass 1: Give all referenced instruction handles a symbolic name, i.e. a |
| * label. |
| */ |
| map = new Hashtable<InstructionHandle, String>(); |
| |
| for (InstructionHandle ih1 : ihs) { |
| if (ih1 instanceof BranchHandle) { |
| BranchInstruction bi = (BranchInstruction) ih1.getInstruction(); |
| |
| if (bi instanceof Select) { // Special cases LOOKUPSWITCH and TABLESWITCH |
| for (InstructionHandle target : ((Select) bi).getTargets()) { |
| put(target, "Label" + label_counter++ + ":"); |
| } |
| } |
| |
| InstructionHandle ih = bi.getTarget(); |
| put(ih, "Label" + label_counter++ + ":"); |
| } |
| } |
| |
| LocalVariableGen[] lvs = mg.getLocalVariables(); |
| for (LocalVariableGen lv : lvs) { |
| InstructionHandle ih = lv.getStart(); |
| put(ih, "Label" + label_counter++ + ":"); |
| ih = lv.getEnd(); |
| put(ih, "Label" + label_counter++ + ":"); |
| } |
| |
| CodeExceptionGen[] ehs = mg.getExceptionHandlers(); |
| for (CodeExceptionGen c : ehs) { |
| InstructionHandle ih = c.getStartPC(); |
| |
| put(ih, "Label" + label_counter++ + ":"); |
| ih = c.getEndPC(); |
| put(ih, "Label" + label_counter++ + ":"); |
| ih = c.getHandlerPC(); |
| put(ih, "Label" + label_counter++ + ":"); |
| } |
| |
| LineNumberGen[] lns = mg.getLineNumbers(); |
| for (LineNumberGen ln : lns) { |
| InstructionHandle ih = ln.getInstruction(); |
| put(ih, ".line " + ln.getSourceLine()); |
| } |
| |
| // Pass 2: Output code. |
| for (LocalVariableGen l : lvs) { |
| out.println(".var " + l.getIndex() + " is " + l.getName() + " " + |
| l.getType().getSignature() + |
| " from " + get(l.getStart()) + |
| " to " + get(l.getEnd())); |
| } |
| |
| out.print("\n"); |
| |
| for (InstructionHandle ih : ihs) { |
| Instruction inst = ih.getInstruction(); |
| String str = map.get(ih); |
| |
| if (str != null) { |
| out.println(str); |
| } |
| |
| if (inst instanceof BranchInstruction) { |
| if (inst instanceof Select) { // Special cases LOOKUPSWITCH and TABLESWITCH |
| Select s = (Select) inst; |
| int[] matchs = s.getMatchs(); |
| InstructionHandle[] targets = s.getTargets(); |
| |
| if (s instanceof TABLESWITCH) { |
| out.println("\ttableswitch " + matchs[0] + " " + matchs[matchs.length - 1]); |
| |
| for (InstructionHandle target : targets) { |
| out.println("\t\t" + get(target)); |
| } |
| |
| } else { // LOOKUPSWITCH |
| out.println("\tlookupswitch "); |
| |
| for (int j = 0; j < targets.length; j++) { |
| out.println("\t\t" + matchs[j] + " : " + get(targets[j])); |
| } |
| } |
| |
| out.println("\t\tdefault: " + get(s.getTarget())); // Applies for both |
| } else { |
| BranchInstruction bi = (BranchInstruction) inst; |
| ih = bi.getTarget(); |
| str = get(ih); |
| out.println("\t" + Constants.OPCODE_NAMES[bi.getOpcode()] + " " + str); |
| } |
| } else { |
| out.println("\t" + inst.toString(cp.getConstantPool())); |
| } |
| } |
| |
| out.print("\n"); |
| |
| for (CodeExceptionGen c : ehs) { |
| ObjectType caught = c.getCatchType(); |
| String class_name = (caught == null) ? // catch any exception, used when compiling finally |
| "all" : caught.getClassName().replace('.', '/'); |
| |
| out.println(".catch " + class_name + " from " + |
| get(c.getStartPC()) + " to " + get(c.getEndPC()) + |
| " using " + get(c.getHandlerPC())); |
| } |
| |
| printEndMethod(code); |
| } |
| |
| private String get(InstructionHandle ih) { |
| String str = new StringTokenizer(map.get(ih), "\n").nextToken(); |
| return str.substring(0, str.length() - 1); |
| } |
| |
| private void put(InstructionHandle ih, String line) { |
| String str = map.get(ih); |
| |
| if (str == null) { |
| map.put(ih, line); |
| } else { |
| if (line.startsWith("Label") || str.endsWith(line)) { |
| return; |
| } |
| |
| map.put(ih, str + "\n" + line); // append |
| } |
| } |
| |
| public static void main(String[] argv) throws Exception { |
| JavaClass java_class; |
| |
| if (argv.length == 0) { |
| System.err.println("disassemble: No input files specified"); |
| return; |
| } |
| |
| for (String arg : argv) { |
| if ((java_class = Repository.lookupClass(arg)) == null) { |
| java_class = new ClassParser(arg).parse(); |
| } |
| |
| String class_name = java_class.getClassName(); |
| int index = class_name.lastIndexOf('.'); |
| String path = class_name.substring(0, index + 1).replace('.', File.separatorChar); |
| class_name = class_name.substring(index + 1); |
| |
| if (!path.equals("")) { |
| File f = new File(path); |
| f.mkdirs(); |
| } |
| |
| String name = path + class_name + ".j"; |
| FileOutputStream out = new FileOutputStream(name); |
| new JasminVisitor(java_class, out).disassemble(); |
| System.out.println("File dumped to: " + name); |
| } |
| } |
| } |