/*

 * Copyright (c) 2002, 2012, 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 sun.jvm.hotspot.tools.jcore;

import java.io.*;

import java.util.*;

import sun.jvm.hotspot.oops.*;

import sun.jvm.hotspot.runtime.*;

import sun.jvm.hotspot.utilities.*;

public class ClassWriter implements /* imports */ ClassConstants

{

    public static final boolean DEBUG = false;

    protected void debugMessage(String message) {

        System.out.println(message);

    }

    protected InstanceKlass     klass;

    protected DataOutputStream  dos;

    protected ConstantPool      cpool;

    // Map between class name to index of type CONSTANT_Class

    protected Map<String, Short> classToIndex = new HashMap<String, Short>();

    // Map between any modified UTF-8 and it's constant pool index.

    protected Map<String, Short> utf8ToIndex = new HashMap<String, Short>();

    // constant pool index for attribute names.

    protected short  _sourceFileIndex;

    protected short  _innerClassesIndex;

    protected short  _syntheticIndex;

    protected short  _deprecatedIndex;

    protected short  _constantValueIndex;

    protected short  _codeIndex;

    protected short  _exceptionsIndex;

    protected short  _lineNumberTableIndex;

    protected short  _localVariableTableIndex;

    protected short  _signatureIndex;

    protected static int extractHighShortFromInt(int val) {

        // must stay in sync with ConstantPool::name_and_type_at_put, method_at_put, etc.

        return (val >> 16) & 0xFFFF;

    }

    protected static int extractLowShortFromInt(int val) {

        // must stay in sync with ConstantPool::name_and_type_at_put, method_at_put, etc.

        return val & 0xFFFF;

    }

    public ClassWriter(InstanceKlass kls, OutputStream os) {

        klass = kls;

        dos = new DataOutputStream(os);

        cpool = klass.getConstants();

    }

    public void write() throws IOException {

        if (DEBUG) debugMessage("class name = " + klass.getName().asString());

        // write magic

        dos.writeInt(0xCAFEBABE);

        writeVersion();

        writeConstantPool();

        writeClassAccessFlags();

        writeThisClass();

        writeSuperClass();

        writeInterfaces();

        writeFields();

        writeMethods();

        writeClassAttributes();

        // flush output

        dos.flush();

    }

    protected void writeVersion() throws IOException {

        dos.writeShort((short)klass.minorVersion());

        dos.writeShort((short)klass.majorVersion());

    }

    protected void writeIndex(int index) throws IOException {

        if (index == 0) throw new InternalError();

        dos.writeShort(index);

    }

