@SuppressFBWarnings("ES_COMPARING_STRINGS_WITH_EQ") public MethodDescriptor getMethodDescriptorOperand() { if (nameConstantOperand == NOT_AVAILABLE || classConstantOperand == NOT_AVAILABLE) { throw new IllegalStateException("getMethodDescriptorOperand called but value not available"); } if (referencedMethod == null) { referencedMethod = DescriptorFactory.instance().getMethodDescriptor(classConstantOperand, nameConstantOperand, sigConstantOperand, opcode == Const.INVOKESTATIC); } return referencedMethod; }
@SuppressFBWarnings("ES_COMPARING_STRINGS_WITH_EQ") public FieldDescriptor getFieldDescriptorOperand() { if (nameConstantOperand == NOT_AVAILABLE) { throw new IllegalStateException("getFieldDescriptorOperand called but value not available"); } if (referencedField == null) { referencedField = DescriptorFactory.instance().getFieldDescriptor(classConstantOperand, nameConstantOperand, sigConstantOperand, opcode == Const.GETSTATIC || opcode == Const.PUTSTATIC); } return referencedField; }
/** * Get the class descriptor. */ public final ClassDescriptor getClassDescriptor() { return DescriptorFactory.instance().getClassDescriptorForDottedClassName(className); }
public MethodDescriptor toMethodDescriptor() { return DescriptorFactory.instance().getMethodDescriptor(this); }
public static void profile() { XFactory xFactory = AnalysisContext.currentXFactory(); int count = 0; for (XMethod m : xFactory.methods.values()) { if (m instanceof MethodInfo) { count++; } } System.out.printf("XFactory cached methods: %d/%d%n", count, xFactory.methods.size()); DescriptorFactory.instance().profile(); }
public static ClassDescriptor createClassDescriptor(Class<?> aClass) { return instance().getClassDescriptor(ClassName.toSlashedClassName(aClass.getName())); }
public static @Nonnull ClassDescriptor createClassDescriptor(@SlashedClassName String className) { return instance().getClassDescriptor(className); }
/** * Get a ClassDescriptor for the class described by given ObjectType object. * * @param type * an ObjectType * @return a ClassDescriptor for the class described by the ObjectType */ public static ClassDescriptor getClassDescriptor(ObjectType type) { return instance().getClassDescriptorForDottedClassName(type.getClassName()); }
@Override public JavaClass loadClass(String className) throws ClassNotFoundException { if (className.length() == 0) { throw new IllegalArgumentException("Request to load empty class"); } className = ClassName.toSlashedClassName(className); ClassDescriptor classDescriptor = DescriptorFactory.instance().getClassDescriptor(className); try { return Global.getAnalysisCache().getClassAnalysis(JavaClass.class, classDescriptor); } catch (CheckedAnalysisException e) { throw new ClassNotFoundException("Exception while looking for class " + className, e); } }
public static @Nonnull XField getExactXField(@SlashedClassName String className, Field f) { FieldDescriptor fd = DescriptorFactory.instance().getFieldDescriptor(className, f); return getExactXField(fd); }
/** * Construct a ClassDescriptor from a JavaClass. * * @param jclass * a JavaClass * @return a ClassDescriptor identifying that JavaClass */ public static ClassDescriptor getClassDescriptor(JavaClass jclass) { return DescriptorFactory.instance().getClassDescriptor(ClassName.toSlashedClassName(jclass.getClassName())); }
@Override public void visit(ConstantClass obj) { @SlashedClassName String className = obj.getBytes(javaClass.getConstantPool()); if (className.indexOf('[') >= 0) { ClassParser.extractReferencedClassesFromSignature(referencedClassSet, className); } else if (ClassName.isValidClassName(className)) { referencedClassSet.add(DescriptorFactory.instance().getClassDescriptor(className)); } }
private void addCheckedCall(@DottedClassName String className, String methodName, String sig, int argumentParameterIndex, int typeParameterIndex) { ClassDescriptor c = DescriptorFactory.instance().getClassDescriptorForDottedClassName(className); String call = methodName+sig; Info info = new Info(c, argumentParameterIndex, typeParameterIndex); callMap.add(call, info); }
/** * Create an XField object * * @param className * @param fieldName * @param fieldSignature * @param isStatic * @return the created XField */ public static XField createXField(@DottedClassName String className, String fieldName, String fieldSignature, boolean isStatic) { FieldDescriptor fieldDesc = DescriptorFactory.instance().getFieldDescriptor(ClassName.toSlashedClassName(className), fieldName, fieldSignature, isStatic); return createXField(fieldDesc); }
public MethodDescriptor getInvokedMethod(ConstantPoolGen cpg, InvokeInstruction inv) { String invoked = inv.getClassName(cpg); String methodName = inv.getMethodName(cpg); String methodSig = inv.getSignature(cpg); MethodDescriptor invokedMethod = DescriptorFactory.instance().getMethodDescriptor(ClassName.toSlashedClassName(invoked), methodName, methodSig, inv instanceof INVOKESTATIC); return invokedMethod; }
/** * Get the MethodDescriptor that (hopefully) uniqely names this method. * * @return the MethodDescriptor uniquely naming this method */ public MethodDescriptor toMethodDescriptor() { return DescriptorFactory.instance().getMethodDescriptor(getSlashedClassName(), method.getName(), method.getSignature(), method.isStatic()); }
@Override public JavaClass findClass(String className) { @SlashedClassName String slashedClassName = ClassName.toSlashedClassName(className); ClassDescriptor classDescriptor = DescriptorFactory.instance().getClassDescriptor(slashedClassName); return Global.getAnalysisCache().probeClassAnalysis(JavaClass.class, classDescriptor); }
/** * @param className * @param methodName * @param methodSig * @param isStatic * @return the created XMethod */ public static XMethod createXMethod(@DottedClassName String className, String methodName, String methodSig, boolean isStatic) { assertDottedClassName(className); MethodDescriptor desc = DescriptorFactory.instance().getMethodDescriptor(ClassName.toSlashedClassName(className), methodName, methodSig, isStatic); return createXMethod(desc); }
@Override public MethodDescriptor getMethodDescriptor() { return DescriptorFactory.instance().getMethodDescriptor(ClassName.toSlashedClassName(getClassName()), getName(), getSignature(), isStatic()); }
@Override public FieldDescriptor getFieldDescriptor() { return DescriptorFactory.instance().getFieldDescriptor(getClassDescriptor().getClassName(), getName(), getSignature(), isStatic()); } }