/*

 * 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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package com.sun.tools.javap;

import java.util.Formatter;

import com.sun.tools.classfile.AccessFlags;

import com.sun.tools.classfile.AnnotationDefault_attribute;

import com.sun.tools.classfile.Attribute;

import com.sun.tools.classfile.Attributes;

import com.sun.tools.classfile.CharacterRangeTable_attribute;

import com.sun.tools.classfile.Code_attribute;

import com.sun.tools.classfile.CompilationID_attribute;

import com.sun.tools.classfile.ConstantPool;

import com.sun.tools.classfile.ConstantPoolException;

import com.sun.tools.classfile.ConstantValue_attribute;

import com.sun.tools.classfile.DefaultAttribute;

import com.sun.tools.classfile.Deprecated_attribute;

import com.sun.tools.classfile.EnclosingMethod_attribute;

import com.sun.tools.classfile.Exceptions_attribute;

import com.sun.tools.classfile.Field;

import com.sun.tools.classfile.InnerClasses_attribute;

import com.sun.tools.classfile.LineNumberTable_attribute;

import com.sun.tools.classfile.LocalVariableTable_attribute;

import com.sun.tools.classfile.LocalVariableTypeTable_attribute;

import com.sun.tools.classfile.ModuleExportTable_attribute;

import com.sun.tools.classfile.ModuleMemberTable_attribute;

import com.sun.tools.classfile.Module_attribute;

import com.sun.tools.classfile.RuntimeInvisibleAnnotations_attribute;

import com.sun.tools.classfile.RuntimeInvisibleParameterAnnotations_attribute;

import com.sun.tools.classfile.RuntimeVisibleAnnotations_attribute;

import com.sun.tools.classfile.RuntimeVisibleParameterAnnotations_attribute;

import com.sun.tools.classfile.Signature_attribute;

import com.sun.tools.classfile.SourceDebugExtension_attribute;

import com.sun.tools.classfile.SourceFile_attribute;

import com.sun.tools.classfile.SourceID_attribute;

import com.sun.tools.classfile.StackMapTable_attribute;

import com.sun.tools.classfile.StackMap_attribute;

import com.sun.tools.classfile.Synthetic_attribute;

import static com.sun.tools.classfile.AccessFlags.*;

/*

 *  A writer for writing Attributes as text.

 *

 *  <p><b>This is NOT part of any API supported by Sun Microsystems.  If

 *  you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 */

public class AttributeWriter extends BasicWriter

        implements Attribute.Visitor<Void,Void>

