/*

 * Copyright (c) 2001, 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 java.util.AbstractList;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.List;

import java.util.ListIterator;

import java.util.Map;

import java.util.Set;

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

/**

 * Representation of constant pool entries and indexes.

 * @author John Rose

 */

abstract

class ConstantPool {

    private ConstantPool() {}  // do not instantiate

    static int verbose() {

        return Utils.currentPropMap().getInteger(Utils.DEBUG_VERBOSE);

    }

    /** Factory for Utf8 string constants.

     *  Used for well-known strings like "SourceFile", "<init>", etc.

     *  Also used to back up more complex constant pool entries, like Class.

     */

    public static synchronized Utf8Entry getUtf8Entry(String value) {

        Map<String, Utf8Entry> utf8Entries  = Utils.getTLGlobals().getUtf8Entries();

        Utf8Entry e = utf8Entries.get(value);

        if (e == null) {

            e = new Utf8Entry(value);

            utf8Entries.put(e.stringValue(), e);

        }

        return e;

    }

    /** Factory for Class constants. */

    public static ClassEntry getClassEntry(String name) {

        Map<String, ClassEntry> classEntries = Utils.getTLGlobals().getClassEntries();

        ClassEntry e = classEntries.get(name);

        if (e == null) {

            e = new ClassEntry(getUtf8Entry(name));

            assert(name.equals(e.stringValue()));

            classEntries.put(e.stringValue(), e);

        }

        return e;

    }

    /** Factory for literal constants (String, Integer, etc.). */

    public static LiteralEntry getLiteralEntry(Comparable<?> value) {

        Map<Object, LiteralEntry> literalEntries = Utils.getTLGlobals().getLiteralEntries();

        LiteralEntry e = literalEntries.get(value);

        if (e == null) {

            if (value instanceof String)

                e = new StringEntry(getUtf8Entry((String)value));

            else

                e = new NumberEntry((Number)value);

            literalEntries.put(value, e);

        }

        return e;

    }

    /** Factory for literal constants (String, Integer, etc.). */

    public static StringEntry getStringEntry(String value) {

        return (StringEntry) getLiteralEntry(value);

    }

    /** Factory for signature (type) constants. */

    public static SignatureEntry getSignatureEntry(String type) {

        Map<String, SignatureEntry> signatureEntries = Utils.getTLGlobals().getSignatureEntries();

        SignatureEntry e = signatureEntries.get(type);

        if (e == null) {

            e = new SignatureEntry(type);

            assert(e.stringValue().equals(type));

            signatureEntries.put(type, e);

        }

        return e;

    }

    // Convenience overloading.

    public static SignatureEntry getSignatureEntry(Utf8Entry formRef, ClassEntry[] classRefs) {

        return getSignatureEntry(SignatureEntry.stringValueOf(formRef, classRefs));

    }

    /** Factory for descriptor (name-and-type) constants. */

    public static DescriptorEntry getDescriptorEntry(Utf8Entry nameRef, SignatureEntry typeRef) {

        Map<String, DescriptorEntry> descriptorEntries = Utils.getTLGlobals().getDescriptorEntries();

        String key = DescriptorEntry.stringValueOf(nameRef, typeRef);

        DescriptorEntry e = descriptorEntries.get(key);

        if (e == null) {

            e = new DescriptorEntry(nameRef, typeRef);

            assert(e.stringValue().equals(key))

                : (e.stringValue()+" != "+(key));

            descriptorEntries.put(key, e);

        }

        return e;

    }

    // Convenience overloading.

    public static DescriptorEntry getDescriptorEntry(Utf8Entry nameRef, Utf8Entry typeRef) {

        return getDescriptorEntry(nameRef, getSignatureEntry(typeRef.stringValue()));

    }

    /** Factory for member reference constants. */

