FileDocCategorySizeDatePackage
ConstantPool.javaAPI DocJava SE 5 API11977Fri Aug 26 14:55:16 BST 2005com.sun.org.apache.bcel.internal.classfile

ConstantPool

public class ConstantPool extends Object implements Node, Cloneable
This class represents the constant pool, i.e., a table of constants. It may contain null references, due to the JVM specification that skips an entry after an 8-byte constant (double, long) entry.
version
$Id: ConstantPool.java,v 1.1.1.1 2001/10/29 19:59:59 jvanzyl Exp $
see
Constant
author
M. Dahm

Fields Summary
private int
constant_pool_count
private Constant[]
constant_pool
Constructors Summary
public ConstantPool(Constant[] constant_pool)

param
constant_pool Array of constants

    setConstantPool(constant_pool);
  
ConstantPool(DataInputStream file)
Read constants from given file stream.

param
file Input stream
throw
IOException
throw
ClassFormatError

    byte tag;

    constant_pool_count = file.readUnsignedShort();
    constant_pool       = new Constant[constant_pool_count];

    /* constant_pool[0] is unused by the compiler and may be used freely
     * by the implementation.
     */
    for(int i=1; i < constant_pool_count; i++) {
      constant_pool[i] = Constant.readConstant(file);
	  
      /* Quote from the JVM specification:
       * "All eight byte constants take up two spots in the constant pool.
       * If this is the n'th byte in the constant pool, then the next item
       * will be numbered n+2"
       * 
       * Thus we have to increment the index counter.
       */
      tag = constant_pool[i].getTag();
      if((tag == Constants.CONSTANT_Double) || (tag == Constants.CONSTANT_Long))
	i++;
    }
  
Methods Summary
public voidaccept(com.sun.org.apache.bcel.internal.classfile.Visitor v)
Called by objects that are traversing the nodes of the tree implicitely defined by the contents of a Java class. I.e., the hierarchy of methods, fields, attributes, etc. spawns a tree of objects.

param
v Visitor object

    v.visitConstantPool(this);
  
public java.lang.StringconstantToString(com.sun.org.apache.bcel.internal.classfile.Constant c)
Resolve constant to a string representation.

param
constant Constant to be printed
return
String representation

    String   str;
    int      i;
    byte     tag = c.getTag();

    switch(tag) {
    case Constants.CONSTANT_Class: 
      i   = ((ConstantClass)c).getNameIndex();
      c   = getConstant(i, Constants.CONSTANT_Utf8);
      str = Utility.compactClassName(((ConstantUtf8)c).getBytes(), false);
      break;

    case Constants.CONSTANT_String:
      i   = ((ConstantString)c).getStringIndex();
      c   = getConstant(i, Constants.CONSTANT_Utf8);
      str = "\"" + escape(((ConstantUtf8)c).getBytes()) + "\"";
      break;

    case Constants.CONSTANT_Utf8:    str = ((ConstantUtf8)c).getBytes();         break;
    case Constants.CONSTANT_Double:  str = "" + ((ConstantDouble)c).getBytes();  break;
    case Constants.CONSTANT_Float:   str = "" + ((ConstantFloat)c).getBytes();   break;
    case Constants.CONSTANT_Long:    str = "" + ((ConstantLong)c).getBytes();    break;
    case Constants.CONSTANT_Integer: str = "" + ((ConstantInteger)c).getBytes(); break;

    case Constants.CONSTANT_NameAndType:
      str = (constantToString(((ConstantNameAndType)c).getNameIndex(),
			      Constants.CONSTANT_Utf8) + " " +
	     constantToString(((ConstantNameAndType)c).getSignatureIndex(),
			      Constants.CONSTANT_Utf8));
      break;

    case Constants.CONSTANT_InterfaceMethodref: case Constants.CONSTANT_Methodref:
    case Constants.CONSTANT_Fieldref:
      str = (constantToString(((ConstantCP)c).getClassIndex(),
			      Constants.CONSTANT_Class) + "." + 
	     constantToString(((ConstantCP)c).getNameAndTypeIndex(),
			      Constants.CONSTANT_NameAndType));	     
      break;

    default: // Never reached
      throw new RuntimeException("Unknown constant type " + tag);
    }
	
    return str;
  
