/*

 * Copyright (c) 2003, 2013, 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.java.util.jar.pack;

import com.sun.java.util.jar.pack.ConstantPool.Entry;

import com.sun.java.util.jar.pack.ConstantPool.Index;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import static com.sun.java.util.jar.pack.Constants.*;

/**

 * Represents an attribute in a class-file.

 * Takes care to remember where constant pool indexes occur.

 * Implements the "little language" of Pack200 for describing

 * attribute layouts.

 * @author John Rose

 */

class Attribute implements Comparable<Attribute> {

    // Attribute instance fields.

    Layout def;     // the name and format of this attr

    byte[] bytes;   // the actual bytes

    Object fixups;  // reference relocations, if any are required

    public String name() { return def.name(); }

    public Layout layout() { return def; }

    public byte[] bytes() { return bytes; }

    public int size() { return bytes.length; }

    public Entry getNameRef() { return def.getNameRef(); }

    private Attribute(Attribute old) {

        this.def = old.def;

        this.bytes = old.bytes;

        this.fixups = old.fixups;

    }

    public Attribute(Layout def, byte[] bytes, Object fixups) {

        this.def = def;

        this.bytes = bytes;

        this.fixups = fixups;

        Fixups.setBytes(fixups, bytes);

    }

    public Attribute(Layout def, byte[] bytes) {

        this(def, bytes, null);

    }

    public Attribute addContent(byte[] bytes, Object fixups) {

        assert(isCanonical());

        if (bytes.length == 0 && fixups == null)

            return this;

        Attribute res = new Attribute(this);

        res.bytes = bytes;

        res.fixups = fixups;

        Fixups.setBytes(fixups, bytes);

        return res;

    }

    public Attribute addContent(byte[] bytes) {

        return addContent(bytes, null);

    }

    public void finishRefs(Index ix) {

        if (fixups != null) {

            Fixups.finishRefs(fixups, bytes, ix);

            fixups = null;

        }

    }

    public boolean isCanonical() {

        return this == def.canon;

    }

    @Override

    public int compareTo(Attribute that) {

        return this.def.compareTo(that.def);

    }

    private static final Map<List<Attribute>, List<Attribute>> canonLists = new HashMap<>();

    private static final Map<Layout, Attribute> attributes = new HashMap<>();

    private static final Map<Layout, Attribute> standardDefs = new HashMap<>();

    // Canonicalized lists of trivial attrs (Deprecated, etc.)

    // are used by trimToSize, in order to reduce footprint

    // of some common cases.  (Note that Code attributes are

    // always zero size.)

    public static List<Attribute> getCanonList(List<Attribute> al) {

        synchronized (canonLists) {

            List<Attribute> cl = canonLists.get(al);

            if (cl == null) {

                cl = new ArrayList<>(al.size());

                cl.addAll(al);

                cl = Collections.unmodifiableList(cl);

                canonLists.put(al, cl);

            }

            return cl;

        }

    }

    // Find the canonical empty attribute with the given ctype, name, layout.

    public static Attribute find(int ctype, String name, String layout) {

        Layout key = Layout.makeKey(ctype, name, layout);

        synchronized (attributes) {

            Attribute a = attributes.get(key);

            if (a == null) {

                a = new Layout(ctype, name, layout).canonicalInstance();

                attributes.put(key, a);

            }

            return a;

        }

    }

    public static Layout keyForLookup(int ctype, String name) {

        return Layout.makeKey(ctype, name);

    }

    // Find canonical empty attribute with given ctype and name,

    // and with the standard layout.

    public static Attribute lookup(Map<Layout, Attribute> defs, int ctype,

            String name) {

        if (defs == null) {

            defs = standardDefs;

        }

        return defs.get(Layout.makeKey(ctype, name));

    }

    public static Attribute define(Map<Layout, Attribute> defs, int ctype,

            String name, String layout) {

        Attribute a = find(ctype, name, layout);

        defs.put(Layout.makeKey(ctype, name), a);

        return a;

    }