    public static MemberEntry getMemberEntry(byte tag, ClassEntry classRef, DescriptorEntry descRef) {

        Map<String, MemberEntry> memberEntries = Utils.getTLGlobals().getMemberEntries();

        String key = MemberEntry.stringValueOf(tag, classRef, descRef);

        MemberEntry e = memberEntries.get(key);

        if (e == null) {

            e = new MemberEntry(tag, classRef, descRef);

            assert(e.stringValue().equals(key))

                : (e.stringValue()+" != "+(key));

            memberEntries.put(key, e);

        }

        return e;

    }

    /** Factory for MethodHandle constants. */

    public static MethodHandleEntry getMethodHandleEntry(byte refKind, MemberEntry memRef) {

        Map<String, MethodHandleEntry> methodHandleEntries = Utils.getTLGlobals().getMethodHandleEntries();

        String key = MethodHandleEntry.stringValueOf(refKind, memRef);

        MethodHandleEntry e = methodHandleEntries.get(key);

        if (e == null) {

            e = new MethodHandleEntry(refKind, memRef);

            assert(e.stringValue().equals(key));

            methodHandleEntries.put(key, e);

        }

        return e;

    }

    /** Factory for MethodType constants. */

    public static MethodTypeEntry getMethodTypeEntry(SignatureEntry sigRef) {

        Map<String, MethodTypeEntry> methodTypeEntries = Utils.getTLGlobals().getMethodTypeEntries();

        String key = sigRef.stringValue();

        MethodTypeEntry e = methodTypeEntries.get(key);

        if (e == null) {

            e = new MethodTypeEntry(sigRef);

            assert(e.stringValue().equals(key));

            methodTypeEntries.put(key, e);

        }

        return e;

    }

    public static MethodTypeEntry getMethodTypeEntry(Utf8Entry typeRef) {

        return getMethodTypeEntry(getSignatureEntry(typeRef.stringValue()));

    }

    /** Factory for InvokeDynamic constants. */

    public static InvokeDynamicEntry getInvokeDynamicEntry(BootstrapMethodEntry bssRef, DescriptorEntry descRef) {

        Map<String, InvokeDynamicEntry> invokeDynamicEntries = Utils.getTLGlobals().getInvokeDynamicEntries();

        String key = InvokeDynamicEntry.stringValueOf(bssRef, descRef);

        InvokeDynamicEntry e = invokeDynamicEntries.get(key);

        if (e == null) {

            e = new InvokeDynamicEntry(bssRef, descRef);

            assert(e.stringValue().equals(key));

            invokeDynamicEntries.put(key, e);

        }

        return e;

    }

    /** Factory for BootstrapMethod pseudo-constants. */

    public static BootstrapMethodEntry getBootstrapMethodEntry(MethodHandleEntry bsmRef, Entry[] argRefs) {

        Map<String, BootstrapMethodEntry> bootstrapMethodEntries = Utils.getTLGlobals().getBootstrapMethodEntries();

        String key = BootstrapMethodEntry.stringValueOf(bsmRef, argRefs);

        BootstrapMethodEntry e = bootstrapMethodEntries.get(key);

        if (e == null) {

            e = new BootstrapMethodEntry(bsmRef, argRefs);

            assert(e.stringValue().equals(key));

            bootstrapMethodEntries.put(key, e);

        }

        return e;

    }

    /** Entries in the constant pool. */

    class Entry implements Comparable<Object> {

        protected final byte tag;       // a CONSTANT_foo code

        protected int valueHash;        // cached hashCode

        protected Entry(byte tag) {

            this.tag = tag;

        }

        public final byte getTag() {

            return tag;

        }

        public final boolean tagEquals(int tag) {

            return getTag() == tag;

        }

        public Entry getRef(int i) {

            return null;

        }

        public boolean eq(Entry that) {  // same reference

            assert(that != null);

            return this == that || this.equals(that);

        }

        // Equality of Entries is value-based.

        public abstract boolean equals(Object o);

        public final int hashCode() {

            if (valueHash == 0) {

                valueHash = computeValueHash();

                if (valueHash == 0)  valueHash = 1;

            }

            return valueHash;

        }

        protected abstract int computeValueHash();

        public abstract int compareTo(Object o);