public java.lang.StringconstantToString(int index, byte tag)
Retrieve constant at `index' from constant pool and resolve it to a string representation.

param
index of constant in constant pool
param
tag expected type
return
String representation

    Constant c = getConstant(index, tag);
    return constantToString(c);
  
public com.sun.org.apache.bcel.internal.classfile.ConstantPoolcopy()

return
deep copy of this constant pool

    ConstantPool c = null;

    try {
      c = (ConstantPool)clone();
    } catch(CloneNotSupportedException e) {}

    c.constant_pool = new Constant[constant_pool_count];

    for(int i=1; i < constant_pool_count; i++) {
      if(constant_pool[i] != null)
	c.constant_pool[i] = constant_pool[i].copy();
    }

    return c;
  
public voiddump(java.io.DataOutputStream file)
Dump constant pool to file stream in binary format.

param
file Output file stream
throw
IOException

    file.writeShort(constant_pool_count);

    for(int i=1; i < constant_pool_count; i++)
      if(constant_pool[i] != null)
	constant_pool[i].dump(file);
  
private static final java.lang.Stringescape(java.lang.String str)

    int          len = str.length();
    StringBuffer buf = new StringBuffer(len + 5);
    char[]       ch  = str.toCharArray();

    for(int i=0; i < len; i++) {
      switch(ch[i]) {
      case '\n" : buf.append("\\n"); break;
      case '\r" : buf.append("\\r"); break;
      case '\t" : buf.append("\\t"); break;
      case '\b" : buf.append("\\b"); break;
      case '""  : buf.append("\\\""); break;
      default: buf.append(ch[i]);
      }
    }

    return buf.toString();
  
public com.sun.org.apache.bcel.internal.classfile.ConstantgetConstant(int index)
Get constant from constant pool.

param
index Index in constant pool
return
Constant value
see
Constant

    if (index >= constant_pool.length || index < 0)
      throw new ClassFormatError("Invalid constant pool reference: " +
				 index + ". Constant pool size is: " +
				 constant_pool.length);
    return constant_pool[index];
  
public com.sun.org.apache.bcel.internal.classfile.ConstantgetConstant(int index, byte tag)
Get constant from constant pool and check whether it has the expected type.

param
index Index in constant pool
param
tag Tag of expected constant, i.e., its type
return
Constant value
see
Constant
throw
ClassFormatError

    Constant c;

    c = getConstant(index);

    if(c == null)
      throw new ClassFormatError("Constant pool at index " + index + " is null.");

    if(c.getTag() == tag)
      return c;
    else
      throw new ClassFormatError("Expected class `" + Constants.CONSTANT_NAMES[tag] + 
				 "' at index " + index + " and got " + c);
  
public com.sun.org.apache.bcel.internal.classfile.Constant[]getConstantPool()

return
Array of constants.
see
Constant

 return constant_pool;  
public java.lang.StringgetConstantString(int index, byte tag)
Get string from constant pool and bypass the indirection of `ConstantClass' and `ConstantString' objects. I.e. these classes have an index field that points to another entry of the constant pool of type `ConstantUtf8' which contains the real data.

param
index Index in constant pool
param
tag Tag of expected constant, either ConstantClass or ConstantString
return
Contents of string reference
see
ConstantClass
see
ConstantString
throw
ClassFormatError

    Constant c;
    int    i;
    String   s;

    c = getConstant(index, tag);

    /* This switch() is not that elegant, since the two classes have the
     * same contents, they just differ in the name of the index
     * field variable.
     * But we want to stick to the JVM naming conventions closely though
     * we could have solved these more elegantly by using the same
     * variable name or by subclassing.
     */
    switch(tag) {
    case Constants.CONSTANT_Class:  i = ((ConstantClass)c).getNameIndex();    break;
    case Constants.CONSTANT_String: i = ((ConstantString)c).getStringIndex(); break;
    default:
      throw new RuntimeException("getConstantString called with illegal tag " + tag);
    }

    // Finally get the string from the constant pool
    c = getConstant(i, Constants.CONSTANT_Utf8);
    return ((ConstantUtf8)c).getBytes();
  
public intgetLength()

return
Length of constant pool.

    return constant_pool_count;
  
public voidsetConstant(int index, com.sun.org.apache.bcel.internal.classfile.Constant constant)

param
constant Constant to set

    constant_pool[index] = constant;
  
public voidsetConstantPool(com.sun.org.apache.bcel.internal.classfile.Constant[] constant_pool)

param
constant_pool

    this.constant_pool = constant_pool;
    constant_pool_count = (constant_pool == null)? 0 : constant_pool.length;
  
public java.lang.StringtoString()

return
String representation.

    StringBuffer buf = new StringBuffer();

    for(int i=1; i < constant_pool_count; i++)
      buf.append(i + ")" + constant_pool[i] + "\n");

    return buf.toString();