Java Code Examples for org.apache.bcel.Constants#CONSTANT_Double

/**
 * @return String representation of constant value.
 */ 
public final String toString() {
  Constant c = constant_pool.getConstant(constantvalue_index);
	
  String   buf;
  int    i;

  // Print constant to string depending on its type
  switch(c.getTag()) {
  case Constants.CONSTANT_Long:    buf = "" + ((ConstantLong)c).getBytes();    break;
  case Constants.CONSTANT_Float:   buf = "" + ((ConstantFloat)c).getBytes();   break;
  case Constants.CONSTANT_Double:  buf = "" + ((ConstantDouble)c).getBytes();  break;
  case Constants.CONSTANT_Integer: buf = "" + ((ConstantInteger)c).getBytes(); break;
  case Constants.CONSTANT_String:  
    i   = ((ConstantString)c).getStringIndex();
    c   = constant_pool.getConstant(i, Constants.CONSTANT_Utf8);
    buf = "\"" + Utility.convertString(((ConstantUtf8)c).getBytes()) + "\"";
    break;

  default:
    throw new IllegalStateException("Type of ConstValue invalid: " + c);
  }

  return buf;
}
 

/**
  * Read constants from given file stream.
  *
  * @param file Input stream
  * @throws IOException
  * @throws ClassFormatException
  */
 ConstantPool(DataInputStream file) throws IOException, ClassFormatException
 {
   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++;
   }
 }
 

/**
 * Read one constant from the given file, the type depends on a tag byte.
 *
 * @param file Input stream
 * @return Constant object
 */
static final Constant readConstant(DataInputStream file)
  throws IOException, ClassFormatException
{
  byte b = file.readByte(); // Read tag byte

  switch(b) {
  case Constants.CONSTANT_Class:              return new ConstantClass(file);
  case Constants.CONSTANT_Fieldref:           return new ConstantFieldref(file);
  case Constants.CONSTANT_Methodref:          return new ConstantMethodref(file);
  case Constants.CONSTANT_InterfaceMethodref: return new 
			ConstantInterfaceMethodref(file);
  case Constants.CONSTANT_String:             return new ConstantString(file);
  case Constants.CONSTANT_Integer:            return new ConstantInteger(file);
  case Constants.CONSTANT_Float:              return new ConstantFloat(file);
  case Constants.CONSTANT_Long:               return new ConstantLong(file);
  case Constants.CONSTANT_Double:             return new ConstantDouble(file);
  case Constants.CONSTANT_NameAndType:        return new ConstantNameAndType(file);
  case Constants.CONSTANT_Utf8:               return new ConstantUtf8(file);
  default:                          
    throw new ClassFormatException("Invalid byte tag in constant pool: " + b);
  }
}
 

/**
 * Resolve constant to a string representation.
 *
 * @param  constant Constant to be printed
 * @return String representation
 */
public String constantToString(Constant c)
     throws ClassFormatException  
{
  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;
}
 

/** 
 * @param bytes Data
 */
public ConstantDouble(double bytes) {    
  super(Constants.CONSTANT_Double);
  this.bytes = bytes;
}
 

public void visitConstantDouble(ConstantDouble obj){
	if (obj.getTag() != Constants.CONSTANT_Double){
		throw new ClassConstraintException("Wrong constant tag in '"+tostring(obj)+"'.");
	}
	//no indices to check
}