{

    static AttributeWriter instance(Context context) {

        AttributeWriter instance = context.get(AttributeWriter.class);

        if (instance == null)

            instance = new AttributeWriter(context);

        return instance;

    }

    protected AttributeWriter(Context context) {

        super(context);

        context.put(AttributeWriter.class, this);

        annotationWriter = AnnotationWriter.instance(context);

        codeWriter = CodeWriter.instance(context);

        constantWriter = ConstantWriter.instance(context);

        options = Options.instance(context);

    }

    public void write(Object owner, Attribute attr, ConstantPool constant_pool) {

        if (attr != null) {

            // null checks

            owner.getClass();

            constant_pool.getClass();

            this.constant_pool = constant_pool;

            this.owner = owner;

            attr.accept(this, null);

        }

    }

    public void write(Object owner, Attributes attrs, ConstantPool constant_pool) {

        if (attrs != null) {

            // null checks

            owner.getClass();

            constant_pool.getClass();

            this.constant_pool = constant_pool;

            this.owner = owner;

            for (Attribute attr: attrs)

                attr.accept(this, null);

        }

    }

    public Void visitDefault(DefaultAttribute attr, Void ignore) {

        byte[] data = attr.info;

        int i = 0;

        int j = 0;

        print("  ");

        try {

            print(attr.getName(constant_pool));

        } catch (ConstantPoolException e) {

            report(e);

            print("attribute name = #" + attr.attribute_name_index);

        }

        print(": ");

        println("length = 0x" + toHex(attr.info.length));

        print("   ");

        while (i < data.length) {

            print(toHex(data[i], 2));

            j++;

            if (j == 16) {

                println();

                print("   ");

                j = 0;

            } else {

                print(" ");

            }

            i++;

        }

        println();

        return null;

    }

    public Void visitAnnotationDefault(AnnotationDefault_attribute attr, Void ignore) {

        println("  AnnotationDefault: ");

        print("    default_value: ");

        annotationWriter.write(attr.default_value);

        return null;

    }

    public Void visitCharacterRangeTable(CharacterRangeTable_attribute attr, Void ignore) {

        print("  CharacterRangeTable: ");

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

            CharacterRangeTable_attribute.Entry e = attr.character_range_table[i];

            print("    " + e.start_pc + ", " +

                    e.end_pc + ", " +

                    Integer.toHexString(e.character_range_start) + ", " +

                    Integer.toHexString(e.character_range_end) + ", " +

                    Integer.toHexString(e.flags) +

                    "\t// ");

            print(e.start_pc + ", " +

                    e.end_pc + ", " +

                    (e.character_range_start >> 10) + ":" + (e.character_range_start & 0x3ff) + ", " +

                    (e.character_range_end >> 10) + ":" + (e.character_range_end & 0x3ff));

            if ((e.flags & CharacterRangeTable_attribute.CRT_STATEMENT) != 0)

                print(", statement");

            if ((e.flags & CharacterRangeTable_attribute.CRT_BLOCK) != 0)

                print(", block");

            if ((e.flags & CharacterRangeTable_attribute.CRT_ASSIGNMENT) != 0)

                print(", assignment");

            if ((e.flags & CharacterRangeTable_attribute.CRT_FLOW_CONTROLLER) != 0)

                print(", flow-controller");

            if ((e.flags & CharacterRangeTable_attribute.CRT_FLOW_TARGET) != 0)

                print(", flow-target");

            if ((e.flags & CharacterRangeTable_attribute.CRT_INVOKE) != 0)

                print(", invoke");

            if ((e.flags & CharacterRangeTable_attribute.CRT_CREATE) != 0)

                print(", create");

            if ((e.flags & CharacterRangeTable_attribute.CRT_BRANCH_TRUE) != 0)

                print(", branch-true");

            if ((e.flags & CharacterRangeTable_attribute.CRT_BRANCH_FALSE) != 0)

                print(", branch-false");

        }

        return null;

    }

    public Void visitCode(Code_attribute attr, Void ignore) {

        codeWriter.write(attr, constant_pool);

        println();

        return null;

    }

    public Void visitCompilationID(CompilationID_attribute attr, Void ignore) {

        constantWriter.write(attr.compilationID_index);

        return null;

    }

    public Void visitConstantValue(ConstantValue_attribute attr, Void ignore) {

        if (options.compat) // BUG 6622216 javap names some attributes incorrectly

            print("  Constant value: ");

        else

            print("  ConstantValue: ");

        constantWriter.write(attr.constantvalue_index);

        if (!options.compat) // BUG 6622232 javap gets whitespace confused

            println();

        return null;

    }

    public Void visitDeprecated(Deprecated_attribute attr, Void ignore) {

        if (!(options.compat && owner instanceof Field)) // BUG 6622232 javap gets whitespace confused

            print("  ");

        println("Deprecated: true");

        return null;

    }

    public Void visitEnclosingMethod(EnclosingMethod_attribute attr, Void ignore) {

        print("  EnclosingMethod: #" + attr.class_index + ".#" + attr.method_index

                + "\t// " + getJavaClassName(attr));

        if (attr.method_index != 0)

            print("." + getMethodName(attr));

        println();

        return null;

    }

    private String getJavaClassName(EnclosingMethod_attribute a) {

        try {

            return getJavaName(a.getClassName(constant_pool));

        } catch (ConstantPoolException e) {

            return report(e);

        }

    }

    private String getMethodName(EnclosingMethod_attribute a) {

        try {

            return a.getMethodName(constant_pool);

        } catch (ConstantPoolException e) {

            return report(e);

        }

    }

    public Void visitExceptions(Exceptions_attribute attr, Void ignore) {

        println("  Exceptions: ");

        print("   throws ");

        for (int i = 0; i < attr.number_of_exceptions; i++) {

            if (i > 0)

                print(", ");

            print(getJavaException(attr, i));

        }

        if (!options.compat) // BUG 6622232 javap gets whitespace confused

            println();

        return null;

    }

    private String getJavaException(Exceptions_attribute attr, int index) {

        try {

            return getJavaName(attr.getException(index, constant_pool));

        } catch (ConstantPoolException e) {

            return report(e);

        }

    }

    public Void visitInnerClasses(InnerClasses_attribute attr, Void ignore) {

        boolean first = true;

        if (options.compat) {

            writeInnerClassHeader();

            first = false;

        }

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

            InnerClasses_attribute.Info info = attr.classes[i];

            //access

            AccessFlags access_flags = info.inner_class_access_flags;

            if (options.compat) {

                // BUG 6622215: javap ignores certain relevant access flags

                access_flags = access_flags.ignore(ACC_STATIC | ACC_PROTECTED | ACC_PRIVATE | ACC_INTERFACE | ACC_SYNTHETIC | ACC_ENUM);

                // BUG 6622232: javap gets whitespace confused

                print("   ");

            }

            if (options.checkAccess(access_flags)) {

                if (first) {

                    writeInnerClassHeader();

                    first = false;

                }

                if (!options.compat) // BUG 6622232: javap gets whitespace confused

                    print("   ");

                for (String name: access_flags.getInnerClassModifiers())

                    print(name + " ");

                if (info.inner_name_index!=0) {

                    print("#" + info.inner_name_index + "= ");

                }

                print("#" + info.inner_class_info_index);

                if (info.outer_class_info_index != 0) {

                    print(" of #" + info.outer_class_info_index);

                }

                print("; //");

                if (info.inner_name_index != 0) {

                    print(getInnerName(constant_pool, info) + "=");

                }

                constantWriter.write(info.inner_class_info_index);

                if (info.outer_class_info_index != 0) {

                    print(" of ");

                    constantWriter.write(info.outer_class_info_index);

                }

                println();

            }

        }

        return null;

    }

    String getInnerName(ConstantPool constant_pool, InnerClasses_attribute.Info info) {

        try {

            return info.getInnerName(constant_pool);

        } catch (ConstantPoolException e) {

            return report(e);

        }

    }

    private void writeInnerClassHeader() {

        print("  ");

        if (options.compat) // BUG 6622216: javap names some attributes incorrectly

            print("InnerClass");

        else

            print("InnerClasses");

        println(": ");

    }

    public Void visitLineNumberTable(LineNumberTable_attribute attr, Void ignore) {

        println("  LineNumberTable: ");

        for (LineNumberTable_attribute.Entry entry: attr.line_number_table) {

            println("   line " + entry.line_number + ": " + entry.start_pc);

        }

        return null;

    }

    public Void visitLocalVariableTable(LocalVariableTable_attribute attr, Void ignore) {

        println("  LocalVariableTable: ");

        println("   Start  Length  Slot  Name   Signature");

        for (LocalVariableTable_attribute.Entry entry : attr.local_variable_table) {

            Formatter formatter = new Formatter();

            println(formatter.format("%8d %7d %5d %5s   %s",

                    entry.start_pc, entry.length, entry.index,

                    constantWriter.stringValue(entry.name_index),

                    constantWriter.stringValue(entry.descriptor_index)));

        }

        return null;

    }

    public Void visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr, Void ignore) {

        println("  LocalVariableTypeTable: ");

        println("   Start  Length  Slot  Name   Signature");

        for (LocalVariableTypeTable_attribute.Entry entry : attr.local_variable_table) {

            Formatter formatter = new Formatter();

            println(formatter.format("%8d %7d %5d %5s   %s",

                    entry.start_pc, entry.length, entry.index,

                    constantWriter.stringValue(entry.name_index),

                    constantWriter.stringValue(entry.signature_index)));

        }

        return null;

    }

    public Void visitModule(Module_attribute attr, Void ignore) {

        println("  Module: #" + attr.module_name + "\t// " + getModuleName(attr));

        return null;

    }

    String getModuleName(Module_attribute attr) {

        try {

            return attr.getModuleName(constant_pool);

        } catch (ConstantPoolException e) {

            return report(e);

        }

    }

    public Void visitModuleExportTable(ModuleExportTable_attribute attr, Void ignore) {

        println("  ModuleExportTable:");

        println("    Types: (" + attr.export_type_table.length + ")");

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

            println("      #" + attr.export_type_table[i] + "\t// " + getExportTypeName(attr, i));

        }

        return null;

    }

    String getExportTypeName(ModuleExportTable_attribute attr, int index) {

        try {

            return attr.getExportTypeName(index, constant_pool);

        } catch (ConstantPoolException e) {

            return report(e);

        }

    }

    public Void visitModuleMemberTable(ModuleMemberTable_attribute attr, Void ignore) {

        println("  ModuleMemberTable:");

        println("    Packages: (" + attr.package_member_table.length + ")");

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

            println("      #" + attr.package_member_table[i] + "\t// " + getPackageMemberName(attr, i));

        }

        return null;

    }

    String getPackageMemberName(ModuleMemberTable_attribute attr, int index) {

        try {

            return attr.getPackageMemberName(index, constant_pool);

        } catch (ConstantPoolException e) {

            return report(e);

        }

    }

    public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, Void ignore) {

        println("  RuntimeVisibleAnnotations: ");

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

            print("    " + i + ": ");

            annotationWriter.write(attr.annotations[i]);

            println();

        }

        return null;

    }

    public Void visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, Void ignore) {

        println("  RuntimeInvisibleAnnotations: ");

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

            print("    " + i + ": ");

            annotationWriter.write(attr.annotations[i]);

            println();

        }

        return null;

    }

    public Void visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, Void ignore) {

        println("  RuntimeVisibleParameterAnnotations: ");

        for (int param = 0; param < attr.parameter_annotations.length; param++) {

            println("    parameter " + param + ": ");

            for (int i = 0; i < attr.parameter_annotations[param].length; i++) {

                print("    " + i + ": ");

                annotationWriter.write(attr.parameter_annotations[param][i]);

                println();

            }

        }

        return null;

    }

    public Void visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute attr, Void ignore) {

        println("  RuntimeInvisibleParameterAnnotations: ");

        for (int param = 0; param < attr.parameter_annotations.length; param++) {

            println("    " + param + ": ");

            for (int i = 0; i < attr.parameter_annotations[param].length; i++) {

                print("    " + i + ": ");

                annotationWriter.write(attr.parameter_annotations[param][i]);

                println();

            }

        }

        return null;

    }

    public Void visitSignature(Signature_attribute attr, Void ignore) {

        println("  Signature: #" + attr.signature_index + "\t// " + getSignature(attr));

        return null;

    }

    String getSignature(Signature_attribute info) {

        try {

            return info.getSignature(constant_pool);

        } catch (ConstantPoolException e) {

            return report(e);

        }

    }

    public Void visitSourceDebugExtension(SourceDebugExtension_attribute attr, Void ignore) {

        println("  SourceDebugExtension: " + attr.getValue());

        return null;

    }

    public Void visitSourceFile(SourceFile_attribute attr, Void ignore) {

        println("  SourceFile: \"" + getSourceFile(attr) + "\"");

        return null;

    }

    private String getSourceFile(SourceFile_attribute attr) {

        try {

            return attr.getSourceFile(constant_pool);

        } catch (ConstantPoolException e) {

            return report(e);

        }

    }

    public Void visitSourceID(SourceID_attribute attr, Void ignore) {

        constantWriter.write(attr.sourceID_index);

        return null;

    }

    public Void visitStackMap(StackMap_attribute attr, Void ignore) {

        println("  StackMap: number_of_entries = " + attr.number_of_entries);

        StackMapTableWriter w = new StackMapTableWriter();

        for (StackMapTable_attribute.stack_map_frame entry : attr.entries) {

            w.write(entry);

        }

        println();

        return null;

    }

    public Void visitStackMapTable(StackMapTable_attribute attr, Void ignore) {

        println("  StackMapTable: number_of_entries = " + attr.number_of_entries);

        StackMapTableWriter w = new StackMapTableWriter();

        for (StackMapTable_attribute.stack_map_frame entry : attr.entries) {

            w.write(entry);

        }

        println();

        return null;

    }

    class StackMapTableWriter // also handles CLDC StackMap attributes

            implements StackMapTable_attribute.stack_map_frame.Visitor<Void,Void> {

        public void write(StackMapTable_attribute.stack_map_frame frame) {

            frame.accept(this, null);

        }

        public Void visit_same_frame(StackMapTable_attribute.same_frame frame, Void p) {

            printHeader(frame);