/*

  * 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.

  */

 package org.apache.commons.javaflow.bytecode.transformation.bcel;

 import java.io.OutputStream;

 import java.io.PrintWriter;

 import org.apache.bcel.Constants;

 import org.apache.bcel.classfile.Code;

 import org.apache.bcel.classfile.ConstantValue;

 import org.apache.bcel.classfile.Deprecated;

 import org.apache.bcel.classfile.ExceptionTable;

 import org.apache.bcel.classfile.Field;

 import org.apache.bcel.classfile.JavaClass;

 import org.apache.bcel.classfile.Method;

 import org.apache.bcel.classfile.Synthetic;

 import org.apache.bcel.classfile.Utility;

 import org.apache.bcel.generic.BranchInstruction;

 import org.apache.bcel.generic.CodeExceptionGen;

 import org.apache.bcel.generic.ConstantPoolGen;

 import org.apache.bcel.generic.Instruction;

 import org.apache.bcel.generic.InstructionHandle;

 import org.apache.bcel.generic.InstructionList;

 import org.apache.bcel.generic.LocalVariableGen;

 import org.apache.bcel.generic.MethodGen;

 import org.apache.bcel.generic.ObjectType;

 import org.apache.bcel.generic.Select;

 import org.apache.bcel.generic.TABLESWITCH;

 public final class DecompilingVisitor extends org.apache.bcel.classfile.EmptyVisitor {

         private JavaClass clazz;

         private PrintWriter out;

         private String clazzname;

         private ConstantPoolGen cp;

         public DecompilingVisitor(JavaClass clazz, OutputStream out) {

                 this.clazz = clazz;

                 this.out = new PrintWriter(out);

                 clazzname = clazz.getClassName();

                 cp = new ConstantPoolGen(clazz.getConstantPool());

         }

         public void start() {

                 new org.apache.bcel.classfile.DescendingVisitor(clazz, this).visit();

                 out.close();

         }

         public void visitJavaClass(JavaClass clazz) {

                 out.println("// source " + clazz.getSourceFileName());

                 out.println(Utility.accessToString(clazz.getAccessFlags(), true) + " "

                                 + Utility.classOrInterface(clazz.getAccessFlags()) + " "

                                 + clazz.getClassName().replace('.', '/'));

                 out.println("  extends " + clazz.getSuperclassName().replace('.', '/'));

                 String[] interfaces = clazz.getInterfaceNames();

                 if (interfaces.length > 0) {

                         out.print("  implements");

                         for (int i = 0; i < interfaces.length; i++)

                                 out.print(" " + interfaces[i].replace('.', '/'));

                         out.println();

                 }

                 out.println();

         }

         public void visitField(Field field) {

                 out.println("  " + Utility.accessToString(field.getAccessFlags()) + " "        

                                 + field.getType() + " " + field.getName() + ";");

                 /*if (field.getAttributes().length == 0)

                         out.print("\n");*/

         }

         public void visitConstantValue(ConstantValue cv) {

                 out.println(" = " + cv);

         }

         private Method _method;

         public void visitDeprecated(Deprecated attribute) {

         }

         public void visitSynthetic(Synthetic attribute) {

         }

         public void visitMethod(Method method) {

                 this._method = method; // Remember for use in subsequent visitXXX calls

                 out.println("\n  " + Utility.accessToString(_method.getAccessFlags())

                                 + " " + _method.getReturnType() + " " + _method.getName());

         }

         public void visitExceptionTable(ExceptionTable e) {

                 String[] names = e.getExceptionNames();

                 for (int i = 0; i < names.length; i++)

                         out.println("    throws " + names[i].replace('.', '/'));

         }

         public void visitCode(Code code) {

                 MethodGen mg = new MethodGen(_method, clazzname, cp);

                 InstructionList il = mg.getInstructionList();

                 InstructionHandle[] ihs = il.getInstructionHandles();

                 LocalVariableGen[] lvs = mg.getLocalVariables();

                 CodeExceptionGen[] ehs = mg.getExceptionHandlers();

                 for (int i = 0; i < lvs.length; i++) {

                         LocalVariableGen l = lvs[i];

                         out.println("    // local variable " + l.getIndex() + " is \"" + l.getName()

                                         + "\" " + l.getType() + " from "

                                         + l.getStart().getPosition() + " to "

                                         + l.getEnd().getPosition());

                 }

                 out.print("\n");

                 for (int i = 0; i < ihs.length; i++) {

                         InstructionHandle ih = ihs[i];

                         Instruction inst = ih.getInstruction();

                         out.print("    " + ih.getPosition());

                         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("  tableswitch " + matchs[0] + " "

                                                                 + matchs[matchs.length - 1]);

                                                 for (int j = 0; j < targets.length; j++)

                                                         out.println("        " + targets[j].getPosition());

                                         } else { // LOOKUPSWITCH

                                                 out.println("  lookupswitch ");

                                                 for (int j = 0; j < targets.length; j++)

                                                         out.println("        " + matchs[j] + " : "

                                                                         + targets[j].getPosition());

                                         }

                                         out.println("        default: " + s.getTarget()); // Applies

                                                                                                                                           // for

                                                                                                                                           // both

                                 } else {

                                         BranchInstruction bi = (BranchInstruction) inst;

                                         ih = bi.getTarget();

                                         //str = get(ih);

                                         out.println("  " + Constants.OPCODE_NAMES[bi.getOpcode()]

                                                         + " " + ih);

                                 }

                         } else

                                 out.println("  " + inst.toString(cp.getConstantPool()));

                 }

                 out.print("\n");

                 for (int i = 0; i < ehs.length; i++) {

                         CodeExceptionGen c = ehs[i];

                         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 "

                                         + c.getStartPC().getPosition() + " to "

                                         + c.getEndPC().getPosition() + " using "

                                         + c.getHandlerPC().getPosition());

                 }

         }

 }