    static {

        Map<Layout, Attribute> sd = standardDefs;

        define(sd, ATTR_CONTEXT_CLASS, "Signature", "RSH");

        define(sd, ATTR_CONTEXT_CLASS, "Synthetic", "");

        define(sd, ATTR_CONTEXT_CLASS, "Deprecated", "");

        define(sd, ATTR_CONTEXT_CLASS, "SourceFile", "RUH");

        define(sd, ATTR_CONTEXT_CLASS, "EnclosingMethod", "RCHRDNH");

        define(sd, ATTR_CONTEXT_CLASS, "InnerClasses", "NH[RCHRCNHRUNHFH]");

        define(sd, ATTR_CONTEXT_CLASS, "BootstrapMethods", "NH[RMHNH[KLH]]");

        define(sd, ATTR_CONTEXT_FIELD, "Signature", "RSH");

        define(sd, ATTR_CONTEXT_FIELD, "Synthetic", "");

        define(sd, ATTR_CONTEXT_FIELD, "Deprecated", "");

        define(sd, ATTR_CONTEXT_FIELD, "ConstantValue", "KQH");

        define(sd, ATTR_CONTEXT_METHOD, "Signature", "RSH");

        define(sd, ATTR_CONTEXT_METHOD, "Synthetic", "");

        define(sd, ATTR_CONTEXT_METHOD, "Deprecated", "");

        define(sd, ATTR_CONTEXT_METHOD, "Exceptions", "NH[RCH]");

        define(sd, ATTR_CONTEXT_METHOD, "MethodParameters", "NB[RUNHFH]");

        //define(sd, ATTR_CONTEXT_METHOD, "Code", "HHNI[B]NH[PHPOHPOHRCNH]NH[RUHNI[B]]");

        define(sd, ATTR_CONTEXT_CODE, "StackMapTable",

               ("[NH[(1)]]" +

                "[TB" +

                "(64-127)[(2)]" +

                "(247)[(1)(2)]" +

                "(248-251)[(1)]" +

                "(252)[(1)(2)]" +

                "(253)[(1)(2)(2)]" +

                "(254)[(1)(2)(2)(2)]" +

                "(255)[(1)NH[(2)]NH[(2)]]" +

                "()[]" +

                "]" +

                "[H]" +

                "[TB(7)[RCH](8)[PH]()[]]"));

        define(sd, ATTR_CONTEXT_CODE, "LineNumberTable", "NH[PHH]");

        define(sd, ATTR_CONTEXT_CODE, "LocalVariableTable", "NH[PHOHRUHRSHH]");

        define(sd, ATTR_CONTEXT_CODE, "LocalVariableTypeTable", "NH[PHOHRUHRSHH]");

        //define(sd, ATTR_CONTEXT_CODE, "CharacterRangeTable", "NH[PHPOHIIH]");

        //define(sd, ATTR_CONTEXT_CODE, "CoverageTable", "NH[PHHII]");

        // Note:  Code and InnerClasses are special-cased elsewhere.

        // Their layout specs. are given here for completeness.

        // The Code spec is incomplete, in that it does not distinguish

        // bytecode bytes or locate CP references.

        // The BootstrapMethods attribute is also special-cased

        // elsewhere as an appendix to the local constant pool.

    }

    // Metadata.

    //

    // We define metadata using similar layouts

    // for all five kinds of metadata attributes and 2 type metadata attributes

    //

    // Regular annotations are a counted list of [RSHNH[RUH(1)]][...]

    //   pack.method.attribute.RuntimeVisibleAnnotations=[NH[(1)]][RSHNH[RUH(1)]][TB...]

    //

    // Parameter annotations are a counted list of regular annotations.

    //   pack.method.attribute.RuntimeVisibleParameterAnnotations=[NB[(1)]][NH[(1)]][RSHNH[RUH(1)]][TB...]

    //

    // RuntimeInvisible annotations are defined similarly...

    // Non-method annotations are defined similarly...

    //

    // Annotation are a simple tagged value [TB...]

    //   pack.attribute.method.AnnotationDefault=[TB...]