    protected void writeConstantPool() throws IOException {

        final U1Array tags = cpool.getTags();

        final long len = tags.length();

        dos.writeShort((short) len);

        if (DEBUG) debugMessage("constant pool length = " + len);

        int ci = 0; // constant pool index

        // collect all modified UTF-8 Strings from Constant Pool

        for (ci = 1; ci < len; ci++) {

            int cpConstType = tags.at(ci);

            if(cpConstType == JVM_CONSTANT_Utf8) {

                Symbol sym = cpool.getSymbolAt(ci);

                utf8ToIndex.put(sym.asString(), new Short((short) ci));

            }

            else if(cpConstType == JVM_CONSTANT_Long ||

                      cpConstType == JVM_CONSTANT_Double) {

                ci++;

            }

        }

        // remember index of attribute name modified UTF-8 strings

        // class attributes

        Short sourceFileIndex = (Short) utf8ToIndex.get("SourceFile");

        _sourceFileIndex = (sourceFileIndex != null)? sourceFileIndex.shortValue() : 0;

        if (DEBUG) debugMessage("SourceFile index = " + _sourceFileIndex);

        Short innerClassesIndex = (Short) utf8ToIndex.get("InnerClasses");

        _innerClassesIndex = (innerClassesIndex != null)? innerClassesIndex.shortValue() : 0;

        if (DEBUG) debugMessage("InnerClasses index = " + _innerClassesIndex);

        // field attributes

        Short constantValueIndex = (Short) utf8ToIndex.get("ConstantValue");

        _constantValueIndex = (constantValueIndex != null)?

                                          constantValueIndex.shortValue() : 0;

        if (DEBUG) debugMessage("ConstantValue index = " + _constantValueIndex);

        Short syntheticIndex = (Short) utf8ToIndex.get("Synthetic");

        _syntheticIndex = (syntheticIndex != null)? syntheticIndex.shortValue() : 0;

        if (DEBUG) debugMessage("Synthetic index = " + _syntheticIndex);

        Short deprecatedIndex = (Short) utf8ToIndex.get("Deprecated");

        _deprecatedIndex = (deprecatedIndex != null)? deprecatedIndex.shortValue() : 0;

        if (DEBUG) debugMessage("Deprecated index = " + _deprecatedIndex);

        // method attributes

        Short codeIndex = (Short) utf8ToIndex.get("Code");

        _codeIndex = (codeIndex != null)? codeIndex.shortValue() : 0;

        if (DEBUG) debugMessage("Code index = " + _codeIndex);

        Short exceptionsIndex = (Short) utf8ToIndex.get("Exceptions");

        _exceptionsIndex = (exceptionsIndex != null)? exceptionsIndex.shortValue() : 0;

        if (DEBUG) debugMessage("Exceptions index = " + _exceptionsIndex);

        // Short syntheticIndex = (Short) utf8ToIndex.get("Synthetic");

        // Short deprecatedIndex = (Short) utf8ToIndex.get("Deprecated");

        // Code attributes

        Short lineNumberTableIndex = (Short) utf8ToIndex.get("LineNumberTable");

        _lineNumberTableIndex = (lineNumberTableIndex != null)?

                                       lineNumberTableIndex.shortValue() : 0;

        if (DEBUG) debugMessage("LineNumberTable index = " + _lineNumberTableIndex);

        Short localVariableTableIndex = (Short) utf8ToIndex.get("LocalVariableTable");

        _localVariableTableIndex = (localVariableTableIndex != null)?

                                       localVariableTableIndex.shortValue() : 0;

        if (DEBUG) debugMessage("LocalVariableTable index = " + _localVariableTableIndex);

        Short signatureIdx = (Short) utf8ToIndex.get("Signature");

        _signatureIndex = (signatureIdx != null)? signatureIdx.shortValue() : 0;

        if (DEBUG) debugMessage("Signature index = " + _signatureIndex);

        for(ci = 1; ci < len; ci++) {

            int cpConstType = tags.at(ci);

            // write cp_info

            // write constant type

            switch(cpConstType) {

                case JVM_CONSTANT_Utf8: {

                     dos.writeByte(cpConstType);

                     Symbol sym = cpool.getSymbolAt(ci);

                     dos.writeShort((short)sym.getLength());

                     dos.write(sym.asByteArray());

                     if (DEBUG) debugMessage("CP[" + ci + "] = modified UTF-8 " + sym.asString());

                     break;

                }

                case JVM_CONSTANT_Unicode:

                     throw new IllegalArgumentException("Unicode constant!");

                case JVM_CONSTANT_Integer:

                     dos.writeByte(cpConstType);

                     dos.writeInt(cpool.getIntAt(ci));

                     if (DEBUG) debugMessage("CP[" + ci + "] = int " + cpool.getIntAt(ci));

                     break;

                case JVM_CONSTANT_Float:

                     dos.writeByte(cpConstType);

                     dos.writeFloat(cpool.getFloatAt(ci));

                     if (DEBUG) debugMessage("CP[" + ci + "] = float " + cpool.getFloatAt(ci));

                     break;

                case JVM_CONSTANT_Long: {

                     dos.writeByte(cpConstType);

                     long l = cpool.getLongAt(ci);

                     // long entries occupy two pool entries

                     ci++;

                     dos.writeLong(l);

                     break;

                }

                case JVM_CONSTANT_Double:

                     dos.writeByte(cpConstType);

                     dos.writeDouble(cpool.getDoubleAt(ci));

                     // double entries occupy two pool entries

                     ci++;

                     break;

                case JVM_CONSTANT_Class:

                case JVM_CONSTANT_UnresolvedClass:

                case JVM_CONSTANT_UnresolvedClassInError: {

                     dos.writeByte(JVM_CONSTANT_Class);

                     String klassName = cpool.getKlassNameAt(ci).asString();

                     Short s = (Short) utf8ToIndex.get(klassName);

                     classToIndex.put(klassName, new Short((short)ci));

                     dos.writeShort(s.shortValue());

                     if (DEBUG) debugMessage("CP[" + ci  + "] = class " + s);

                     break;

                }

                case JVM_CONSTANT_String: {

                     dos.writeByte(cpConstType);

                     String str = cpool.getUnresolvedStringAt(ci).asString();

                     Short s = (Short) utf8ToIndex.get(str);

                     dos.writeShort(s.shortValue());

                     if (DEBUG) debugMessage("CP[" + ci + "] = string " + s);

                     break;

                }

                // all external, internal method/field references

                case JVM_CONSTANT_Fieldref:

                case JVM_CONSTANT_Methodref:

                case JVM_CONSTANT_InterfaceMethodref: {

                     dos.writeByte(cpConstType);

                     int value = cpool.getIntAt(ci);

                     short klassIndex = (short) extractLowShortFromInt(value);

                     short nameAndTypeIndex = (short) extractHighShortFromInt(value);

                     dos.writeShort(klassIndex);

                     dos.writeShort(nameAndTypeIndex);

                     if (DEBUG) debugMessage("CP[" + ci + "] = ref klass = " +

                           klassIndex + ", N&T = " + nameAndTypeIndex);

                     break;

                }

                case JVM_CONSTANT_NameAndType: {

                     dos.writeByte(cpConstType);

                     int value = cpool.getIntAt(ci);

                     short nameIndex = (short) extractLowShortFromInt(value);

                     short signatureIndex = (short) extractHighShortFromInt(value);

                     dos.writeShort(nameIndex);

                     dos.writeShort(signatureIndex);

                     if (DEBUG) debugMessage("CP[" + ci + "] = N&T name = " + nameIndex

                                        + ", type = " + signatureIndex);

                     break;

                }

                case JVM_CONSTANT_MethodHandle: {

                     dos.writeByte(cpConstType);

                     int value = cpool.getIntAt(ci);

                     byte refKind = (byte) extractLowShortFromInt(value);

                     short memberIndex = (short) extractHighShortFromInt(value);

                     dos.writeByte(refKind);

                     dos.writeShort(memberIndex);

                     if (DEBUG) debugMessage("CP[" + ci + "] = MH kind = " +

                           refKind + ", mem = " + memberIndex);

                     break;

                }

                case JVM_CONSTANT_MethodType: {

                     dos.writeByte(cpConstType);

                     int value = cpool.getIntAt(ci);

                     short refIndex = (short) value;

                     dos.writeShort(refIndex);

                     if (DEBUG) debugMessage("CP[" + ci + "] = MT index = " + refIndex);

                     break;

                }

                case JVM_CONSTANT_InvokeDynamic: {

                     dos.writeByte(cpConstType);

                     int value = cpool.getIntAt(ci);

                     short bsmIndex = (short) extractLowShortFromInt(value);

                     short nameAndTypeIndex = (short) extractHighShortFromInt(value);

                     dos.writeShort(bsmIndex);

                     dos.writeShort(nameAndTypeIndex);

                     if (DEBUG) debugMessage("CP[" + ci + "] = INDY bsm = " +

                           bsmIndex + ", N&T = " + nameAndTypeIndex);

                     break;

                }

                default:

                  throw new InternalError("Unknown tag: " + cpConstType);

            } // switch

        }

    }

