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

The following examples show how to use org.apache.bcel.Constants#CONSTANT_Class . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source Project: ApkToolPlus   File: Constant.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * 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);
  }
}
 
Example 2
Source Project: commons-bcel   File: listclass.java    License: Apache License 2.0 6 votes vote down vote up
public static String[] getClassDependencies(final ConstantPool pool) {
    final String[] tempArray = new String[pool.getLength()];
    int size = 0;
    final StringBuilder buf = new StringBuilder();

    for (int idx = 0; idx < pool.getLength(); idx++) {
        final Constant c = pool.getConstant(idx);
        if (c != null && c.getTag() == Constants.CONSTANT_Class) {
            final ConstantUtf8 c1 = (ConstantUtf8) pool.getConstant(((ConstantClass) c).getNameIndex());
            buf.setLength(0);
            buf.append(c1.getBytes());
            for (int n = 0; n < buf.length(); n++) {
                if (buf.charAt(n) == '/') {
                    buf.setCharAt(n, '.');
                }
            }

            tempArray[size++] = buf.toString();
        }
    }

    final String[] dependencies = new String[size];
    System.arraycopy(tempArray, 0, dependencies, 0, size);
    return dependencies;
}
 
Example 3
Source Project: ApkToolPlus   File: ConstantPool.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * 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
 * @throws  ClassFormatException
 */
public String getConstantString(int index, byte tag) 
     throws ClassFormatException
{
  Constant c;
  int    i;

  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();
}
 
Example 4
Source Project: ApkToolPlus   File: Pass2Verifier.java    License: Apache License 2.0 5 votes vote down vote up
public void visitConstantClass(ConstantClass obj){
	if (obj.getTag() != Constants.CONSTANT_Class){
		throw new ClassConstraintException("Wrong constant tag in '"+tostring(obj)+"'.");
	}
	checkIndex(obj, obj.getNameIndex(), CONST_Utf8);

}
 
Example 5
Source Project: commons-bcel   File: Package.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Add this class to allClasses. Then go through all its dependents
 * and add them to the dependents list if they are not in allClasses
 */
void addDependents(final JavaClass clazz) throws IOException {
    final String name = clazz.getClassName().replace('.', '/');
    allClasses.put(name, clazz);
    final ConstantPool pool = clazz.getConstantPool();
    for (int i = 1; i < pool.getLength(); i++) {
        final Constant cons = pool.getConstant(i);
        //System.out.println("("+i+") " + cons );
        if (cons != null && cons.getTag() == Constants.CONSTANT_Class) {
            final int idx = ((ConstantClass) pool.getConstant(i)).getNameIndex();
            final String clas = ((ConstantUtf8) pool.getConstant(idx)).getBytes();
            addClassString(clas, name);
        }
    }
}
 
Example 6
Source Project: ApkToolPlus   File: ConstantPool.java    License: Apache License 2.0 4 votes vote down vote up
/**
 * 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;
}
 
Example 7
Source Project: ApkToolPlus   File: ConstantClass.java    License: Apache License 2.0 4 votes vote down vote up
/**
 * @param name_index Name index in constant pool.  Should refer to a
 * ConstantUtf8.
 */
public ConstantClass(int name_index) {
  super(Constants.CONSTANT_Class);
  this.name_index = name_index;
}