* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.

import java.util.HashMap;

import java.util.Map;

import com.sun.org.apache.bcel.internal.Const;

import com.sun.org.apache.bcel.internal.classfile.Constant;

import com.sun.org.apache.bcel.internal.classfile.ConstantCP;

import com.sun.org.apache.bcel.internal.classfile.ConstantClass;

import com.sun.org.apache.bcel.internal.classfile.ConstantDouble;

import com.sun.org.apache.bcel.internal.classfile.ConstantFieldref;

import com.sun.org.apache.bcel.internal.classfile.ConstantFloat;

import com.sun.org.apache.bcel.internal.classfile.ConstantInteger;

import com.sun.org.apache.bcel.internal.classfile.ConstantInterfaceMethodref;

import com.sun.org.apache.bcel.internal.classfile.ConstantInvokeDynamic;

import com.sun.org.apache.bcel.internal.classfile.ConstantLong;

import com.sun.org.apache.bcel.internal.classfile.ConstantMethodref;

import com.sun.org.apache.bcel.internal.classfile.ConstantNameAndType;

import com.sun.org.apache.bcel.internal.classfile.ConstantPool;

import com.sun.org.apache.bcel.internal.classfile.ConstantString;

import com.sun.org.apache.bcel.internal.classfile.ConstantUtf8;

 * This class is used to build up a constant pool. The user adds constants via

 * `addXXX' methods, `addString', `addClass', etc.. These methods return an

 * index into the constant pool. Finally, `getFinalConstantPool()' returns the

 * constant pool built up. Intermediate versions of the constant pool can be

 * Constants.MAX_SHORT entries. Note that the first (0) is used by the JVM and

 * that Double and Long constants need two slots.

 * @version $Id: ConstantPoolGen.java 1749603 2016-06-21 20:50:19Z ggregory $

public class ConstantPoolGen {

    private static final int DEFAULT_BUFFER_SIZE = 256;

    private int size;

    private Constant[] constants;

    private int index = 1; // First entry (0) used by JVM

    private static final String METHODREF_DELIM = ":";

    private static final String IMETHODREF_DELIM = "#";

    private static final String FIELDREF_DELIM = "&";

    private static final String NAT_DELIM = "%"; // Name and Type

    private static class Index {

        final int index;

        Index(final int i) {

            index = i;

        }

    }

    /**

     * Initialize with given array of constants.

     *

     * @param cs array of given constants, new ones will be appended

     */

    public ConstantPoolGen(final Constant[] cs) {

        final StringBuilder sb = new StringBuilder(DEFAULT_BUFFER_SIZE);

        size = Math.max(DEFAULT_BUFFER_SIZE, cs.length + 64);

        constants = new Constant[size];

        System.arraycopy(cs, 0, constants, 0, cs.length);

        if (cs.length > 0) {

            index = cs.length;

        }

        for (int i = 1; i < index; i++) {

            final Constant c = constants[i];

            if (c instanceof ConstantString) {

                final ConstantString s = (ConstantString) c;

                final ConstantUtf8 u8 = (ConstantUtf8) constants[s.getStringIndex()];

                final String key = u8.getBytes();

                if (!string_table.containsKey(key)) {

                    string_table.put(key, new Index(i));

                }

            } else if (c instanceof ConstantClass) {

                final ConstantClass s = (ConstantClass) c;

                final ConstantUtf8 u8 = (ConstantUtf8) constants[s.getNameIndex()];

                final String key = u8.getBytes();

                if (!class_table.containsKey(key)) {

                    class_table.put(key, new Index(i));

                }

            } else if (c instanceof ConstantNameAndType) {

                final ConstantNameAndType n = (ConstantNameAndType) c;

                final ConstantUtf8 u8 = (ConstantUtf8) constants[n.getNameIndex()];

                final ConstantUtf8 u8_2 = (ConstantUtf8) constants[n.getSignatureIndex()];

                sb.append(u8.getBytes());

                sb.append(NAT_DELIM);

                sb.append(u8_2.getBytes());

                final String key = sb.toString();

                sb.delete(0, sb.length());

                if (!n_a_t_table.containsKey(key)) {

                    n_a_t_table.put(key, new Index(i));

                }

            } else if (c instanceof ConstantUtf8) {

                final ConstantUtf8 u = (ConstantUtf8) c;

                final String key = u.getBytes();

                if (!utf8_table.containsKey(key)) {

                    utf8_table.put(key, new Index(i));

                }

            } else if (c instanceof ConstantCP) {

                final ConstantCP m = (ConstantCP) c;

                String class_name;

                ConstantUtf8 u8;

                if (c instanceof ConstantInvokeDynamic) {

                    class_name = Integer.toString(((ConstantInvokeDynamic) m).getBootstrapMethodAttrIndex());

                    // since name can't begin with digit, can  use

                    // METHODREF_DELIM with out fear of duplicates.

                } else {

                    final ConstantClass clazz = (ConstantClass) constants[m.getClassIndex()];

                    u8 = (ConstantUtf8) constants[clazz.getNameIndex()];

                    class_name = u8.getBytes().replace('/', '.');

                }

                final ConstantNameAndType n = (ConstantNameAndType) constants[m.getNameAndTypeIndex()];

                u8 = (ConstantUtf8) constants[n.getNameIndex()];

                final String method_name = u8.getBytes();

                u8 = (ConstantUtf8) constants[n.getSignatureIndex()];

                final String signature = u8.getBytes();

                String delim = METHODREF_DELIM;

                if (c instanceof ConstantInterfaceMethodref) {

                    delim = IMETHODREF_DELIM;

                } else if (c instanceof ConstantFieldref) {

                    delim = FIELDREF_DELIM;

                }

                sb.append(class_name);

                sb.append(delim);

                sb.append(method_name);

                sb.append(delim);

                sb.append(signature);

                final String key = sb.toString();

                sb.delete(0, sb.length());

                if (!cp_table.containsKey(key)) {

                    cp_table.put(key, new Index(i));

                }

            } else if (c == null) { // entries may be null

                // nothing to do

            } else if (c instanceof ConstantInteger) {

                // nothing to do

            } else if (c instanceof ConstantLong) {

                // nothing to do

            } else if (c instanceof ConstantFloat) {

                // nothing to do

            } else if (c instanceof ConstantDouble) {

                // nothing to do

            } else if (c instanceof com.sun.org.apache.bcel.internal.classfile.ConstantMethodType) {

                // TODO should this be handled somehow?

            } else if (c instanceof com.sun.org.apache.bcel.internal.classfile.ConstantMethodHandle) {

                // TODO should this be handled somehow?

            } else {

                assert false : "Unexpected constant type: " + c.getClass().getName();

            }

        }

    }

    /**

     * Initialize with given constant pool.

     */

    public ConstantPoolGen(final ConstantPool cp) {

        this(cp.getConstantPool());

    }

    /**

     * Create empty constant pool.

     */

    public ConstantPoolGen() {

        size = DEFAULT_BUFFER_SIZE;

        constants = new Constant[size];

    /**

     * Resize internal array of constants.

     */

    protected void adjustSize() {

        if (index + 3 >= size) {

            final Constant[] cs = constants;

            size *= 2;

            constants = new Constant[size];

            System.arraycopy(cs, 0, constants, 0, index);

        }

    }

    private final Map<String, Index> string_table = new HashMap<>();

    /**

     * Look for ConstantString in ConstantPool containing String `str'.

     *

     * @param str String to search for

     * @return index on success, -1 otherwise

     */

    public int lookupString(final String str) {

        final Index index = string_table.get(str);

        return (index != null) ? index.index : -1;

    /**

     * Add a new String constant to the ConstantPool, if it is not already in

     * there.

     *

     * @param str String to add

     * @return index of entry

     */

    public int addString(final String str) {

        int ret;

        if ((ret = lookupString(str)) != -1) {

            return ret; // Already in CP

        }

        final int utf8 = addUtf8(str);

        adjustSize();

        final ConstantString s = new ConstantString(utf8);

        ret = index;

        constants[index++] = s;

        if (!string_table.containsKey(str)) {

            string_table.put(str, new Index(ret));

        }

        return ret;

    }

    private final Map<String, Index> class_table = new HashMap<>();

    /**

     * Look for ConstantClass in ConstantPool named `str'.

     *

     * @param str String to search for

     * @return index on success, -1 otherwise

     */

    public int lookupClass(final String str) {

        final Index index = class_table.get(str.replace('.', '/'));

        return (index != null) ? index.index : -1;

    }

    private int addClass_(final String clazz) {

        int ret;

        if ((ret = lookupClass(clazz)) != -1) {

            return ret; // Already in CP

        }

        adjustSize();

        final ConstantClass c = new ConstantClass(addUtf8(clazz));

        ret = index;

        constants[index++] = c;

        if (!class_table.containsKey(clazz)) {

            class_table.put(clazz, new Index(ret));

        }

        return ret;

    }

    /**

     * Add a new Class reference to the ConstantPool, if it is not already in

     * there.

     *

     * @param str Class to add

     * @return index of entry

     */

    public int addClass(final String str) {

        return addClass_(str.replace('.', '/'));

    /**

     * Add a new Class reference to the ConstantPool for a given type.

     *

     * @param type Class to add

     * @return index of entry

     */

    public int addClass(final ObjectType type) {

        return addClass(type.getClassName());

    }

    /**

     * Add a reference to an array class (e.g. String[][]) as needed by

     * MULTIANEWARRAY instruction, e.g. to the ConstantPool.

     *

     * @param type type of array class

     * @return index of entry

     */

    public int addArrayClass(final ArrayType type) {

        return addClass_(type.getSignature());

    }

    /**

     * Look for ConstantInteger in ConstantPool.

     *

     * @param n integer number to look for

     * @return index on success, -1 otherwise

     */

    public int lookupInteger(final int n) {

        for (int i = 1; i < index; i++) {

            if (constants[i] instanceof ConstantInteger) {

                final ConstantInteger c = (ConstantInteger) constants[i];

                if (c.getBytes() == n) {

                    return i;

                }

            }

        }

        return -1;

    /**

     * Add a new Integer constant to the ConstantPool, if it is not already in

     * there.

     *

     * @param n integer number to add

     * @return index of entry

     */

    public int addInteger(final int n) {

        int ret;

        if ((ret = lookupInteger(n)) != -1) {

            return ret; // Already in CP

        }

        adjustSize();

        ret = index;

        constants[index++] = new ConstantInteger(n);

        return ret;

    }

    /**

     * Look for ConstantFloat in ConstantPool.

     *

     * @param n Float number to look for

     * @return index on success, -1 otherwise

     */

    public int lookupFloat(final float n) {

        final int bits = Float.floatToIntBits(n);

        for (int i = 1; i < index; i++) {

            if (constants[i] instanceof ConstantFloat) {

                final ConstantFloat c = (ConstantFloat) constants[i];

                if (Float.floatToIntBits(c.getBytes()) == bits) {

                    return i;

                }

            }

        }

        return -1;

    }

    /**

     * Add a new Float constant to the ConstantPool, if it is not already in

     * there.

     *

     * @param n Float number to add

     * @return index of entry

     */

    public int addFloat(final float n) {

        int ret;

        if ((ret = lookupFloat(n)) != -1) {

            return ret; // Already in CP

        }

        adjustSize();

        ret = index;

        constants[index++] = new ConstantFloat(n);

        return ret;

    }

    private final Map<String, Index> utf8_table = new HashMap<>();

    /**

     * Look for ConstantUtf8 in ConstantPool.

     *

     * @param n Utf8 string to look for

     * @return index on success, -1 otherwise

     */

    public int lookupUtf8(final String n) {

        final Index index = utf8_table.get(n);

        return (index != null) ? index.index : -1;

    /**

     * Add a new Utf8 constant to the ConstantPool, if it is not already in

     * there.

     *

     * @param n Utf8 string to add

     * @return index of entry

     */

    public int addUtf8(final String n) {

        int ret;

        if ((ret = lookupUtf8(n)) != -1) {

            return ret; // Already in CP

        }

        adjustSize();

        ret = index;

        constants[index++] = new ConstantUtf8(n);

        if (!utf8_table.containsKey(n)) {

            utf8_table.put(n, new Index(ret));

        }

        return ret;

    }

    /**

     * Look for ConstantLong in ConstantPool.

     *

     * @param n Long number to look for

     * @return index on success, -1 otherwise

     */

    public int lookupLong(final long n) {

        for (int i = 1; i < index; i++) {

            if (constants[i] instanceof ConstantLong) {

                final ConstantLong c = (ConstantLong) constants[i];

                if (c.getBytes() == n) {

                    return i;

                }

            }

        }

        return -1;

    }

    /**

     * Add a new long constant to the ConstantPool, if it is not already in

     * there.

     *

     * @param n Long number to add

     * @return index of entry

     */

    public int addLong(final long n) {

        int ret;

        if ((ret = lookupLong(n)) != -1) {

            return ret; // Already in CP

        }

        adjustSize();

        ret = index;

        constants[index] = new ConstantLong(n);

        index += 2; // Wastes one entry according to spec

        return ret;

    }

    /**

     * Look for ConstantDouble in ConstantPool.

     *

     * @param n Double number to look for

     * @return index on success, -1 otherwise

     */

    public int lookupDouble(final double n) {

        final long bits = Double.doubleToLongBits(n);

        for (int i = 1; i < index; i++) {

            if (constants[i] instanceof ConstantDouble) {

                final ConstantDouble c = (ConstantDouble) constants[i];

                if (Double.doubleToLongBits(c.getBytes()) == bits) {

                    return i;

                }

            }

        }

        return -1;

    }

    /**

     * Add a new double constant to the ConstantPool, if it is not already in

     * there.

     *

     * @param n Double number to add

     * @return index of entry

     */

    public int addDouble(final double n) {

        int ret;

        if ((ret = lookupDouble(n)) != -1) {

            return ret; // Already in CP

        }

        adjustSize();

        ret = index;

        constants[index] = new ConstantDouble(n);

        index += 2; // Wastes one entry according to spec

        return ret;

    }

    private final Map<String, Index> n_a_t_table = new HashMap<>();

    /**

     * Look for ConstantNameAndType in ConstantPool.