    static {

        String mdLayouts[] = {

            Attribute.normalizeLayoutString

            (""

             +"\n  # parameter_annotations :="

             +"\n  [ NB[(1)] ]     # forward call to annotations"

             ),

            Attribute.normalizeLayoutString

            (""

             +"\n  # annotations :="

             +"\n  [ NH[(1)] ]     # forward call to annotation"

             +"\n  "

            ),

            Attribute.normalizeLayoutString

             (""

             +"\n  # annotation :="

             +"\n  [RSH"

             +"\n    NH[RUH (1)]   # forward call to value"

             +"\n    ]"

             ),

            Attribute.normalizeLayoutString

            (""

             +"\n  # value :="

             +"\n  [TB # Callable 2 encodes one tagged value."

             +"\n    (\\B,\\C,\\I,\\S,\\Z)[KIH]"

             +"\n    (\\D)[KDH]"

             +"\n    (\\F)[KFH]"

             +"\n    (\\J)[KJH]"

             +"\n    (\\c)[RSH]"

             +"\n    (\\e)[RSH RUH]"

             +"\n    (\\s)[RUH]"

             +"\n    (\\[)[NH[(0)]] # backward self-call to value"

             +"\n    (\\@)[RSH NH[RUH (0)]] # backward self-call to value"

             +"\n    ()[] ]"

             )

        };

        /*

         * RuntimeVisibleTypeAnnotation and RuntimeInvisibleTypeAnnotatation are

         * similar to RuntimeVisibleAnnotation and RuntimeInvisibleAnnotation,

         * a type-annotation union  and a type-path structure precedes the

         * annotation structure

         */

        String typeLayouts[] = {

            Attribute.normalizeLayoutString

            (""

             +"\n # type-annotations :="

             +"\n  [ NH[(1)(2)(3)] ]     # forward call to type-annotations"

            ),

            Attribute.normalizeLayoutString

            ( ""

             +"\n  # type-annotation :="

             +"\n  [TB"

             +"\n    (0-1) [B] # {CLASS, METHOD}_TYPE_PARAMETER"

             +"\n    (16) [FH] # CLASS_EXTENDS"

             +"\n    (17-18) [BB] # {CLASS, METHOD}_TYPE_PARAMETER_BOUND"

             +"\n    (19-21) [] # FIELD, METHOD_RETURN, METHOD_RECEIVER"

             +"\n    (22) [B] # METHOD_FORMAL_PARAMETER"

             +"\n    (23) [H] # THROWS"

             +"\n    (64-65) [NH[PHOHH]] # LOCAL_VARIABLE, RESOURCE_VARIABLE"

             +"\n    (66) [H] # EXCEPTION_PARAMETER"

             +"\n    (67-70) [PH] # INSTANCEOF, NEW, {CONSTRUCTOR, METHOD}_REFERENCE_RECEIVER"

             +"\n    (71-75) [PHB] # CAST, {CONSTRUCTOR,METHOD}_INVOCATION_TYPE_ARGUMENT, {CONSTRUCTOR, METHOD}_REFERENCE_TYPE_ARGUMENT"

             +"\n    ()[] ]"

            ),

            Attribute.normalizeLayoutString

            (""

             +"\n # type-path"

             +"\n [ NB[BB] ]"

            )

        };

        Map<Layout, Attribute> sd = standardDefs;

        String defaultLayout     = mdLayouts[3];

        String annotationsLayout = mdLayouts[1] + mdLayouts[2] + mdLayouts[3];

        String paramsLayout      = mdLayouts[0] + annotationsLayout;

        String typesLayout       = typeLayouts[0] + typeLayouts[1] +

                                   typeLayouts[2] + mdLayouts[2] + mdLayouts[3];

        for (int ctype = 0; ctype < ATTR_CONTEXT_LIMIT; ctype++) {

            if (ctype != ATTR_CONTEXT_CODE) {

                define(sd, ctype,

                       "RuntimeVisibleAnnotations",   annotationsLayout);

                define(sd, ctype,

                       "RuntimeInvisibleAnnotations",  annotationsLayout);

                if (ctype == ATTR_CONTEXT_METHOD) {

                    define(sd, ctype,

                           "RuntimeVisibleParameterAnnotations",   paramsLayout);

                    define(sd, ctype,

                           "RuntimeInvisibleParameterAnnotations", paramsLayout);

                    define(sd, ctype,

                           "AnnotationDefault", defaultLayout);

                }

            }

            define(sd, ctype,

                   "RuntimeVisibleTypeAnnotations", typesLayout);

            define(sd, ctype,

                   "RuntimeInvisibleTypeAnnotations", typesLayout);

        }

    }

    public static String contextName(int ctype) {

        switch (ctype) {

        case ATTR_CONTEXT_CLASS: return "class";

        case ATTR_CONTEXT_FIELD: return "field";

        case ATTR_CONTEXT_METHOD: return "method";

        case ATTR_CONTEXT_CODE: return "code";

        }

        return null;

    }

    /** Base class for any attributed object (Class, Field, Method, Code).

     *  Flags are included because they are used to help transmit the

     *  presence of attributes.  That is, flags are a mix of modifier

     *  bits and attribute indicators.

     */

    class Holder {

        // We need this abstract method to interpret embedded CP refs.

        protected abstract Entry[] getCPMap();

        protected int flags;             // defined here for convenience

        protected List<Attribute> attributes;

        public int attributeSize() {

            return (attributes == null) ? 0 : attributes.size();

        }

        public void trimToSize() {

            if (attributes == null) {

                return;

            }

            if (attributes.isEmpty()) {

                attributes = null;

                return;

            }

            if (attributes instanceof ArrayList) {

                ArrayList<Attribute> al = (ArrayList<Attribute>)attributes;

                al.trimToSize();

                boolean allCanon = true;

                for (Attribute a : al) {

                    if (!a.isCanonical()) {

                        allCanon = false;

                    }

                    if (a.fixups != null) {

                        assert(!a.isCanonical());

                        a.fixups = Fixups.trimToSize(a.fixups);

                    }

                }

                if (allCanon) {

                    // Replace private writable attribute list

                    // with only trivial entries by public unique

                    // immutable attribute list with the same entries.

                    attributes = getCanonList(al);

                }

            }

        }

