/*
 * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package ilib;

import java.io.IOException;
import java.io.File;
import java.io.FileOutputStream;
import java.io.DataOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.CharArrayWriter;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

public class ClassDump implements RuntimeConstants {

  public static void dump(Options opt,
                                       ClassLoader loader,
                                       String className,
                                       byte[] classfileBuffer) {
    ClassReaderWriter c = new ClassReaderWriter(classfileBuffer);
    (new ClassDump(className, c)).doit();
  }

    static boolean verbose = true;

    final String className;
    final ClassReaderWriter c;
    private final PrintStream output;

    int constantPoolCount;
    int methodsCount;

    ClassDump(String className, ClassReaderWriter c) {
        this.className = className;
        this.c = c;
        this.output = System.err;
    }

    void doit() {
        int i;
        c.copy(4 + 2 + 2); // magic min/maj version
        constantPoolCount = c.copyU2();
        // copy old constant pool
        c.copyConstantPool(constantPoolCount);

        traceln("ConstantPool size: " + constantPoolCount);

        c.copy(2 + 2 + 2);  // access, this, super
        int interfaceCount = c.copyU2();
        traceln("interfaceCount: " + interfaceCount);
        c.copy(interfaceCount * 2);
        copyFields(); // fields
        copyMethods(); // methods
        int attrCount = c.copyU2();
        traceln("class attrCount: " + attrCount);
        // copy the class attributes
        copyAttrs(attrCount);
    }


    void copyFields() {
        int count = c.copyU2();
        if (verbose) {
            System.out.println("fields count: " + count);
        }
        for (int i = 0; i < count; ++i) {
            c.copy(6); // access, name, descriptor
            int attrCount = c.copyU2();
            if (verbose) {
                System.out.println("field attr count: " + attrCount);
            }
            copyAttrs(attrCount);
        }
    }

    void copyMethods() {
        methodsCount = c.copyU2();
        if (verbose) {
            System.out.println("methods count: " + methodsCount);
        }
        for (int i = 0; i < methodsCount; ++i) {
            copyMethod();
        }
    }

    void copyMethod() {
        int accessFlags = c.copyU2();// access flags
        int nameIndex = c.copyU2();  // name
        checkIndex(nameIndex, "Method name");
        String methodName = c.constantPoolString(nameIndex);
        traceln("method: " + methodName);
        int descriptorIndex = c.copyU2();                  // descriptor
        checkIndex(descriptorIndex, "Method descriptor");
        int attrCount = c.copyU2();  // attribute count
        if (verbose) {
            System.out.println("method attr count: " + attrCount);
        }
        for (int i = 0; i < attrCount; ++i) {
            copyAttrForMethod(methodName, accessFlags);
        }
    }

    void copyAttrs(int attrCount) {
        for (int i = 0; i < attrCount; ++i) {
            copyAttr();
        }
    }

    void copyAttr() {
        c.copy(2);             // name
        int len = c.copyU4();  // attr len
        if (verbose) {
            System.out.println("attr len: " + len);
        }
        c.copy(len);           // attribute info
    }

    void copyAttrForMethod(String methodName, int accessFlags) {
        int nameIndex = c.copyU2();   // name
        // check for Code attr
        checkIndex(nameIndex, "Method attr name");
        if (nameIndex == c.codeAttributeIndex) {
            try {
                copyCodeAttr(methodName);
            } catch (IOException exc) {
                System.err.println("Code Exception - " + exc);
                System.exit(1);
            }
        } else {
            int len = c.copyU4();     // attr len
            traceln("method attr len: " + len);
            c.copy(len);              // attribute info
        }
    }

    void copyAttrForCode() throws IOException {
        int nameIndex = c.copyU2();   // name

        checkIndex(nameIndex, "Code attr name");
        int len = c.copyU4();     // attr len
        traceln("code attr len: " + len);
        c.copy(len);              // attribute info
    }

    void copyCodeAttr(String methodName) throws IOException {
        traceln("Code attr found");
        int attrLength = c.copyU4();        // attr len
        checkLength(attrLength, "Code attr length");
        int maxStack = c.readU2();          // max stack
        c.copyU2();                         // max locals
        int codeLength = c.copyU4();        // code length
        checkLength(codeLength, "Code length");

        copyExceptionTable();

        int attrCount = c.copyU2();
        checkLength(attrCount, "Code attr count");
        for (int i = 0; i < attrCount; ++i) {
            copyAttrForCode();
        }
    }

    /**
     * Copy the exception table for this method code
     */
    void copyExceptionTable() throws IOException {
        int tableLength = c.copyU2();   // exception table len
        checkLength(tableLength, "Exception Table length");
        if (tableLength > 0) {
            traceln();
            traceln("Exception table:");
            traceln(" from:old/new  to:old/new target:old/new type");
            for (int tcnt = tableLength; tcnt > 0; --tcnt) {
                int startPC = c.readU2();
                int endPC = c.readU2();
                int handlerPC = c.readU2();
                int catchType = c.copyU2();
                if (verbose) {
                    traceFixedWidthInt(startPC, 6);
                    traceFixedWidthInt(endPC, 6);
                    traceFixedWidthInt(handlerPC, 6);
                    trace("    ");
                    if (catchType == 0)
                        traceln("any");
                    else {
                        traceln("" + catchType);
                    }
                }
            }
        }
    }

    private void checkIndex(int index, String comment) {
        if (index > constantPoolCount) {
            output.println("ERROR BAD INDEX " + comment + " : " + index);
        } else {
            traceln(comment + " : " + index);
        }
    }

    private void checkLength(int length, String comment) {
        if (length > c.inputBytes().length) {
            output.println("ERROR BAD LENGTH " + comment + " : " + length);
        } else {
            traceln(comment + " : " + length);
        }
    }

    private void trace(String str) {
        if (verbose) {
            output.print(str);
        }
    }

    private void traceln(String str) {
        if (verbose) {
            output.println(str);
        }
    }

    private void traceln() {
        if (verbose) {
            output.println();
        }
    }

    private void trace(int i) {
        if (verbose) {
            output.print(i);
        }
    }

    /**
     * Print an integer so that it takes 'length' characters in
     * the output.  Temporary until formatting code is stable.
     */
    private void traceFixedWidthInt(int x, int length) {
        if (verbose) {
            CharArrayWriter baStream = new CharArrayWriter();
            PrintWriter pStream = new PrintWriter(baStream);
            pStream.print(x);
            String str = baStream.toString();
            for (int cnt = length - str.length(); cnt > 0; --cnt)
                trace(" ");
            trace(str);
        }
    }


}