        protected int superCompareTo(Object o) {

            Entry that = (Entry) o;

            if (this.tag != that.tag) {

                return TAG_ORDER[this.tag] - TAG_ORDER[that.tag];

            }

            return 0;  // subclasses must refine this

        }

        public final boolean isDoubleWord() {

            return tag == CONSTANT_Double || tag == CONSTANT_Long;

        }

        public final boolean tagMatches(int matchTag) {

            if (tag == matchTag)

                return true;

            byte[] allowedTags;

            switch (matchTag) {

                case CONSTANT_All:

                    return true;

                case CONSTANT_Signature:

                    return tag == CONSTANT_Utf8;  // format check also?

                case CONSTANT_LoadableValue:

                    allowedTags = LOADABLE_VALUE_TAGS;

                    break;

                case CONSTANT_AnyMember:

                    allowedTags = ANY_MEMBER_TAGS;

                    break;

                case CONSTANT_FieldSpecific:

                    allowedTags = FIELD_SPECIFIC_TAGS;

                    break;

                default:

                    return false;

            }

            for (byte b : allowedTags) {

                if (b == tag)

                    return true;

            }

            return false;

        }

        public String toString() {

            String valuePrint = stringValue();

            if (verbose() > 4) {

                if (valueHash != 0)

                    valuePrint += " hash="+valueHash;

                valuePrint += " id="+System.identityHashCode(this);

            }

            return tagName(tag)+"="+valuePrint;

        }

        public abstract String stringValue();

    }

    public static

    class Utf8Entry extends Entry {

        final String value;

        Utf8Entry(String value) {

            super(CONSTANT_Utf8);

            this.value = value.intern();

            hashCode();  // force computation of valueHash

        }

        protected int computeValueHash() {

            return value.hashCode();

        }

        public boolean equals(Object o) {

            // Use reference equality of interned strings:

            return (o != null && o.getClass() == Utf8Entry.class

                    && ((Utf8Entry) o).value.equals(value));

        }

        public int compareTo(Object o) {

            int x = superCompareTo(o);

            if (x == 0) {

                x = value.compareTo(((Utf8Entry)o).value);

            }

            return x;

        }

        public String stringValue() {

            return value;

        }

    }

    static boolean isMemberTag(byte tag) {

        switch (tag) {

        case CONSTANT_Fieldref:

        case CONSTANT_Methodref:

        case CONSTANT_InterfaceMethodref:

            return true;

        }

        return false;

    }

    static byte numberTagOf(Number value) {

        if (value instanceof Integer)  return CONSTANT_Integer;

        if (value instanceof Float)    return CONSTANT_Float;

        if (value instanceof Long)     return CONSTANT_Long;

        if (value instanceof Double)   return CONSTANT_Double;

        throw new RuntimeException("bad literal value "+value);

    }

    static boolean isRefKind(byte refKind) {

        return (REF_getField <= refKind && refKind <= REF_invokeInterface);

    }

    class LiteralEntry extends Entry {

        protected LiteralEntry(byte tag) {

            super(tag);

        }

        public abstract Comparable<?> literalValue();

    }

    public static

    class NumberEntry extends LiteralEntry {

        final Number value;

        NumberEntry(Number value) {

            super(numberTagOf(value));

            this.value = value;

            hashCode();  // force computation of valueHash

        }

        protected int computeValueHash() {

            return value.hashCode();

        }

        public boolean equals(Object o) {

            return (o != null && o.getClass() == NumberEntry.class

                    && ((NumberEntry) o).value.equals(value));

        }

        public int compareTo(Object o) {

            int x = superCompareTo(o);

            if (x == 0) {

                @SuppressWarnings("unchecked")

                Comparable<Number> compValue = (Comparable<Number>)value;

                x = compValue.compareTo(((NumberEntry)o).value);

            }

            return x;

        }

        public Number numberValue() {

            return value;

        }

        public Comparable<?> literalValue() {

            return (Comparable<?>) value;

        }

        public String stringValue() {

            return value.toString();

        }

    }