        public void addAttribute(Attribute a) {

            if (attributes == null)

                attributes = new ArrayList<>(3);

            else if (!(attributes instanceof ArrayList))

                attributes = new ArrayList<>(attributes);  // unfreeze it

            attributes.add(a);

        }

        public Attribute removeAttribute(Attribute a) {

            if (attributes == null)       return null;

            if (!attributes.contains(a))  return null;

            if (!(attributes instanceof ArrayList))

                attributes = new ArrayList<>(attributes);  // unfreeze it

            attributes.remove(a);

            return a;

        }

        public Attribute getAttribute(int n) {

            return attributes.get(n);

        }

        protected void visitRefs(int mode, Collection<Entry> refs) {

            if (attributes == null)  return;

            for (Attribute a : attributes) {

                a.visitRefs(this, mode, refs);

            }

        }

        static final List<Attribute> noAttributes = Arrays.asList(new Attribute[0]);

        public List<Attribute> getAttributes() {

            if (attributes == null)

                return noAttributes;

            return attributes;

        }

        public void setAttributes(List<Attribute> attrList) {

            if (attrList.isEmpty())

                attributes = null;

            else

                attributes = attrList;

        }

        public Attribute getAttribute(String attrName) {

            if (attributes == null)  return null;

            for (Attribute a : attributes) {

                if (a.name().equals(attrName))

                    return a;

            }

            return null;

        }

        public Attribute getAttribute(Layout attrDef) {

            if (attributes == null)  return null;

            for (Attribute a : attributes) {

                if (a.layout() == attrDef)

                    return a;

            }

            return null;

        }

        public Attribute removeAttribute(String attrName) {

            return removeAttribute(getAttribute(attrName));

        }

        public Attribute removeAttribute(Layout attrDef) {

            return removeAttribute(getAttribute(attrDef));

        }

        public void strip(String attrName) {

            removeAttribute(getAttribute(attrName));

        }

    }

    // Lightweight interface to hide details of band structure.

    // Also used for testing.

    class ValueStream {

        public int getInt(int bandIndex) { throw undef(); }

        public void putInt(int bandIndex, int value) { throw undef(); }

        public Entry getRef(int bandIndex) { throw undef(); }

        public void putRef(int bandIndex, Entry ref) { throw undef(); }

        // Note:  decodeBCI goes w/ getInt/Ref; encodeBCI goes w/ putInt/Ref

        public int decodeBCI(int bciCode) { throw undef(); }

        public int encodeBCI(int bci) { throw undef(); }

        public void noteBackCall(int whichCallable) { /* ignore by default */ }

        private RuntimeException undef() {

            return new UnsupportedOperationException("ValueStream method");

        }

    }

    // Element kinds:

    static final byte EK_INT  = 1;     // B H I SH etc.

    static final byte EK_BCI  = 2;     // PH POH etc.

    static final byte EK_BCO  = 3;     // OH etc.

    static final byte EK_FLAG = 4;     // FH etc.

    static final byte EK_REPL = 5;     // NH[...] etc.

    static final byte EK_REF  = 6;     // RUH, RUNH, KQH, etc.

    static final byte EK_UN   = 7;     // TB(...)[...] etc.

    static final byte EK_CASE = 8;     // (...)[...] etc.

    static final byte EK_CALL = 9;     // (0), (1), etc.

    static final byte EK_CBLE = 10;    // [...][...] etc.

    static final byte EF_SIGN  = 1<<0;   // INT is signed

    static final byte EF_DELTA = 1<<1;   // BCI/BCI value is diff'ed w/ previous

    static final byte EF_NULL  = 1<<2;   // null REF is expected/allowed

    static final byte EF_BACK  = 1<<3;   // call, callable, case is backward

    static final int NO_BAND_INDEX = -1;

    /** A "class" of attributes, characterized by a context-type, name

     *  and format.  The formats are specified in a "little language".

     */

    public static

    class Layout implements Comparable<Layout> {

        int ctype;       // attribute context type, e.g., ATTR_CONTEXT_CODE

        String name;     // name of attribute

        boolean hasRefs; // this kind of attr contains CP refs?

        String layout;   // layout specification

        int bandCount;   // total number of elems

        Element[] elems; // tokenization of layout

        Attribute canon; // canonical instance of this layout

        public int ctype() { return ctype; }

        public String name() { return name; }

        public String layout() { return layout; }

        public Attribute canonicalInstance() { return canon; }

        public Entry getNameRef() {