jdk-sandbox: comparison jaxp/src/java.xml/share/classes/com/sun/org/apache/bcel/internal/generic/ConstantPoolGen.java

equal deleted inserted replaced

-:3d364c870c90
+:686eef1e7a79
+/*
+* reserved comment block
+* DO NOT REMOVE OR ALTER!
+*/
+package com.sun.org.apache.bcel.internal.generic;
+/* ====================================================================
+* The Apache Software License, Version 1.1
+*
+* Copyright (c) 2001 The Apache Software Foundation.  All rights
+* reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions
+* are met:
+*
+* 1. Redistributions of source code must retain the above copyright
+*    notice, this list of conditions and the following disclaimer.
+*
+* 2. Redistributions in binary form must reproduce the above copyright
+*    notice, this list of conditions and the following disclaimer in
+*    the documentation and/or other materials provided with the
+*    distribution.
+*
+* 3. The end-user documentation included with the redistribution,
+*    if any, must include the following acknowledgment:
+*       "This product includes software developed by the
+*        Apache Software Foundation (http://www.apache.org/)."
+*    Alternately, this acknowledgment may appear in the software itself,
+*    if and wherever such third-party acknowledgments normally appear.
+*
+* 4. The names "Apache" and "Apache Software Foundation" and
+*    "Apache BCEL" must not be used to endorse or promote products
+*    derived from this software without prior written permission. For
+*    written permission, please contact apache@apache.org.
+*
+* 5. Products derived from this software may not be called "Apache",
+*    "Apache BCEL", nor may "Apache" appear in their name, without
+*    prior written permission of the Apache Software Foundation.
+*
+* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+* SUCH DAMAGE.
+* ====================================================================
+*
+* This software consists of voluntary contributions made by many
+* individuals on behalf of the Apache Software Foundation.  For more
+* information on the Apache Software Foundation, please see
+* <http://www.apache.org/>.
+*/
+import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.classfile.*;
+import java.util.HashMap;
+/**
+* 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
+* obtained with `getConstantPool()'. A constant pool has capacity for
+* Constants.MAX_SHORT entries. Note that the first (0) is used by the
+* JVM and that Double and Long constants need two slots.
+*
+* @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
+* @see Constant
+*/
+public class ConstantPoolGen implements java.io.Serializable {
+protected int        size      = 1024; // Inital size, sufficient in most cases
+protected Constant[] constants = new Constant[size];
+protected 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        = "%";
+private static class Index implements java.io.Serializable {
+int index;
+Index(int i) { index = i; }
+}
+/**
+* Initialize with given array of constants.
+*
+* @param c array of given constants, new ones will be appended
+*/
+public ConstantPoolGen(Constant[] cs) {
+if(cs.length > size) {
+size      = cs.length;
+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++) {
+Constant c = constants[i];
+if(c instanceof ConstantString) {
+ConstantString s  = (ConstantString)c;
+ConstantUtf8   u8 = (ConstantUtf8)constants[s.getStringIndex()];
+string_table.put(u8.getBytes(), new Index(i));
+} else if(c instanceof ConstantClass) {
+ConstantClass s  = (ConstantClass)c;
+ConstantUtf8  u8 = (ConstantUtf8)constants[s.getNameIndex()];
+class_table.put(u8.getBytes(), new Index(i));
+} else if(c instanceof ConstantNameAndType) {
+ConstantNameAndType n    = (ConstantNameAndType)c;
+ConstantUtf8        u8   = (ConstantUtf8)constants[n.getNameIndex()];
+ConstantUtf8        u8_2 = (ConstantUtf8)constants[n.getSignatureIndex()];
+n_a_t_table.put(u8.getBytes() + NAT_DELIM + u8_2.getBytes(), new Index(i));
+} else if(c instanceof ConstantUtf8) {
+ConstantUtf8 u = (ConstantUtf8)c;
+utf8_table.put(u.getBytes(), new Index(i));
+} else if(c instanceof ConstantCP) {
+ConstantCP          m     = (ConstantCP)c;
+ConstantClass       clazz = (ConstantClass)constants[m.getClassIndex()];
+ConstantNameAndType n     = (ConstantNameAndType)constants[m.getNameAndTypeIndex()];
+ConstantUtf8 u8         = (ConstantUtf8)constants[clazz.getNameIndex()];
+String       class_name = u8.getBytes().replace('/', '.');
+u8 = (ConstantUtf8)constants[n.getNameIndex()];
+String method_name = u8.getBytes();
+u8 = (ConstantUtf8)constants[n.getSignatureIndex()];
+String signature = u8.getBytes();
+String delim = METHODREF_DELIM;
+if(c instanceof ConstantInterfaceMethodref)
+delim = IMETHODREF_DELIM;
+else if(c instanceof ConstantFieldref)
+delim = FIELDREF_DELIM;
+cp_table.put(class_name + delim + method_name + delim + signature, new Index(i));
+}
+}
+}
+/**
+* Initialize with given constant pool.
+*/
+public ConstantPoolGen(ConstantPool cp) {
+this(cp.getConstantPool());
+}
+/**
+* Create empty constant pool.
+*/
+public ConstantPoolGen() {}
+/** Resize internal array of constants.
+*/
+protected void adjustSize() {
+if(index + 3 >= size) {
+Constant[] cs = constants;
+size      *= 2;
+constants  = new Constant[size];
+System.arraycopy(cs, 0, constants, 0, index);
+}
+}
+private HashMap 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(String str) {
+Index 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(String str) {
+int ret;
+if((ret = lookupString(str)) != -1)
+return ret; // Already in CP
+int utf8 = addUtf8(str);
+adjustSize();
+ConstantString s  = new ConstantString(utf8);
+ret = index;
+constants[index++] = s;
+string_table.put(str, new Index(ret));
+return ret;
+}
+private HashMap 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(String str) {
+Index index = (Index)class_table.get(str.replace('.', '/'));
+return (index != null)? index.index : -1;
+}
+private int addClass_(String clazz) {
+int    ret;
+if((ret = lookupClass(clazz)) != -1)
+return ret; // Already in CP
+adjustSize();
+ConstantClass c = new ConstantClass(addUtf8(clazz));
+ret = index;
+constants[index++] = c;
+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(String str) {
+return addClass_(str.replace('.', '/'));
+}
+/**
+* Add a new Class reference to the ConstantPool for a given type.
+*
+* @param str Class to add
+* @return index of entry
+*/
+public int addClass(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(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(int n) {
+for(int i=1; i < index; i++) {
+if(constants[i] instanceof ConstantInteger) {
+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(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(float n) {
+int bits = Float.floatToIntBits(n);
+for(int i=1; i < index; i++) {
+if(constants[i] instanceof ConstantFloat) {
+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(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 HashMap 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(String n) {
+Index 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(String n) {
+int  ret;
+if((ret = lookupUtf8(n)) != -1)
+return ret; // Already in CP
+adjustSize();
+ret = index;
+constants[index++] = new ConstantUtf8(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(long n) {
+for(int i=1; i < index; i++) {
+if(constants[i] instanceof ConstantLong) {
+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(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(double n) {
+long bits = Double.doubleToLongBits(n);
+for(int i=1; i < index; i++) {
+if(constants[i] instanceof ConstantDouble) {
+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(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 HashMap n_a_t_table = new HashMap();
+/**
+* Look for ConstantNameAndType in ConstantPool.
+*
+* @param name of variable/method
+* @param signature of variable/method
+* @return index on success, -1 otherwise
+*/
+public int lookupNameAndType(String name, String signature) {
+Index index = (Index)n_a_t_table.get(name + NAT_DELIM + signature);
+return (index != null)? index.index : -1;
+}
+/**
+* Add a new NameAndType constant to the ConstantPool if it is not already
+* in there.
+*
+* @param n NameAndType string to add
+* @return index of entry
+*/
+public int addNameAndType(String name, String signature) {
+int  ret;
+int  name_index, signature_index;
+if((ret = lookupNameAndType(name, signature)) != -1)
+return ret; // Already in CP
+adjustSize();
+name_index      = addUtf8(name);
+signature_index = addUtf8(signature);
+ret = index;
+constants[index++] = new ConstantNameAndType(name_index, signature_index);
+n_a_t_table.put(name + NAT_DELIM + signature, new Index(ret));
+return ret;
+}
+private HashMap cp_table = new HashMap();
+/**
+* Look for ConstantMethodref in ConstantPool.
+*
+* @param class_name Where to find method
+* @param method_name Guess what
+* @param signature return and argument types
+* @return index on success, -1 otherwise
+*/
+public int lookupMethodref(String class_name, String method_name, String signature) {
+Index index = (Index)cp_table.get(class_name + METHODREF_DELIM + method_name +
+METHODREF_DELIM + signature);
+return (index != null)? index.index : -1;
+}
+public int lookupMethodref(MethodGen method) {
+return lookupMethodref(method.getClassName(), method.getName(),
+method.getSignature());
+}
+/**
+* Add a new Methodref constant to the ConstantPool, if it is not already
+* in there.
+*
+* @param n Methodref string to add
+* @return index of entry
+*/
+public int addMethodref(String class_name, String method_name, String signature) {
+int  ret, class_index, name_and_type_index;
+if((ret = lookupMethodref(class_name, method_name, signature)) != -1)
+return ret; // Already in CP
+adjustSize();
+name_and_type_index = addNameAndType(method_name, signature);
+class_index         = addClass(class_name);
+ret = index;
+constants[index++] = new ConstantMethodref(class_index, name_and_type_index);
+cp_table.put(class_name + METHODREF_DELIM + method_name +
+METHODREF_DELIM + signature, new Index(ret));
+return ret;
+}
+public int addMethodref(MethodGen method) {
+return addMethodref(method.getClassName(), method.getName(),
+method.getSignature());
+}
+/**
+* Look for ConstantInterfaceMethodref in ConstantPool.
+*
+* @param class_name Where to find method
+* @param method_name Guess what
+* @param signature return and argument types
+* @return index on success, -1 otherwise
+*/
+public int lookupInterfaceMethodref(String class_name, String method_name, String signature) {
+Index index = (Index)cp_table.get(class_name + IMETHODREF_DELIM + method_name +
+IMETHODREF_DELIM + signature);
+return (index != null)? index.index : -1;
+}
+public int lookupInterfaceMethodref(MethodGen method) {
+return lookupInterfaceMethodref(method.getClassName(), method.getName(),
+method.getSignature());
+}
+/**
+* Add a new InterfaceMethodref constant to the ConstantPool, if it is not already
+* in there.
+*
+* @param n InterfaceMethodref string to add
+* @return index of entry
+*/
+public int addInterfaceMethodref(String class_name, String method_name, String signature) {
+int ret, class_index, name_and_type_index;
+if((ret = lookupInterfaceMethodref(class_name, method_name, signature)) != -1)
+return ret; // Already in CP
+adjustSize();
+class_index         = addClass(class_name);
+name_and_type_index = addNameAndType(method_name, signature);
+ret = index;
+constants[index++] = new ConstantInterfaceMethodref(class_index, name_and_type_index);
+cp_table.put(class_name + IMETHODREF_DELIM + method_name +
+IMETHODREF_DELIM + signature, new Index(ret));
+return ret;
+}
+public int addInterfaceMethodref(MethodGen method) {
+return addInterfaceMethodref(method.getClassName(), method.getName(),
+method.getSignature());
+}
+/**
+* Look for ConstantFieldref in ConstantPool.
+*
+* @param class_name Where to find method
+* @param field_name Guess what
+* @param signature return and argument types
+* @return index on success, -1 otherwise
+*/
+public int lookupFieldref(String class_name, String field_name, String signature) {
+Index index = (Index)cp_table.get(class_name + FIELDREF_DELIM + field_name +
+FIELDREF_DELIM + signature);
+return (index != null)? index.index : -1;
+}
+/**
+* Add a new Fieldref constant to the ConstantPool, if it is not already
+* in there.
+*
+* @param n Fieldref string to add
+* @return index of entry
+*/
+public int addFieldref(String class_name, String field_name, String signature) {
+int  ret;
+int  class_index, name_and_type_index;
+if((ret = lookupFieldref(class_name, field_name, signature)) != -1)
+return ret; // Already in CP
+adjustSize();
+class_index         = addClass(class_name);
+name_and_type_index = addNameAndType(field_name, signature);
+ret = index;
+constants[index++] = new ConstantFieldref(class_index, name_and_type_index);
+cp_table.put(class_name + FIELDREF_DELIM + field_name + FIELDREF_DELIM + signature, new Index(ret));
+return ret;
+}
+/**
+* @param i index in constant pool
+* @return constant pool entry at index i
+*/
+public Constant getConstant(int i) { return constants[i]; }
+/**
+* Use with care!
+*
+* @param i index in constant pool
+* @param c new constant pool entry at index i
+*/
+public void setConstant(int i, Constant c) { constants[i] = c; }
+/**
+* @return intermediate constant pool
+*/
+public ConstantPool getConstantPool() {
+return new ConstantPool(constants);
+}
+/**
+* @return current size of constant pool
+*/
+public int getSize() {
+return index;
+}
+/**
+* @return constant pool with proper length
+*/
+public ConstantPool getFinalConstantPool() {
+Constant[] cs = new Constant[index];
+System.arraycopy(constants, 0, cs, 0, index);
+return new ConstantPool(cs);
+}
+/**
+* @return String representation.
+*/
+public String toString() {
+StringBuffer buf = new StringBuffer();
+for(int i=1; i < index; i++)
+buf.append(i + ")" + constants[i] + "\n");
+return buf.toString();
+}
+/** Import constant from another ConstantPool and return new index.
+*/
+public int addConstant(Constant c, ConstantPoolGen cp) {
+Constant[] constants = cp.getConstantPool().getConstantPool();
+switch(c.getTag()) {
+case Constants.CONSTANT_String: {
+ConstantString s  = (ConstantString)c;
+ConstantUtf8   u8 = (ConstantUtf8)constants[s.getStringIndex()];
+return addString(u8.getBytes());
+}
+case Constants.CONSTANT_Class: {
+ConstantClass s  = (ConstantClass)c;
+ConstantUtf8  u8 = (ConstantUtf8)constants[s.getNameIndex()];
+return addClass(u8.getBytes());
+}
+case Constants.CONSTANT_NameAndType: {
+ConstantNameAndType n    = (ConstantNameAndType)c;
+ConstantUtf8        u8   = (ConstantUtf8)constants[n.getNameIndex()];
+ConstantUtf8        u8_2 = (ConstantUtf8)constants[n.getSignatureIndex()];
+return addNameAndType(u8.getBytes(), u8_2.getBytes());
+}
+case Constants.CONSTANT_Utf8:
+return addUtf8(((ConstantUtf8)c).getBytes());
+case Constants.CONSTANT_Double:
+return addDouble(((ConstantDouble)c).getBytes());
+case Constants.CONSTANT_Float:
+return addFloat(((ConstantFloat)c).getBytes());
+case Constants.CONSTANT_Long:
+return addLong(((ConstantLong)c).getBytes());
+case Constants.CONSTANT_Integer:
+return addInteger(((ConstantInteger)c).getBytes());
+case Constants.CONSTANT_InterfaceMethodref: case Constants.CONSTANT_Methodref:
+case Constants.CONSTANT_Fieldref: {
+ConstantCP          m     = (ConstantCP)c;
+ConstantClass       clazz = (ConstantClass)constants[m.getClassIndex()];
+ConstantNameAndType n     = (ConstantNameAndType)constants[m.getNameAndTypeIndex()];
+ConstantUtf8 u8           = (ConstantUtf8)constants[clazz.getNameIndex()];
+String       class_name   = u8.getBytes().replace('/', '.');
+u8 = (ConstantUtf8)constants[n.getNameIndex()];
+String name = u8.getBytes();
+u8 = (ConstantUtf8)constants[n.getSignatureIndex()];
+String signature = u8.getBytes();
+switch(c.getTag()) {
+case Constants.CONSTANT_InterfaceMethodref:
+return addInterfaceMethodref(class_name, name, signature);
+case Constants.CONSTANT_Methodref:
+return addMethodref(class_name, name, signature);
+case Constants.CONSTANT_Fieldref:
+return addFieldref(class_name, name, signature);
+default: // Never reached
+throw new RuntimeException("Unknown constant type " + c);
+}
+}
+default: // Never reached
+throw new RuntimeException("Unknown constant type " + c);
+}
+}
+}

changeset 25868	686eef1e7a79
parent 12457	c348e06f0e82
child 44797	8b3b3b911b8a