    public static

    class StringEntry extends LiteralEntry {

        final Utf8Entry ref;

        public Entry getRef(int i) { return i == 0 ? ref : null; }

        StringEntry(Entry ref) {

            super(CONSTANT_String);

            this.ref = (Utf8Entry) ref;

            hashCode();  // force computation of valueHash

        }

        protected int computeValueHash() {

            return ref.hashCode() + tag;

        }

        public boolean equals(Object o) {

            return (o != null && o.getClass() == StringEntry.class &&

                    ((StringEntry)o).ref.eq(ref));

        }

        public int compareTo(Object o) {

            int x = superCompareTo(o);

            if (x == 0) {

                x = ref.compareTo(((StringEntry)o).ref);

            }

            return x;

        }

        public Comparable<?> literalValue() {

            return ref.stringValue();

        }

        public String stringValue() {

            return ref.stringValue();

        }

    }

    public static

    class ClassEntry extends Entry {

        final Utf8Entry ref;

        public Entry getRef(int i) { return i == 0 ? ref : null; }

        protected int computeValueHash() {

            return ref.hashCode() + tag;

        }

        ClassEntry(Entry ref) {

            super(CONSTANT_Class);

            this.ref = (Utf8Entry) ref;

            hashCode();  // force computation of valueHash

        }

        public boolean equals(Object o) {

            return (o != null && o.getClass() == ClassEntry.class

                    && ((ClassEntry) o).ref.eq(ref));

        }

        public int compareTo(Object o) {

            int x = superCompareTo(o);

            if (x == 0) {

                x = ref.compareTo(((ClassEntry)o).ref);

            }

            return x;

        }

        public String stringValue() {

            return ref.stringValue();

        }

    }

    public static

    class DescriptorEntry extends Entry {

        final Utf8Entry      nameRef;

        final SignatureEntry typeRef;

        public Entry getRef(int i) {

            if (i == 0)  return nameRef;

            if (i == 1)  return typeRef;

            return null;

        }

        DescriptorEntry(Entry nameRef, Entry typeRef) {

            super(CONSTANT_NameandType);

            if (typeRef instanceof Utf8Entry) {

                typeRef = getSignatureEntry(typeRef.stringValue());

            }

            this.nameRef = (Utf8Entry) nameRef;

            this.typeRef = (SignatureEntry) typeRef;

            hashCode();  // force computation of valueHash

        }

        protected int computeValueHash() {

            int hc2 = typeRef.hashCode();

            return (nameRef.hashCode() + (hc2 << 8)) ^ hc2;

        }

        public boolean equals(Object o) {

            if (o == null || o.getClass() != DescriptorEntry.class) {

                return false;

            }

            DescriptorEntry that = (DescriptorEntry)o;

            return this.nameRef.eq(that.nameRef)

                && this.typeRef.eq(that.typeRef);

        }

        public int compareTo(Object o) {

            int x = superCompareTo(o);

            if (x == 0) {

                DescriptorEntry that = (DescriptorEntry)o;

                // Primary key is typeRef, not nameRef.

                x = this.typeRef.compareTo(that.typeRef);

                if (x == 0)

                    x = this.nameRef.compareTo(that.nameRef);

            }

            return x;

        }

        public String stringValue() {

            return stringValueOf(nameRef, typeRef);

        }

        static

        String stringValueOf(Entry nameRef, Entry typeRef) {

            return qualifiedStringValue(typeRef, nameRef);

        }

        public String prettyString() {

            return nameRef.stringValue()+typeRef.prettyString();

        }

        public boolean isMethod() {

            return typeRef.isMethod();

        }

        public byte getLiteralTag() {

            return typeRef.getLiteralTag();

        }

    }

    static String qualifiedStringValue(Entry e1, Entry e2) {

        return qualifiedStringValue(e1.stringValue(), e2.stringValue());

    }

    static String qualifiedStringValue(String s1, String s234) {

        // Qualification by dot must decompose uniquely.  Second string might already be qualified.