    protected void writeClassAccessFlags() throws IOException {

        int flags = (int)(klass.getAccessFlags() & JVM_RECOGNIZED_CLASS_MODIFIERS);

        dos.writeShort((short)flags);

    }

    protected void writeThisClass() throws IOException {

        String klassName = klass.getName().asString();

        Short index = (Short) classToIndex.get(klassName);

        dos.writeShort(index.shortValue());

        if (DEBUG) debugMessage("this class = " + index);

    }

    protected void writeSuperClass() throws IOException {

        Klass superKlass = klass.getSuper();

        if (superKlass != null) { // is not java.lang.Object

            String superName = superKlass.getName().asString();

            Short index = (Short) classToIndex.get(superName);

            if (DEBUG) debugMessage("super class = " + index);

            dos.writeShort(index.shortValue());

        } else {

            dos.writeShort(0); // no super class

        }

    }

    protected void writeInterfaces() throws IOException {

        KlassArray interfaces = klass.getLocalInterfaces();

        final int len = interfaces.length();

        if (DEBUG) debugMessage("number of interfaces = " + len);

        // write interfaces count

        dos.writeShort((short) len);

        for (int i = 0; i < len; i++) {

           Klass k = interfaces.getAt(i);

           Short index = (Short) classToIndex.get(k.getName().asString());

           dos.writeShort(index.shortValue());

           if (DEBUG) debugMessage("\t" + index);

        }

    }

