Java XFactory类代码示例

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
public static @CheckForNull
XMethod findSuperImplementorAsXMethod(JavaClass clazz, String name, String signature, BugReporter bugReporter) {
    try {
        JavaClass c = clazz;
        while (true) {
            c = c.getSuperClass();
            if (c == null)
                return null;
            Method m = findImplementation(c, name, signature);
            if (m != null && !m.isAbstract())
                return XFactory.createXMethod(c, m);

        }
    } catch (ClassNotFoundException e) {
        bugReporter.reportMissingClass(e);
        return null;
    }
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
@Override
public void visitParameterAnnotation(int p, String annotationClass, Map<String, ElementValue> map, boolean runtimeVisible) {
    if (database == null) {
        return;
    }

    NullnessAnnotation n = NullnessAnnotation.Parser.parse(annotationClass);
    annotationClass = lastPortion(annotationClass);
    if (n == null)
        return;

    XMethod xmethod = XFactory.createXMethod(this);
    if (DEBUG) {
        System.out.println("Parameter " + p + " @" + annotationClass.substring(annotationClass.lastIndexOf('/') + 1) + " in "
                + xmethod.toString());
    }
    XMethodParameter xparameter = new XMethodParameter(xmethod, p);

    database.addDirectAnnotation(xparameter, n);

}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
@Override
public void visit(ConstantValue s) {
    if (!visitingField())
        return;
    int i = s.getConstantValueIndex();
    Constant c = getConstantPool().getConstant(i);
    if (c instanceof ConstantString) {
        String value = ((ConstantString) c).getBytes(getConstantPool());
        if (value.length() < SIZE_OF_HUGE_CONSTANT)
            return;
        String key = getStringKey(value);
        definition.put(key, XFactory.createXField(this));
        stringSize.put(key, value.length());
    }

}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
@Override
public void visitAnnotation(String annotationClass, Map<String, ElementValue> map, boolean runtimeVisible) {

    if (!annotationClass.startsWith(NET_JCIP_ANNOTATIONS))
        return;
    annotationClass = annotationClass.substring(NET_JCIP_ANNOTATIONS.length());
    ElementValue value = map.get("value");
    ClassMember member;
    if (visitingField())
        member = XFactory.createXField(this);
    else if (visitingMethod())
        member = XFactory.createXMethod(this);
    else {
        Map<String, ElementValue> annotationsOfThisClass = AnalysisContext.currentAnalysisContext()
                .getJCIPAnnotationDatabase().getEntryForClass(getDottedClassName());
        annotationsOfThisClass.put(annotationClass, value);
        return;
    }
    Map<String, ElementValue> annotationsOfThisMember = AnalysisContext.currentAnalysisContext().getJCIPAnnotationDatabase()
            .getEntryForClassMember(member);
    annotationsOfThisMember.put(annotationClass, value);
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
@Override
protected FieldDescriptor parseKey(String s) throws PropertyDatabaseFormatException {
    String[] tuple = s.split(",");
    if (tuple.length != 4) {
        throw new PropertyDatabaseFormatException("Invalid field tuple: " + s);
    }

    String className = XFactory.canonicalizeString(tuple[0]);
    String fieldName = XFactory.canonicalizeString(tuple[1]);
    String signature = XFactory.canonicalizeString(tuple[2]);
    int accessFlags;
    try {
        accessFlags = Integer.parseInt(tuple[3]);
    } catch (NumberFormatException e) {
        throw new PropertyDatabaseFormatException("Invalid field access flags: " + tuple[3]);
    }

    return DescriptorFactory.instance().getFieldDescriptor(ClassName.toSlashedClassName(className), fieldName, signature,
            (accessFlags & Constants.ACC_STATIC) != 0);
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
private void modelFieldStore(Location location) throws DataflowAnalysisException {
    // Model field stores
    XField writtenField = XFactory.createXField((FieldInstruction) location.getHandle().getInstruction(), cpg);
    TypeQualifierAnnotation tqa = TypeQualifierApplications.getEffectiveTypeQualifierAnnotation(writtenField,
            typeQualifierValue);
    When when = (tqa != null) ? tqa.when : When.UNKNOWN;

    // The ValueNumberFrame *before* the FieldInstruction should
    // have the ValueNumber of the stored value on the top of the stack.
    ValueNumberFrame vnaFrameAtStore = vnaDataflow.getFactAtLocation(location);
    if (vnaFrameAtStore.isValid()) {
        ValueNumber vn = vnaFrameAtStore.getTopValue();
        SourceSinkInfo sink = new SourceSinkInfo(SourceSinkType.FIELD_STORE, location, vn, when);
        registerSourceSink(sink);
    }
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
/**
 * @param jclass
 * @param method
 * @param stack
 * @param branchAnalysis
 * @return
 */
public static JumpInfo computeJumpInfo(JavaClass jclass, Method method, final OpcodeStack stack,
        DismantleBytecode branchAnalysis) {
    branchAnalysis.setupVisitorForClass(jclass);
    MethodInfo xMethod = (MethodInfo) XFactory.createXMethod(jclass, method);
    int oldCount = 0;
    while (true) {
        stack.resetForMethodEntry0(ClassName.toSlashedClassName(jclass.getClassName()), method);
        branchAnalysis.doVisitMethod(method);
        int newCount = stack.jumpEntries.size();
        if (xMethod.hasBackBranch() != stack.backwardsBranch && !stack.encountedTop) {
            AnalysisContext.logError(
                    String.format("For %s, mismatch on existence of backedge: %s for precomputation, %s for bytecode analysis",
                            xMethod, xMethod.hasBackBranch(), stack.backwardsBranch));
        }
        if (newCount == oldCount || !stack.encountedTop || !stack.backwardsBranch)
            break;
        oldCount = newCount;
    }

    return new JumpInfo(stack.jumpEntries, stack.jumpStackEntries, stack.jumpEntryLocations);
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
private void pushByInvoke(DismantleBytecode dbc, boolean popThis) {
    String signature = dbc.getSigConstantOperand();
    if (dbc.getNameConstantOperand().equals("<init>") && signature.endsWith(")V") && popThis) {
        pop(PreorderVisitor.getNumberArguments(signature));
        Item constructed = pop();
        if (getStackDepth() > 0) {
            Item next = getStackItem(0);
            if (constructed.equals(next)) {
                next.source = XFactory.createReferencedXMethod(dbc);
                next.pc = dbc.getPC();
            }
        }
        return;
    }
    pop(PreorderVisitor.getNumberArguments(signature) + (popThis ? 1 : 0));
    pushBySignature(Type.getReturnType(signature).getSignature(), dbc);
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
@Override
protected MethodDescriptor parseKey(String methodStr) throws PropertyDatabaseFormatException {
    String[] tuple = methodStr.split(",");
    if (tuple.length != 4)
        throw new PropertyDatabaseFormatException("Invalid method tuple: " + methodStr);

    try {
        int accessFlags = Integer.parseInt(tuple[3]);
        // return
        // XFactory.createMethodDescriptor(XFactory.canonicalizeString(tuple[0]),
        // XFactory.canonicalizeString( tuple[1]),
        // XFactory.canonicalizeString(tuple[2]), accessFlags);
        String className = XFactory.canonicalizeString(tuple[0]);
        String methodName = XFactory.canonicalizeString(tuple[1]);
        String methodSig = XFactory.canonicalizeString(tuple[2]);
        return DescriptorFactory.instance().getMethodDescriptor(ClassName.toSlashedClassName(className), methodName,
                methodSig, (accessFlags & Constants.ACC_STATIC) != 0);

    } catch (NumberFormatException e) {
        return null;
    }
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
/**
 * If this is a putfield or putstatic instruction, check to see if the field
 * is @NonNull, and treat it as dereferences.
 *
 * @param location
 *            the Location of the instruction
 * @param vnaFrame
 *            the ValueNumberFrame at the Location of the instruction
 * @param fact
 *            the dataflow value to modify
 * @throws DataflowAnalysisException
 */
private void checkNonNullPutField(Location location, ValueNumberFrame vnaFrame, UnconditionalValueDerefSet fact)
        throws DataflowAnalysisException {
    INullnessAnnotationDatabase database = AnalysisContext.currentAnalysisContext().getNullnessAnnotationDatabase();
    if (database == null) {
        return;
    }

    FieldInstruction fieldIns = (FieldInstruction) location.getHandle().getInstruction();

    XField field = XFactory.createXField(fieldIns, methodGen.getConstantPool());
    char firstChar = field.getSignature().charAt(0);
    if (firstChar != 'L' && firstChar != '[')
        return;
    NullnessAnnotation resolvedAnnotation = database.getResolvedAnnotation(field, true);
    if (resolvedAnnotation == NullnessAnnotation.NONNULL) {
        IsNullValueFrame invFrame = invDataflow.getFactAtLocation(location);
        if (!invFrame.isValid())
            return;
        IsNullValue value = invFrame.getTopValue();
        if (reportDereference(value)) {
            ValueNumber vn = vnaFrame.getTopValue();
            fact.addDeref(vn, location);
        }
    }
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
@Override
public void visit(Method obj) {
    if (obj.isAbstract() || BCELUtil.isSynthetic(obj))
        return;
    if (!obj.isPublic())
        return;
    if (!getMethodName().equals("clone"))
        return;
    if (!getMethodSig().startsWith("()"))
        return;
    hasCloneMethod = true;
    cloneIsDeprecated = getXMethod().isDeprecated();
    cloneMethodAnnotation = MethodAnnotation.fromVisitedMethod(this);
    cloneOnlyThrowsException = PruneUnconditionalExceptionThrowerEdges.doesMethodUnconditionallyThrowException(XFactory
            .createXMethod(this));
    // ExceptionTable tbl = obj.getExceptionTable();
    // throwsExceptions = tbl != null && tbl.getNumberOfExceptions() > 0;
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
@Override
public void visitAnnotation(String annotationClass, Map<String, ElementValue> map, boolean runtimeVisible) {
    if (annotationClass.startsWith(NET_JCIP_ANNOTATIONS)) {
        annotationClass = annotationClass.substring(NET_JCIP_ANNOTATIONS.length());
    } else if (annotationClass.startsWith(JSR305_CONCURRENT_ANNOTATIONS)) {
        annotationClass = annotationClass.substring(JSR305_CONCURRENT_ANNOTATIONS.length());
    } else {
        return;
    }
    JCIPAnnotationDatabase annotationDatabase = AnalysisContext.currentAnalysisContext()
        .getJCIPAnnotationDatabase();
    ElementValue value = map.get("value");
    ClassMember member;
    if (visitingField()) {
        member = XFactory.createXField(this);
    } else if (visitingMethod()) {
        member = XFactory.createXMethod(this);
    } else {
        annotationDatabase.addEntryForClass(getDottedClassName(), annotationClass, value);
        return;
    }
    annotationDatabase.addEntryForClassMember(member, annotationClass, value);
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
private JumpInfoFromStackMap getJumpInfoFromStackMap() {
    IAnalysisCache analysisCache = Global.getAnalysisCache();
    XMethod xMethod = XFactory.createXMethod(v.getThisClass(), v.getMethod());
    if (xMethod instanceof MethodInfo) {
        MethodInfo mi = (MethodInfo) xMethod;
        if (!mi.hasBackBranch())
            return null;
    }
    
    try {
        return analysisCache.getMethodAnalysis(JumpInfoFromStackMap.class, xMethod.getMethodDescriptor());
        
    } catch (CheckedAnalysisException e) {
        AnalysisContext.logError("Error getting jump information from StackMap", e);
        return null;
    }
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
/**
 * @param propertySet
 * @param xMethod
 */
private void addPropertiesForMethodContainingWarning(WarningPropertySet<WarningProperty> propertySet) {
    XMethod xMethod = XFactory.createXMethod(classContext.getJavaClass(), method);

    boolean uncallable = !AnalysisContext.currentXFactory().isCalledDirectlyOrIndirectly(xMethod) && xMethod.isPrivate();

    if (uncallable)
        propertySet.addProperty(GeneralWarningProperty.IN_UNCALLABLE_METHOD);
}
 

import edu.umd.cs.findbugs.ba.XFactory; //导入依赖的package包/类
private void registerFieldLoadSource(Location location) throws DataflowAnalysisException {
    XField loadedField = XFactory.createXField((FieldInstruction) location.getHandle().getInstruction(), cpg);
    if (loadedField.isResolved()) {
        TypeQualifierAnnotation tqa = TypeQualifierApplications.getEffectiveTypeQualifierAnnotation(loadedField,
                typeQualifierValue);
        When when = (tqa != null) ? tqa.when : When.UNKNOWN;
        registerTopOfStackSource(SourceSinkType.FIELD_LOAD, location, when, false, null);
    }

}