Java ConstantPool.getConstant方法代码示例

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
public void visitConstantMethodref(ConstantMethodref ref)
{
    ConstantPool    pool = javaClass.getConstantPool();
    String          cstr = ref.getClass(pool);

    if (cstr.equals("java.lang.Class"))
    {
        int     iname = ref.getNameAndTypeIndex();
        String  name = ((ConstantNameAndType)pool.getConstant(iname)).getName(pool);

        if (name.equals("forName")) {
            System.out.println("found Class.forName('" + javaClass.getClassName() + "')");
            ConstantNameAndType cnat = (ConstantNameAndType)pool.getConstant(iname);
            String cfnStr = cnat.getName(pool);
            if (lastConst != null) {
                refClasses.add(lastConst.replace('.', '/'));
                lastConst = null;
            }
        }
    }
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
private void processConstant(ConstantPool pool, Constant c, int i) {
	if (c == null) // don't know why, but constant[0] seems to be always
					// null.
		return;

	log("      const[" + i + "]=" + pool.constantToString(c) + " inst=" + c.getClass().getName(),
			Project.MSG_DEBUG);
	byte tag = c.getTag();
	switch (tag) {
	// reverse engineered from ConstantPool.constantToString..
	case Constants.CONSTANT_Class:
		int ind = ((ConstantClass) c).getNameIndex();
		c = pool.getConstant(ind, Constants.CONSTANT_Utf8);
		String className = Utility.compactClassName(((ConstantUtf8) c).getBytes(), false);
		log("      classNamePre=" + className, Project.MSG_DEBUG);
		className = getRidOfArray(className);
		String firstLetter = className.charAt(0) + "";
		if (primitives.contains(firstLetter))
			return;
		log("      className=" + className, Project.MSG_VERBOSE);
		design.checkClass(className);
		break;
	default:

	}
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
public static @CheckForNull
CodeException getSurroundingTryBlock(ConstantPool constantPool, Code code, @CheckForNull String vmNameOfExceptionClass, int pc) {
    int size = Integer.MAX_VALUE;
    if (code.getExceptionTable() == null)
        return null;
    CodeException result = null;
    for (CodeException catchBlock : code.getExceptionTable()) {
        if (vmNameOfExceptionClass != null) {
            Constant catchType = constantPool.getConstant(catchBlock.getCatchType());
            if (catchType == null || catchType instanceof ConstantClass
                    && !((ConstantClass) catchType).getBytes(constantPool).equals(vmNameOfExceptionClass))
                continue;
        }
        int startPC = catchBlock.getStartPC();
        int endPC = catchBlock.getEndPC();
        if (pc >= startPC && pc <= endPC) {
            int thisSize = endPC - startPC;
            if (size > thisSize) {
                size = thisSize;
                result = catchBlock;
            }
        }
    }
    return result;
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
/**
 * Called to indicate that a field load or store was encountered.
 *
 * @param cpIndex
 *            the constant pool index of the fieldref
 * @param isStatic
 *            true if it is a static field access
 * @param isLoad
 *            true if the access is a load
 */
private void setField(int cpIndex, boolean isStatic, boolean isLoad) {
    // We only allow one field access for an accessor method.
    accessCount++;
    if (accessCount != 1) {
        access = null;
        return;
    }

    ConstantPool cp = javaClass.getConstantPool();
    ConstantFieldref fieldref = (ConstantFieldref) cp.getConstant(cpIndex);

    ConstantClass cls = (ConstantClass) cp.getConstant(fieldref.getClassIndex());
    String className = cls.getBytes(cp).replace('/', '.');

    ConstantNameAndType nameAndType = (ConstantNameAndType) cp.getConstant(fieldref.getNameAndTypeIndex());
    String fieldName = nameAndType.getName(cp);
    String fieldSig = nameAndType.getSignature(cp);


        XField xfield = Hierarchy.findXField(className, fieldName, fieldSig, isStatic);
        if (xfield != null && xfield.isStatic() == isStatic && isValidAccessMethod(methodSig, xfield, isLoad)) {
            access = new InnerClassAccess(methodName, methodSig, xfield, isLoad);
        }
   
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
/**
 * Called to indicate that a field load or store was encountered.
 *
 * @param cpIndex
 *            the constant pool index of the fieldref
 * @param isStatic
 *            true if it is a static field access
 * @param isLoad
 *            true if the access is a load
 */
private void setField(int cpIndex, boolean isStatic, boolean isLoad) {
    // We only allow one field access for an accessor method.
    accessCount++;
    if (accessCount != 1) {
        access = null;
        return;
    }

    ConstantPool cp = javaClass.getConstantPool();
    ConstantFieldref fieldref = (ConstantFieldref) cp.getConstant(cpIndex);

    ConstantClass cls = (ConstantClass) cp.getConstant(fieldref.getClassIndex());
    String className = cls.getBytes(cp).replace('/', '.');

    ConstantNameAndType nameAndType = (ConstantNameAndType) cp.getConstant(fieldref.getNameAndTypeIndex());
    String fieldName = nameAndType.getName(cp);
    String fieldSig = nameAndType.getSignature(cp);


        XField xfield = Hierarchy.findXField(className, fieldName, fieldSig, isStatic);
        if (xfield != null && xfield.isStatic() == isStatic && isValidAccessMethod(methodSig, xfield, isLoad)) {
            access = new InnerClassAccess(methodName, methodSig, xfield, isLoad);
        }

}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
/** 
 * Override this method to create you own classes on the fly. The
 * name contains the special token $$BCEL$$. Everything before that
 * token is consddered to be a package name. You can encode you own
 * arguments into the subsequent string. You must regard however not
 * to use any "illegal" characters, i.e., characters that may not
 * appear in a Java class name too<br>
 *
 * The default implementation interprets the string as a encoded compressed
 * Java class, unpacks and decodes it with the Utility.decode() method, and
 * parses the resulting byte array and returns the resulting JavaClass object.
 *
 * @param class_name compressed byte code with "$$BCEL$$" in it
 */
protected JavaClass createClass( String class_name ) {
    int index = class_name.indexOf("$$BCEL$$");
    String real_name = class_name.substring(index + 8);
    JavaClass clazz = null;
    try {
        byte[] bytes = Utility.decode(real_name, true);
        ClassParser parser = new ClassParser(new ByteArrayInputStream(bytes), "foo");
        clazz = parser.parse();
    } catch (Throwable e) {
        e.printStackTrace();
        return null;
    }
    // Adapt the class name to the passed value
    ConstantPool cp = clazz.getConstantPool();
    ConstantClass cl = (ConstantClass) cp.getConstant(clazz.getClassNameIndex(),
            Constants.CONSTANT_Class);
    ConstantUtf8 name = (ConstantUtf8) cp.getConstant(cl.getNameIndex(),
            Constants.CONSTANT_Utf8);
    name.setBytes(class_name.replace('.', '/'));
    return clazz;
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
public void flagTests(HashSet<String> tests) {
    if (true == _clazz.isAbstract()) {
        return;
    }

    ConstantPool pool = _clazz.getConstantPool();
    for (int i = 0; i < pool.getLength(); ++i) {
        Constant constant = pool.getConstant(i);
        if (null == constant) {
            continue;
        }
        Byte tag = constant.getTag();
        if (Constants.CONSTANT_Utf8 != tag) {
            continue;
        }
        String constantAsString = pool.constantToString(constant);
        if (constantAsString.contains("Lorg/junit/Test")) {
            tests.add(_clazz.getClassName());
        }
    }
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
/**
 * Read class definition from an input stream.
 * 
 * @param filename
 *          the name of the class file (used to determine the class name)
 * @param is
 *          the input stream to read the class file from
 * @throws IOException
 *           if I/O exception occurs while reading from the input stream
 */
public JavaClass(String filename, InputStream is) throws IOException {
  ClassParser parser = new ClassParser(is, filename);
  org.apache.bcel.classfile.JavaClass clazz = parser.parse();
  ConstantPool cp = clazz.getConstantPool();
  name = clazz.getClassName();

  for (Constant c : cp.getConstantPool()) {
    if (c instanceof ConstantClass) {
      ConstantClass cc = (ConstantClass) c;
      ConstantUtf8 cs = (ConstantUtf8) cp.getConstant(cc.getNameIndex());
      String cn = new String(cs.getBytes());
      if (cn.contains("["))
        continue;
      cn = cn.replaceAll("^\\[L", "");
      cn = cn.replaceAll(";", "");
      cn = cn.replaceAll("/", ".");
      getDependencies().add(cn);
    }
  }
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
/**
 * @return mnemonic for instruction with symbolic references resolved
 */
public String toString( ConstantPool cp ) {
    Constant c = cp.getConstant(index);
    StringTokenizer tok = new StringTokenizer(cp.constantToString(c));
    return Constants.OPCODE_NAMES[opcode] + " " + tok.nextToken().replace('.', '/')
            + tok.nextToken();
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
/** @return signature of referenced method/field.
 */
public String getSignature( ConstantPoolGen cpg ) {
    ConstantPool cp = cpg.getConstantPool();
    ConstantCP cmr = (ConstantCP) cp.getConstant(index);
    ConstantNameAndType cnat = (ConstantNameAndType) cp.getConstant(cmr.getNameAndTypeIndex());
    return ((ConstantUtf8) cp.getConstant(cnat.getSignatureIndex())).getBytes();
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
/** @return name of referenced method/field.
 */
public String getName( ConstantPoolGen cpg ) {
    ConstantPool cp = cpg.getConstantPool();
    ConstantCP cmr = (ConstantCP) cp.getConstant(index);
    ConstantNameAndType cnat = (ConstantNameAndType) cp.getConstant(cmr.getNameAndTypeIndex());
    return ((ConstantUtf8) cp.getConstant(cnat.getNameIndex())).getBytes();
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
/** @return name of the referenced class/interface
 *  @deprecated If the instruction references an array class,
 *    this method will return "java.lang.Object".
 *    For code generated by Java 1.5, this answer is
 *    sometimes wrong (e.g., if the "clone()" method is
 *    called on an array).  A better idea is to use
 *    the getReferenceType() method, which correctly distinguishes
 *    between class types and array types.
 */
public String getClassName( ConstantPoolGen cpg ) {
    ConstantPool cp = cpg.getConstantPool();
    ConstantCP cmr = (ConstantCP) cp.getConstant(index);
    String className = cp.getConstantString(cmr.getClassIndex(),
            org.apache.bcel.Constants.CONSTANT_Class);
    if (className.startsWith("[")) {
        // Turn array classes into java.lang.Object.
        return "java.lang.Object";
    }
    return className.replace('/', '.');
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
/**
 * Return the reference type representing the class, interface,
 * or array class referenced by the instruction.
 * @param cpg the ConstantPoolGen used to create the instruction
 * @return an ObjectType (if the referenced class type is a class
 *   or interface), or an ArrayType (if the referenced class
 *   type is an array class)
 */
public ReferenceType getReferenceType( ConstantPoolGen cpg ) {
    ConstantPool cp = cpg.getConstantPool();
    ConstantCP cmr = (ConstantCP) cp.getConstant(index);
    String className = cp.getConstantString(cmr.getClassIndex(),
            org.apache.bcel.Constants.CONSTANT_Class);
    if (className.startsWith("[")) {
        return (ArrayType) Type.getType(className);
    } else {
        className = className.replace('/', '.');
        return new ObjectType(className);
    }
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
/**
 * @return mnemonic for instruction with symbolic references resolved
 */
public String toString( ConstantPool cp ) {
    Constant c = cp.getConstant(index);
    String str = cp.constantToString(c);
    if (c instanceof ConstantClass) {
        str = str.replace('.', '/');
    }
    return org.apache.bcel.Constants.OPCODE_NAMES[opcode] + " " + str;
}
 

import org.apache.bcel.classfile.ConstantPool; //导入方法依赖的package包/类
/**
 * @return mnemonic for instruction with symbolic references resolved
 */
public String toString(ConstantPool cp) {
    Constant c = cp.getConstant(index);
    StringTokenizer tok = new StringTokenizer(cp.constantToString(c));

    return Constants.OPCODE_NAMES[opcode] + " " +
            tok.nextToken().replace('.', '/') + tok.nextToken();
}