    protected void writeFields() throws IOException {

        final int javaFieldsCount = klass.getJavaFieldsCount();

        // write number of fields

        dos.writeShort((short) javaFieldsCount);

        if (DEBUG) debugMessage("number of fields = " + javaFieldsCount);

        for (int index = 0; index < javaFieldsCount; index++) {

            short accessFlags    = klass.getFieldAccessFlags(index);

            dos.writeShort(accessFlags & (short) JVM_RECOGNIZED_FIELD_MODIFIERS);

            short nameIndex    = klass.getFieldNameIndex(index);

            dos.writeShort(nameIndex);

            short signatureIndex = klass.getFieldSignatureIndex(index);

            dos.writeShort(signatureIndex);

            if (DEBUG) debugMessage("\tfield name = " + nameIndex + ", signature = " + signatureIndex);

            short fieldAttributeCount = 0;

            boolean hasSyn = hasSyntheticAttribute(accessFlags);

            if (hasSyn)

                fieldAttributeCount++;

            short initvalIndex = klass.getFieldInitialValueIndex(index);

            if (initvalIndex != 0)

                fieldAttributeCount++;

            short genSigIndex = klass.getFieldGenericSignatureIndex(index);

            if (genSigIndex != 0)

                fieldAttributeCount++;

            dos.writeShort(fieldAttributeCount);

            // write synthetic, if applicable

            if (hasSyn)

                writeSynthetic();

            if (initvalIndex != 0) {

                writeIndex(_constantValueIndex);

                dos.writeInt(2);

                dos.writeShort(initvalIndex);

                if (DEBUG) debugMessage("\tfield init value = " + initvalIndex);

            }

            if (genSigIndex != 0) {

                writeIndex(_signatureIndex);

                dos.writeInt(2);

                dos.writeShort(genSigIndex);

                if (DEBUG) debugMessage("\tfield generic signature index " + genSigIndex);

            }

        }

    }

    protected boolean isSynthetic(short accessFlags) {

        return (accessFlags & (short) JVM_ACC_SYNTHETIC) != 0;

    }

    protected boolean hasSyntheticAttribute(short accessFlags) {

        // Check if flags have the attribute and if the constant pool contains an entry for it.

        return isSynthetic(accessFlags) && _syntheticIndex != 0;

    }

    protected void writeSynthetic() throws IOException {

        writeIndex(_syntheticIndex);

        dos.writeInt(0);

    }

    protected void writeMethods() throws IOException {

        MethodArray methods = klass.getMethods();

        ArrayList<Method> valid_methods = new ArrayList<Method>();

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

            Method m = methods.at(i);

            long accessFlags = m.getAccessFlags();

            // overpass method

            if (accessFlags == (JVM_ACC_PUBLIC | JVM_ACC_SYNTHETIC | JVM_ACC_BRIDGE)) {

                continue;

            }

            valid_methods.add(m);

        }

        final int len = valid_methods.size();

        // write number of methods

        dos.writeShort((short) len);

        if (DEBUG) debugMessage("number of methods = " + len);

        for (int m = 0; m < len; m++) {

            writeMethod(valid_methods.get(m));

        }

    }

    protected void writeMethod(Method m) throws IOException {

        long accessFlags = m.getAccessFlags();

        dos.writeShort((short) (accessFlags & JVM_RECOGNIZED_METHOD_MODIFIERS));

        dos.writeShort((short) m.getNameIndex());

        dos.writeShort((short) m.getSignatureIndex());

        if (DEBUG) debugMessage("\tmethod name = " + m.getNameIndex() + ", signature = "

                        + m.getSignatureIndex());

        final boolean isNative = ((accessFlags & JVM_ACC_NATIVE) != 0);

        final boolean isAbstract = ((accessFlags & JVM_ACC_ABSTRACT) != 0);

        short methodAttributeCount = 0;

        final boolean hasSyn = hasSyntheticAttribute((short)accessFlags);

        if (hasSyn)

            methodAttributeCount++;

        final boolean hasCheckedExceptions = m.hasCheckedExceptions();

        if (hasCheckedExceptions)

            methodAttributeCount++;

        final boolean isCodeAvailable = (!isNative) && (!isAbstract);

        if (isCodeAvailable)

            methodAttributeCount++;

        final boolean isGeneric = (m.getGenericSignature() != null);

        if (isGeneric)

            methodAttributeCount++;

        dos.writeShort(methodAttributeCount);

        if (DEBUG) debugMessage("\tmethod attribute count = " + methodAttributeCount);

        if (hasSyn) {

            if (DEBUG) debugMessage("\tmethod is synthetic");

            writeSynthetic();

        }

        if (isCodeAvailable) {

            byte[] code = m.getByteCode();

            short codeAttrCount = 0;

            int codeSize  = 2           /* max_stack   */ +

                            2           /* max_locals  */ +

                            4           /* code_length */ +

                            code.length /* code        */ +

                            2           /* exp. table len.  */ +

                            2           /* code attr. count */;

            boolean hasExceptionTable = m.hasExceptionTable();

            ExceptionTableElement[] exceptionTable = null;

            int exceptionTableLen = 0;

            if (hasExceptionTable) {

                exceptionTable = m.getExceptionTable();

                exceptionTableLen = exceptionTable.length;

                if (DEBUG) debugMessage("\tmethod has exception table");

                codeSize += exceptionTableLen /* exception table is 4-tuple array */

                                         * (2 /* start_pc     */ +

                                            2 /* end_pc       */ +

                                            2 /* handler_pc   */ +

                                            2 /* catch_type   */);