code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
private void scan(CallGraphNode node) throws CFGBuilderException {
Method method = node.getMethod();
CFG cfg = classContext.getCFG(method);
if (method.isSynchronized()) {
hasSynchronization = true;
}
Iterator<BasicBlock> i = cfg.blockIterator();
while (i.hasNext()) {
BasicBlock block = i.next();
Iterator<InstructionHandle> j = block.instructionIterator();
while (j.hasNext()) {
InstructionHandle handle = j.next();
Instruction ins = handle.getInstruction();
if (ins instanceof InvokeInstruction) {
InvokeInstruction inv = (InvokeInstruction) ins;
Method called = isSelfCall(inv);
if (called != null) {
// Add edge to call graph
CallSite callSite = new CallSite(method, block, handle);
callGraph.createEdge(node, callGraph.getNodeForMethod(called), callSite);
// Add to called method set
calledMethodSet.add(called);
}
} else if (ins instanceof MONITORENTER || ins instanceof MONITOREXIT) {
hasSynchronization = true;
}
}
}
} | java |
private Method isSelfCall(InvokeInstruction inv) {
ConstantPoolGen cpg = classContext.getConstantPoolGen();
JavaClass jclass = classContext.getJavaClass();
String calledClassName = inv.getClassName(cpg);
// FIXME: is it possible we would see a superclass name here?
// Not a big deal for now, as we are mostly just interested in calls
// to private methods, for which we will definitely see the right
// called class name.
if (!calledClassName.equals(jclass.getClassName())) {
return null;
}
String calledMethodName = inv.getMethodName(cpg);
String calledMethodSignature = inv.getSignature(cpg);
boolean isStaticCall = (inv instanceof INVOKESTATIC);
// Scan methods for one that matches.
Method[] methods = jclass.getMethods();
for (Method method : methods) {
String methodName = method.getName();
String signature = method.getSignature();
boolean isStatic = method.isStatic();
if (methodName.equals(calledMethodName) && signature.equals(calledMethodSignature) && isStatic == isStaticCall) {
// This method looks like a match.
return wantCallsFor(method) ? method : null;
}
}
// Hmm...no matching method found.
// This is almost certainly because the named method
// was inherited from a superclass.
LOG.debug("No method found for {}.{} : {}", calledClassName, calledMethodName, calledMethodSignature);
return null;
} | java |
public boolean isEnabledForCurrentJRE() {
if ("".equals(requireJRE)) {
return true;
}
try {
JavaVersion requiredVersion = new JavaVersion(requireJRE);
JavaVersion runtimeVersion = JavaVersion.getRuntimeVersion();
if (DEBUG_JAVA_VERSION) {
System.out.println("Checking JRE version for " + getShortName() + " (requires " + requiredVersion
+ ", running on " + runtimeVersion + ")");
}
boolean enabledForCurrentJRE = runtimeVersion.isSameOrNewerThan(requiredVersion);
if (DEBUG_JAVA_VERSION) {
System.out.println("\t==> " + enabledForCurrentJRE);
}
return enabledForCurrentJRE;
} catch (JavaVersionException e) {
if (DEBUG_JAVA_VERSION) {
System.out.println("Couldn't check Java version: " + e.toString());
e.printStackTrace(System.out);
}
return false;
}
} | java |
public Set<BugPattern> getReportedBugPatterns() {
Set<BugPattern> result = new TreeSet<>();
StringTokenizer tok = new StringTokenizer(reports, ",");
while (tok.hasMoreTokens()) {
String type = tok.nextToken();
BugPattern bugPattern = DetectorFactoryCollection.instance().lookupBugPattern(type);
if (bugPattern != null) {
result.add(bugPattern);
}
}
return result;
} | java |
public String getShortName() {
int endOfPkg = className.lastIndexOf('.');
if (endOfPkg >= 0) {
return className.substring(endOfPkg + 1);
}
return className;
} | java |
public LoadStoreCount getLoadStoreCount(XField field) {
LoadStoreCount loadStoreCount = loadStoreCountMap.get(field);
if (loadStoreCount == null) {
loadStoreCount = new LoadStoreCount();
loadStoreCountMap.put(field, loadStoreCount);
}
return loadStoreCount;
} | java |
public void addLoad(InstructionHandle handle, XField field) {
getLoadStoreCount(field).loadCount++;
handleToFieldMap.put(handle, field);
loadHandleSet.set(handle.getPosition());
} | java |
public void addStore(InstructionHandle handle, XField field) {
getLoadStoreCount(field).storeCount++;
handleToFieldMap.put(handle, field);
} | java |
public static SourceLineAnnotation forFirstLineOfMethod(MethodDescriptor methodDescriptor) {
SourceLineAnnotation result = null;
try {
Method m = Global.getAnalysisCache().getMethodAnalysis(Method.class, methodDescriptor);
XClass xclass = Global.getAnalysisCache().getClassAnalysis(XClass.class, methodDescriptor.getClassDescriptor());
LineNumberTable lnt = m.getLineNumberTable();
String sourceFile = xclass.getSource();
if (sourceFile != null && lnt != null) {
int firstLine = Integer.MAX_VALUE;
int bytecode = 0;
LineNumber[] entries = lnt.getLineNumberTable();
for (LineNumber entry : entries) {
if (entry.getLineNumber() < firstLine) {
firstLine = entry.getLineNumber();
bytecode = entry.getStartPC();
}
}
if (firstLine < Integer.MAX_VALUE) {
result = new SourceLineAnnotation(methodDescriptor.getClassDescriptor().toDottedClassName(), sourceFile,
firstLine, firstLine, bytecode, bytecode);
}
}
} catch (CheckedAnalysisException e) {
// ignore
}
if (result == null) {
result = createUnknown(methodDescriptor.getClassDescriptor().toDottedClassName());
}
return result;
} | java |
public static SourceLineAnnotation fromVisitedInstruction(ClassContext classContext, Method method, Location loc) {
return fromVisitedInstruction(classContext, method, loc.getHandle());
} | java |
public static SourceLineAnnotation fromVisitedInstruction(ClassContext classContext, Method method, InstructionHandle handle) {
return fromVisitedInstruction(classContext, method, handle.getPosition());
} | java |
public static SourceLineAnnotation fromVisitedInstruction(MethodDescriptor methodDescriptor, Location location) {
return fromVisitedInstruction(methodDescriptor, location.getHandle().getPosition());
} | java |
public static SourceLineAnnotation fromVisitedInstructionRange(ClassContext classContext, MethodGen methodGen,
String sourceFile, InstructionHandle start, InstructionHandle end) {
LineNumberTable lineNumberTable = methodGen.getLineNumberTable(methodGen.getConstantPool());
String className = methodGen.getClassName();
if (lineNumberTable == null) {
return createUnknown(className, sourceFile, start.getPosition(), end.getPosition());
}
int startLine = lineNumberTable.getSourceLine(start.getPosition());
int endLine = lineNumberTable.getSourceLine(end.getPosition());
return new SourceLineAnnotation(className, sourceFile, startLine, endLine, start.getPosition(), end.getPosition());
} | java |
public boolean isAssertionInstruction(Instruction ins, ConstantPoolGen cpg) {
if (ins instanceof InvokeInstruction) {
return isAssertionCall((InvokeInstruction) ins);
}
if (ins instanceof GETSTATIC) {
GETSTATIC getStatic = (GETSTATIC) ins;
String className = getStatic.getClassName(cpg);
String fieldName = getStatic.getFieldName(cpg);
if ("java.util.logging.Level".equals(className) && "SEVERE".equals(fieldName)) {
return true;
}
return "org.apache.log4j.Level".equals(className)
&& ("ERROR".equals(fieldName) || "FATAL".equals(fieldName));
}
return false;
} | java |
private static short unsignedValueOf(byte value) {
short result;
if ((value & 0x80) != 0) {
result = (short) (value & 0x7F);
result |= 0x80;
} else {
result = value;
}
return result;
} | java |
private static int extractInt(byte[] arr, int offset) {
return ((arr[offset] & 0xFF) << 24) | ((arr[offset + 1] & 0xFF) << 16) | ((arr[offset + 2] & 0xFF) << 8)
| (arr[offset + 3] & 0xFF);
} | java |
public void makeSameAs(UnconditionalValueDerefSet source) {
// Copy value numbers
valueNumbersUnconditionallyDereferenced.clear();
valueNumbersUnconditionallyDereferenced.or(source.valueNumbersUnconditionallyDereferenced);
lastUpdateTimestamp = source.lastUpdateTimestamp;
// Copy dereference locations for each value number
derefLocationSetMap.clear();
if (source.derefLocationSetMap.size() > 0) {
for (Map.Entry<ValueNumber, Set<Location>> sourceEntry : source.derefLocationSetMap.entrySet()) {
Set<Location> derefLocationSet = Util.makeSmallHashSet(sourceEntry.getValue());
derefLocationSetMap.put(sourceEntry.getKey(), derefLocationSet);
}
}
} | java |
public boolean isSameAs(UnconditionalValueDerefSet otherFact) {
return valueNumbersUnconditionallyDereferenced.equals(otherFact.valueNumbersUnconditionallyDereferenced)
&& derefLocationSetMap.equals(otherFact.derefLocationSetMap);
} | java |
public void addDeref(ValueNumber vn, Location location) {
if (UnconditionalValueDerefAnalysis.DEBUG) {
System.out.println("Adding dereference of " + vn + " to # " + System.identityHashCode(this) + " @ " + location);
}
valueNumbersUnconditionallyDereferenced.set(vn.getNumber());
Set<Location> derefLocationSet = getDerefLocationSet(vn);
derefLocationSet.add(location);
} | java |
public void setDerefSet(ValueNumber vn, Set<Location> derefSet) {
if (UnconditionalValueDerefAnalysis.DEBUG) {
System.out.println("Adding dereference of " + vn + " for # " + System.identityHashCode(this) + " to " + derefSet);
}
valueNumbersUnconditionallyDereferenced.set(vn.getNumber());
Set<Location> derefLocationSet = getDerefLocationSet(vn);
derefLocationSet.clear();
derefLocationSet.addAll(derefSet);
} | java |
public void clearDerefSet(ValueNumber value) {
if (UnconditionalValueDerefAnalysis.DEBUG) {
System.out.println("Clearing dereference of " + value + " for # " + System.identityHashCode(this));
}
valueNumbersUnconditionallyDereferenced.clear(value.getNumber());
derefLocationSetMap.remove(value);
} | java |
public Set<Location> getDerefLocationSet(ValueNumber vn) {
Set<Location> derefLocationSet = derefLocationSetMap.get(vn);
if (derefLocationSet == null) {
derefLocationSet = new HashSet<>();
derefLocationSetMap.put(vn, derefLocationSet);
}
return derefLocationSet;
} | java |
private void work(final IProject project, final String fileName) {
FindBugsJob runFindBugs = new FindBugsJob("Loading XML data from " + fileName + "...", project) {
@Override
protected void runWithProgress(IProgressMonitor monitor) throws CoreException {
FindBugsWorker worker = new FindBugsWorker(project, monitor);
worker.loadXml(fileName);
}
};
runFindBugs.setRule(project);
runFindBugs.scheduleInteractive();
} | java |
private void handleWillCloseWhenClosed(XMethod xmethod, Obligation deletedObligation) {
if (deletedObligation == null) {
if (DEBUG_ANNOTATIONS) {
System.out.println("Method " + xmethod.toString() + " is marked @WillCloseWhenClosed, "
+ "but its parameter is not an obligation");
}
return;
}
// See what type of obligation is being created.
Obligation createdObligation = null;
if ("<init>".equals(xmethod.getName())) {
// Constructor - obligation type is the type of object being created
// (or some supertype)
createdObligation = database.getFactory().getObligationByType(xmethod.getClassDescriptor());
} else {
// Factory method - obligation type is the return type
Type returnType = Type.getReturnType(xmethod.getSignature());
if (returnType instanceof ObjectType) {
try {
createdObligation = database.getFactory().getObligationByType((ObjectType) returnType);
} catch (ClassNotFoundException e) {
reporter.reportMissingClass(e);
return;
}
}
}
if (createdObligation == null) {
if (DEBUG_ANNOTATIONS) {
System.out.println("Method " + xmethod.toString() + " is marked @WillCloseWhenClosed, "
+ "but its return type is not an obligation");
}
return;
}
// Add database entries:
// - parameter obligation is deleted
// - return value obligation is added
database.addEntry(new MatchMethodEntry(xmethod, ObligationPolicyDatabaseActionType.DEL,
ObligationPolicyDatabaseEntryType.STRONG, deletedObligation));
database.addEntry(new MatchMethodEntry(xmethod, ObligationPolicyDatabaseActionType.ADD,
ObligationPolicyDatabaseEntryType.STRONG, createdObligation));
} | java |
public IsNullValue toExceptionValue() {
if (getBaseKind() == NO_KABOOM_NN) {
return new IsNullValue(kind | EXCEPTION, locationOfKaBoom);
}
return instanceByFlagsList[(getFlags() | EXCEPTION) >> FLAG_SHIFT][getBaseKind()];
} | java |
public static IsNullValue merge(IsNullValue a, IsNullValue b) {
if (a == b) {
return a;
}
if (a.equals(b)) {
return a;
}
int aKind = a.kind & 0xff;
int bKind = b.kind & 0xff;
int aFlags = a.getFlags();
int bFlags = b.getFlags();
int combinedFlags = aFlags & bFlags;
if (!(a.isNullOnSomePath() || a.isDefinitelyNull()) && b.isException()) {
combinedFlags |= EXCEPTION;
} else if (!(b.isNullOnSomePath() || b.isDefinitelyNull()) && a.isException()) {
combinedFlags |= EXCEPTION;
}
// Left hand value should be >=, since it is used
// as the first dimension of the matrix to index.
if (aKind < bKind) {
int tmp = aKind;
aKind = bKind;
bKind = tmp;
}
assert aKind >= bKind;
int result = mergeMatrix[aKind][bKind];
IsNullValue resultValue = (result == NO_KABOOM_NN) ? noKaboomNonNullValue(a.locationOfKaBoom)
: instanceByFlagsList[combinedFlags >> FLAG_SHIFT][result];
return resultValue;
} | java |
public boolean isNullOnSomePath() {
int baseKind = getBaseKind();
if (NCP_EXTRA_BRANCH) {
// Note: NCP_EXTRA_BRANCH is an experimental feature
// to see how many false warnings we get when we allow
// two branches between an explicit null and a
// a dereference.
return baseKind == NSP || baseKind == NCP2;
} else {
return baseKind == NSP;
}
} | java |
static public boolean isContainer(ReferenceType target) throws ClassNotFoundException {
Subtypes2 subtypes2 = AnalysisContext.currentAnalysisContext().getSubtypes2();
return subtypes2.isSubtype(target, COLLECTION_TYPE)
|| subtypes2.isSubtype(target, MAP_TYPE);
} | java |
public void addApplicationClass(XClass appXClass) {
for (XMethod m : appXClass.getXMethods()) {
if (m.isStub()) {
return;
}
}
ClassVertex vertex = addClassAndGetClassVertex(appXClass);
vertex.markAsApplicationClass();
} | java |
private ClassVertex addClassAndGetClassVertex(XClass xclass) {
if (xclass == null) {
throw new IllegalStateException();
}
LinkedList<XClass> workList = new LinkedList<>();
workList.add(xclass);
while (!workList.isEmpty()) {
XClass work = workList.removeFirst();
ClassVertex vertex = classDescriptorToVertexMap.get(work.getClassDescriptor());
if (vertex != null && vertex.isFinished()) {
// This class has already been processed.
continue;
}
if (vertex == null) {
vertex = ClassVertex.createResolvedClassVertex(work.getClassDescriptor(), work);
addVertexToGraph(work.getClassDescriptor(), vertex);
}
addSupertypeEdges(vertex, workList);
vertex.setFinished(true);
}
return classDescriptorToVertexMap.get(xclass.getClassDescriptor());
} | java |
public boolean isSubtype(ReferenceType type, ReferenceType possibleSupertype) throws ClassNotFoundException {
// Eliminate some easy cases
if (type.equals(possibleSupertype)) {
return true;
}
if (possibleSupertype.equals(Type.OBJECT)) {
return true;
}
if (type.equals(Type.OBJECT)) {
return false;
}
boolean typeIsObjectType = (type instanceof ObjectType);
boolean possibleSupertypeIsObjectType = (possibleSupertype instanceof ObjectType);
if (typeIsObjectType && possibleSupertypeIsObjectType) {
// Both types are ordinary object (non-array) types.
return isSubtype((ObjectType) type, (ObjectType) possibleSupertype);
}
boolean typeIsArrayType = (type instanceof ArrayType);
boolean possibleSupertypeIsArrayType = (possibleSupertype instanceof ArrayType);
if (typeIsArrayType) {
// Check superclass/interfaces
if (possibleSupertype.equals(SERIALIZABLE) || possibleSupertype.equals(CLONEABLE)) {
return true;
}
// We checked all of the possible class/interface supertypes,
// so if possibleSupertype is not an array type,
// then we can definitively say no
if (!possibleSupertypeIsArrayType) {
return false;
}
// Check array/array subtype relationship
ArrayType typeAsArrayType = (ArrayType) type;
ArrayType possibleSupertypeAsArrayType = (ArrayType) possibleSupertype;
// Must have same number of dimensions
if (typeAsArrayType.getDimensions() < possibleSupertypeAsArrayType.getDimensions()) {
return false;
}
Type possibleSupertypeBasicType = possibleSupertypeAsArrayType.getBasicType();
if (!(possibleSupertypeBasicType instanceof ObjectType)) {
return false;
}
Type typeBasicType = typeAsArrayType.getBasicType();
// If dimensions differ, see if element types are compatible.
if (typeAsArrayType.getDimensions() > possibleSupertypeAsArrayType.getDimensions()) {
return isSubtype(
new ArrayType(typeBasicType, typeAsArrayType.getDimensions()
- possibleSupertypeAsArrayType.getDimensions()), (ObjectType) possibleSupertypeBasicType);
}
// type's base type must be a subtype of possibleSupertype's base
// type.
// Note that neither base type can be a non-ObjectType if we are to
// answer yes.
if (!(typeBasicType instanceof ObjectType)) {
return false;
}
return isSubtype((ObjectType) typeBasicType, (ObjectType) possibleSupertypeBasicType);
}
// OK, we've exhausted the possibilities now
return false;
} | java |
public boolean isSubtype(ObjectType type, ObjectType possibleSupertype) throws ClassNotFoundException {
if (DEBUG_QUERIES) {
System.out.println("isSubtype: check " + type + " subtype of " + possibleSupertype);
}
if (type.equals(possibleSupertype)) {
if (DEBUG_QUERIES) {
System.out.println(" ==> yes, types are same");
}
return true;
}
ClassDescriptor typeClassDescriptor = DescriptorFactory.getClassDescriptor(type);
ClassDescriptor possibleSuperclassClassDescriptor = DescriptorFactory.getClassDescriptor(possibleSupertype);
return isSubtype(typeClassDescriptor, possibleSuperclassClassDescriptor);
} | java |
private ReferenceType computeFirstCommonSuperclassOfSameDimensionArrays(ArrayType aArrType, ArrayType bArrType)
throws ClassNotFoundException {
assert aArrType.getDimensions() == bArrType.getDimensions();
Type aBaseType = aArrType.getBasicType();
Type bBaseType = bArrType.getBasicType();
boolean aBaseIsObjectType = (aBaseType instanceof ObjectType);
boolean bBaseIsObjectType = (bBaseType instanceof ObjectType);
if (!aBaseIsObjectType || !bBaseIsObjectType) {
assert (aBaseType instanceof BasicType) || (bBaseType instanceof BasicType);
if (aArrType.getDimensions() > 1) {
// E.g.: first common supertype of int[][] and WHATEVER[][] is
// Object[]
return new ArrayType(Type.OBJECT, aArrType.getDimensions() - 1);
} else {
assert aArrType.getDimensions() == 1;
// E.g.: first common supertype type of int[] and WHATEVER[] is
// Object
return Type.OBJECT;
}
} else {
assert (aBaseType instanceof ObjectType);
assert (bBaseType instanceof ObjectType);
// Base types are both ObjectTypes, and number of dimensions is
// same.
// We just need to find the first common supertype of base types
// and return a new ArrayType using that base type.
ObjectType firstCommonBaseType = getFirstCommonSuperclass((ObjectType) aBaseType, (ObjectType) bBaseType);
return new ArrayType(firstCommonBaseType, aArrType.getDimensions());
}
} | java |
private ReferenceType computeFirstCommonSuperclassOfDifferentDimensionArrays(ArrayType aArrType, ArrayType bArrType) {
assert aArrType.getDimensions() != bArrType.getDimensions();
boolean aBaseTypeIsPrimitive = (aArrType.getBasicType() instanceof BasicType);
boolean bBaseTypeIsPrimitive = (bArrType.getBasicType() instanceof BasicType);
if (aBaseTypeIsPrimitive || bBaseTypeIsPrimitive) {
int minDimensions, maxDimensions;
if (aArrType.getDimensions() < bArrType.getDimensions()) {
minDimensions = aArrType.getDimensions();
maxDimensions = bArrType.getDimensions();
} else {
minDimensions = bArrType.getDimensions();
maxDimensions = aArrType.getDimensions();
}
if (minDimensions == 1) {
// One of the types was something like int[].
// The only possible common supertype is Object.
return Type.OBJECT;
} else {
// Weird case: e.g.,
// - first common supertype of int[][] and char[][][] is
// Object[]
// because f.c.s. of int[] and char[][] is Object
// - first common supertype of int[][][] and char[][][][][] is
// Object[][]
// because f.c.s. of int[] and char[][][] is Object
return new ArrayType(Type.OBJECT, maxDimensions - minDimensions);
}
} else {
// Both a and b have base types which are ObjectTypes.
// Since the arrays have different numbers of dimensions, the
// f.c.s. will have Object as its base type.
// E.g., f.c.s. of Cat[] and Dog[][] is Object[]
return new ArrayType(Type.OBJECT, Math.min(aArrType.getDimensions(), bArrType.getDimensions()));
}
} | java |
public boolean hasSubtypes(ClassDescriptor classDescriptor) throws ClassNotFoundException {
Set<ClassDescriptor> subtypes = getDirectSubtypes(classDescriptor);
if (DEBUG) {
System.out.println("Direct subtypes of " + classDescriptor + " are " + subtypes);
}
return !subtypes.isEmpty();
} | java |
public Set<ClassDescriptor> getDirectSubtypes(ClassDescriptor classDescriptor) throws ClassNotFoundException {
ClassVertex startVertex = resolveClassVertex(classDescriptor);
Set<ClassDescriptor> result = new HashSet<>();
Iterator<InheritanceEdge> i = graph.incomingEdgeIterator(startVertex);
while (i.hasNext()) {
InheritanceEdge edge = i.next();
result.add(edge.getSource().getClassDescriptor());
}
return result;
} | java |
public Set<ClassDescriptor> getTransitiveCommonSubtypes(ClassDescriptor classDescriptor1, ClassDescriptor classDescriptor2)
throws ClassNotFoundException {
Set<ClassDescriptor> subtypes1 = getSubtypes(classDescriptor1);
Set<ClassDescriptor> result = new HashSet<>(subtypes1);
Set<ClassDescriptor> subtypes2 = getSubtypes(classDescriptor2);
result.retainAll(subtypes2);
return result;
} | java |
public void traverseSupertypes(ClassDescriptor start, InheritanceGraphVisitor visitor) throws ClassNotFoundException {
LinkedList<SupertypeTraversalPath> workList = new LinkedList<>();
ClassVertex startVertex = resolveClassVertex(start);
workList.addLast(new SupertypeTraversalPath(startVertex));
while (!workList.isEmpty()) {
SupertypeTraversalPath cur = workList.removeFirst();
ClassVertex vertex = cur.getNext();
assert !cur.hasBeenSeen(vertex.getClassDescriptor());
cur.markSeen(vertex.getClassDescriptor());
if (!visitor.visitClass(vertex.getClassDescriptor(), vertex.getXClass())) {
// Visitor doesn't want to continue on this path
continue;
}
if (!vertex.isResolved()) {
// Unknown class - so, we don't know its immediate supertypes
continue;
}
// Advance to direct superclass
ClassDescriptor superclassDescriptor = vertex.getXClass().getSuperclassDescriptor();
if (superclassDescriptor != null && traverseEdge(vertex, superclassDescriptor, false, visitor)) {
addToWorkList(workList, cur, superclassDescriptor);
}
// Advance to directly-implemented interfaces
for (ClassDescriptor ifaceDesc : vertex.getXClass().getInterfaceDescriptorList()) {
if (traverseEdge(vertex, ifaceDesc, true, visitor)) {
addToWorkList(workList, cur, ifaceDesc);
}
}
}
} | java |
public void traverseSupertypesDepthFirst(ClassDescriptor start, SupertypeTraversalVisitor visitor) throws ClassNotFoundException {
this.traverseSupertypesDepthFirstHelper(start, visitor, new HashSet<ClassDescriptor>());
} | java |
private Set<ClassDescriptor> computeKnownSubtypes(ClassDescriptor classDescriptor) throws ClassNotFoundException {
LinkedList<ClassVertex> workList = new LinkedList<>();
ClassVertex startVertex = resolveClassVertex(classDescriptor);
workList.addLast(startVertex);
Set<ClassDescriptor> result = new HashSet<>();
while (!workList.isEmpty()) {
ClassVertex current = workList.removeFirst();
if (result.contains(current.getClassDescriptor())) {
// Already added this class
continue;
}
// Add class to the result
result.add(current.getClassDescriptor());
// Add all known subtype vertices to the work list
Iterator<InheritanceEdge> i = graph.incomingEdgeIterator(current);
while (i.hasNext()) {
InheritanceEdge edge = i.next();
workList.addLast(edge.getSource());
}
}
return new HashSet<>(result);
} | java |
public SupertypeQueryResults getSupertypeQueryResults(ClassDescriptor classDescriptor) {
SupertypeQueryResults supertypeQueryResults = supertypeSetMap.get(classDescriptor);
if (supertypeQueryResults == null) {
supertypeQueryResults = computeSupertypes(classDescriptor);
supertypeSetMap.put(classDescriptor, supertypeQueryResults);
}
return supertypeQueryResults;
} | java |
private SupertypeQueryResults computeSupertypes(ClassDescriptor classDescriptor) // throws
// ClassNotFoundException
{
if (DEBUG_QUERIES) {
System.out.println("Computing supertypes for " + classDescriptor.toDottedClassName());
}
// Try to fully resolve the class and its superclasses/superinterfaces.
ClassVertex typeVertex = optionallyResolveClassVertex(classDescriptor);
// Create new empty SupertypeQueryResults.
SupertypeQueryResults supertypeSet = new SupertypeQueryResults();
// Add all known superclasses/superinterfaces.
// The ClassVertexes for all of them should be in the
// InheritanceGraph by now.
LinkedList<ClassVertex> workList = new LinkedList<>();
workList.addLast(typeVertex);
while (!workList.isEmpty()) {
ClassVertex vertex = workList.removeFirst();
supertypeSet.addSupertype(vertex.getClassDescriptor());
if (vertex.isResolved()) {
if (DEBUG_QUERIES) {
System.out.println(" Adding supertype " + vertex.getClassDescriptor().toDottedClassName());
}
} else {
if (DEBUG_QUERIES) {
System.out.println(" Encountered unresolved class " + vertex.getClassDescriptor().toDottedClassName()
+ " in supertype query");
}
supertypeSet.setEncounteredMissingClasses(true);
}
Iterator<InheritanceEdge> i = graph.outgoingEdgeIterator(vertex);
while (i.hasNext()) {
InheritanceEdge edge = i.next();
workList.addLast(edge.getTarget());
}
}
return supertypeSet;
} | java |
private ClassVertex resolveClassVertex(ClassDescriptor classDescriptor) throws ClassNotFoundException {
ClassVertex typeVertex = optionallyResolveClassVertex(classDescriptor);
if (!typeVertex.isResolved()) {
ClassDescriptor.throwClassNotFoundException(classDescriptor);
}
assert typeVertex.isResolved();
return typeVertex;
} | java |
private void addSupertypeEdges(ClassVertex vertex, LinkedList<XClass> workList) {
XClass xclass = vertex.getXClass();
// Direct superclass
ClassDescriptor superclassDescriptor = xclass.getSuperclassDescriptor();
if (superclassDescriptor != null) {
addInheritanceEdge(vertex, superclassDescriptor, false, workList);
}
// Directly implemented interfaces
for (ClassDescriptor ifaceDesc : xclass.getInterfaceDescriptorList()) {
addInheritanceEdge(vertex, ifaceDesc, true, workList);
}
} | java |
private ClassVertex addClassVertexForMissingClass(ClassDescriptor missingClassDescriptor, boolean isInterfaceEdge) {
ClassVertex missingClassVertex = ClassVertex.createMissingClassVertex(missingClassDescriptor, isInterfaceEdge);
missingClassVertex.setFinished(true);
addVertexToGraph(missingClassDescriptor, missingClassVertex);
AnalysisContext.currentAnalysisContext();
AnalysisContext.reportMissingClass(missingClassDescriptor);
return missingClassVertex;
} | java |
public boolean prescreen(ClassContext classContext, Method method) {
BitSet bytecodeSet = classContext.getBytecodeSet(method);
return bytecodeSet != null
&& (bytecodeSet.get(Const.INVOKEINTERFACE) || bytecodeSet.get(Const.INVOKEVIRTUAL)
|| bytecodeSet.get(Const.INVOKESPECIAL) || bytecodeSet.get(Const.INVOKESTATIC) || bytecodeSet
.get(Const.INVOKENONVIRTUAL));
} | java |
private boolean isSynthetic(Method m) {
if ((m.getAccessFlags() & Const.ACC_SYNTHETIC) != 0) {
return true;
}
Attribute[] attrs = m.getAttributes();
for (Attribute attr : attrs) {
if (attr instanceof Synthetic) {
return true;
}
}
return false;
} | java |
private boolean compareTypesOld(Type parmType, Type argType) {
// XXX equality not implemented for GenericObjectType
// if (parmType.equals(argType)) return true;
// Compare type signatures instead
if (GenericUtilities.getString(parmType).equals(GenericUtilities.getString(argType))) {
return true;
}
if (parmType instanceof GenericObjectType) {
GenericObjectType o = (GenericObjectType) parmType;
if (o.getTypeCategory() == GenericUtilities.TypeCategory.WILDCARD_EXTENDS) {
return compareTypesOld(o.getExtension(), argType);
}
}
// ignore type variables for now
if (parmType instanceof GenericObjectType && !((GenericObjectType) parmType).hasParameters()) {
return true;
}
if (argType instanceof GenericObjectType && !((GenericObjectType) argType).hasParameters()) {
return true;
}
// Case: Both are generic containers
if (parmType instanceof GenericObjectType && argType instanceof GenericObjectType) {
return true;
} else {
// Don't consider non reference types (should not be possible)
if (!(parmType instanceof ReferenceType && argType instanceof ReferenceType)) {
return true;
}
// Don't consider non object types (for now)
if (!(parmType instanceof ObjectType && argType instanceof ObjectType)) {
return true;
}
// Otherwise, compare base types ignoring generic information
try {
return Repository.instanceOf(((ObjectType) argType).getClassName(), ((ObjectType) parmType).getClassName());
} catch (ClassNotFoundException e) {
}
}
return true;
} | java |
public void checkMessages(XMLFile messagesDoc) throws DocumentException {
// Detector elements must all have a class attribute
// and details child element.
for (Iterator<Node> i = messagesDoc.xpathIterator("/MessageCollection/Detector"); i.hasNext();) {
Node node = i.next();
messagesDoc.checkAttribute(node, "class");
messagesDoc.checkElement(node, "Details");
}
// BugPattern elements must all have type attribute
// and ShortDescription, LongDescription, and Details
// child elements.
for (Iterator<Node> i = messagesDoc.xpathIterator("/MessageCollection/BugPattern"); i.hasNext();) {
Node node = i.next();
messagesDoc.checkAttribute(node, "type");
messagesDoc.checkElement(node, "ShortDescription");
messagesDoc.checkElement(node, "LongDescription");
messagesDoc.checkElement(node, "Details");
}
// BugCode elements must contain abbrev attribute
// and have non-empty text
for (Iterator<Node> i = messagesDoc.xpathIterator("/MessageCollection/BugCode"); i.hasNext();) {
Node node = i.next();
messagesDoc.checkAttribute(node, "abbrev");
messagesDoc.checkNonEmptyText(node);
}
// Check that all Detectors are described
Set<String> describedDetectorsSet = messagesDoc.collectAttributes("/MessageCollection/Detector", "class");
checkDescribed("Bug detectors not described by Detector elements", messagesDoc, declaredDetectorsSet,
describedDetectorsSet);
// Check that all BugCodes are described
Set<String> describedAbbrevsSet = messagesDoc.collectAttributes("/MessageCollection/BugCode", "abbrev");
checkDescribed("Abbreviations not described by BugCode elements", messagesDoc, declaredAbbrevsSet, describedAbbrevsSet);
} | java |
public static boolean check() {
Class<?> objectType;
Class<?> type;
Class<?> constants;
Class<?> emptyVis;
Class<?> repository;
try {
objectType = Class.forName(ORG_APACHE_BCEL_GENERIC_OBJECT_TYPE);
type = Class.forName(ORG_APACHE_BCEL_GENERIC_TYPE);
constants = Class.forName(ORG_APACHE_BCEL_CONSTANTS);
emptyVis = Class.forName(ORG_APACHE_BCEL_CLASSFILE_EMPTY_VISITOR);
repository = Class.forName(ORG_APACHE_BCEL_REPOSITORY);
} catch (ClassNotFoundException e) {
LOG.error("One or more required BCEL classes were missing."
+ " Ensure that bcel.jar is placed at the same directory with spotbugs.jar");
return false;
}
if (isFinal(objectType)) {
error(ORG_APACHE_BCEL_GENERIC_OBJECT_TYPE);
return false;
}
if (isFinal(type)) {
error(ORG_APACHE_BCEL_GENERIC_TYPE);
return false;
}
if (isFinal(constants)) {
error(ORG_APACHE_BCEL_CONSTANTS);
return false;
}
if (isFinal(emptyVis)) {
error(ORG_APACHE_BCEL_CLASSFILE_EMPTY_VISITOR);
return false;
}
if (isFinal(repository)) {
error(ORG_APACHE_BCEL_REPOSITORY);
return false;
}
return true;
} | java |
public ValueNumber forNumber(int number) {
if (number >= getNumValuesAllocated()) {
throw new IllegalArgumentException("Value " + number + " has not been allocated");
}
return allocatedValueList.get(number);
} | java |
public String format(BugAnnotation[] args, ClassAnnotation primaryClass, boolean abridgedMessages) {
String pat = pattern;
StringBuilder result = new StringBuilder();
while (pat.length() > 0) {
int subst = pat.indexOf('{');
if (subst < 0) {
result.append(pat);
break;
}
result.append(pat.substring(0, subst));
pat = pat.substring(subst + 1);
int end = pat.indexOf('}');
if (end < 0) {
throw new IllegalStateException("unmatched { in " + pat);
}
String substPat = pat.substring(0, end);
int dot = substPat.indexOf('.');
String key = "";
if (dot >= 0) {
key = substPat.substring(dot + 1);
substPat = substPat.substring(0, dot);
} else if (abridgedMessages && primaryClass != null) {
key = "givenClass";
}
int fieldNum;
try {
fieldNum = Integer.parseInt(substPat);
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Bad integer value " + substPat + " in " + pattern);
}
// System.out.println("fn: " + fieldNum);
if (fieldNum < 0) {
result.append("?<?" + fieldNum + "/" + args.length + "???");
} else if (fieldNum >= args.length) {
result.append("?>?" + fieldNum + "/" + args.length + "???");
} else {
BugAnnotation field = args[fieldNum];
String formatted = "";
try {
formatted = field.format(key, primaryClass);
} catch (IllegalArgumentException iae) {
if (SystemProperties.ASSERTIONS_ENABLED) {
throw new IllegalArgumentException("Problem processing " + pattern + " format " + substPat + " for "
+ field.getClass().getSimpleName(), iae);
}
// unknown key -- not unprecedented when reading xml
// generated by older versions of findbugs
formatted = "\u00BF" + fieldNum + ".(key=" + key + ")?"; // "\u00BF"
// is
// inverted
// question
// mark
// System.err.println(iae.getMessage()+" in FindBugsMessageFormat");
// // FIXME: log this error better
}
result.append(formatted);
}
pat = pat.substring(end + 1);
}
return result.toString();
} | java |
public static FieldAnnotation fromVisitedField(PreorderVisitor visitor) {
return new FieldAnnotation(visitor.getDottedClassName(), visitor.getFieldName(), visitor.getFieldSig(),
visitor.getFieldIsStatic());
} | java |
public static FieldAnnotation fromFieldDescriptor(FieldDescriptor fieldDescriptor) {
return new FieldAnnotation(fieldDescriptor.getClassDescriptor().getDottedClassName(), fieldDescriptor.getName(),
fieldDescriptor.getSignature(), fieldDescriptor.isStatic());
} | java |
public static FieldAnnotation isRead(Instruction ins, ConstantPoolGen cpg) {
if (ins instanceof GETFIELD || ins instanceof GETSTATIC) {
FieldInstruction fins = (FieldInstruction) ins;
String className = fins.getClassName(cpg);
return new FieldAnnotation(className, fins.getName(cpg), fins.getSignature(cpg), fins instanceof GETSTATIC);
} else {
return null;
}
} | java |
public static FieldAnnotation isWrite(Instruction ins, ConstantPoolGen cpg) {
if (ins instanceof PUTFIELD || ins instanceof PUTSTATIC) {
FieldInstruction fins = (FieldInstruction) ins;
String className = fins.getClassName(cpg);
return new FieldAnnotation(className, fins.getName(cpg), fins.getSignature(cpg), fins instanceof PUTSTATIC);
} else {
return null;
}
} | java |
public static boolean isClassFile(IJavaElement elt) {
if (elt == null) {
return false;
}
return elt instanceof IClassFile || elt instanceof ICompilationUnit;
} | java |
public static void copyToClipboard(String content) {
if (content == null) {
return;
}
Clipboard cb = null;
try {
cb = new Clipboard(Display.getDefault());
cb.setContents(new String[] { content }, new TextTransfer[] { TextTransfer.getInstance() });
} finally {
if (cb != null) {
cb.dispose();
}
}
} | java |
public static void sortIMarkers(IMarker[] markers) {
Arrays.sort(markers, new Comparator<IMarker>() {
@Override
public int compare(IMarker arg0, IMarker arg1) {
IResource resource0 = arg0.getResource();
IResource resource1 = arg1.getResource();
if (resource0 != null && resource1 != null) {
return resource0.getName().compareTo(resource1.getName());
}
if (resource0 != null && resource1 == null) {
return 1;
}
if (resource0 == null && resource1 != null) {
return -1;
}
return 0;
}
});
} | java |
public @CheckForNull
IsNullValue getDecision(int edgeType) {
switch (edgeType) {
case EdgeTypes.IFCMP_EDGE:
return ifcmpDecision;
case EdgeTypes.FALL_THROUGH_EDGE:
return fallThroughDecision;
default:
throw new IllegalArgumentException("Bad edge type: " + edgeType);
}
} | java |
private BitSet findPreviouslyDeadBlocks() throws DataflowAnalysisException, CFGBuilderException {
BitSet deadBlocks = new BitSet();
ValueNumberDataflow vnaDataflow = classContext.getValueNumberDataflow(method);
for (Iterator<BasicBlock> i = vnaDataflow.getCFG().blockIterator(); i.hasNext();) {
BasicBlock block = i.next();
ValueNumberFrame vnaFrame = vnaDataflow.getStartFact(block);
if (vnaFrame.isTop()) {
deadBlocks.set(block.getLabel());
}
}
return deadBlocks;
} | java |
public void addStreamEscape(Stream source, Location target) {
StreamEscape streamEscape = new StreamEscape(source, target);
streamEscapeSet.add(streamEscape);
if (FindOpenStream.DEBUG) {
System.out.println("Adding potential stream escape " + streamEscape);
}
} | java |
public void addStreamOpenLocation(Location streamOpenLocation, Stream stream) {
if (FindOpenStream.DEBUG) {
System.out.println("Stream open location at " + streamOpenLocation);
}
streamOpenLocationMap.put(streamOpenLocation, stream);
if (stream.isUninteresting()) {
uninterestingStreamEscapeSet.add(stream);
}
} | java |
private NullnessAnnotation getMethodNullnessAnnotation() {
if (method.getSignature().indexOf(")L") >= 0 || method.getSignature().indexOf(")[") >= 0) {
if (DEBUG_NULLRETURN) {
System.out.println("Checking return annotation for "
+ SignatureConverter.convertMethodSignature(classContext.getJavaClass(), method));
}
XMethod m = XFactory.createXMethod(classContext.getJavaClass(), method);
return AnalysisContext.currentAnalysisContext().getNullnessAnnotationDatabase().getResolvedAnnotation(m, false);
}
return NullnessAnnotation.UNKNOWN_NULLNESS;
} | java |
private void checkNonNullParam(Location location, ConstantPoolGen cpg, TypeDataflow typeDataflow,
InvokeInstruction invokeInstruction, BitSet nullArgSet, BitSet definitelyNullArgSet) {
if (inExplicitCatchNullBlock(location)) {
return;
}
boolean caught = inIndirectCatchNullBlock(location);
if (caught && skipIfInsideCatchNull()) {
return;
}
if (invokeInstruction instanceof INVOKEDYNAMIC) {
return;
}
XMethod m = XFactory.createXMethod(invokeInstruction, cpg);
INullnessAnnotationDatabase db = AnalysisContext.currentAnalysisContext().getNullnessAnnotationDatabase();
SignatureParser sigParser = new SignatureParser(invokeInstruction.getSignature(cpg));
for (int i = nullArgSet.nextSetBit(0); i >= 0; i = nullArgSet.nextSetBit(i + 1)) {
if (db.parameterMustBeNonNull(m, i)) {
boolean definitelyNull = definitelyNullArgSet.get(i);
if (DEBUG_NULLARG) {
System.out.println("Checking " + m);
System.out.println("QQQ2: " + i + " -- " + i + " is null");
System.out.println("QQQ nullArgSet: " + nullArgSet);
System.out.println("QQQ dnullArgSet: " + definitelyNullArgSet);
}
BugAnnotation variableAnnotation = null;
try {
ValueNumberFrame vnaFrame = classContext.getValueNumberDataflow(method).getFactAtLocation(location);
ValueNumber valueNumber = vnaFrame.getArgument(invokeInstruction, cpg, i, sigParser);
variableAnnotation = ValueNumberSourceInfo.findAnnotationFromValueNumber(method, location, valueNumber,
vnaFrame, "VALUE_OF");
} catch (DataflowAnalysisException e) {
AnalysisContext.logError("error", e);
} catch (CFGBuilderException e) {
AnalysisContext.logError("error", e);
}
int priority = definitelyNull ? HIGH_PRIORITY : NORMAL_PRIORITY;
if (caught) {
priority++;
}
if (m.isPrivate() && priority == HIGH_PRIORITY) {
priority = NORMAL_PRIORITY;
}
String description = definitelyNull ? "INT_NULL_ARG" : "INT_MAYBE_NULL_ARG";
WarningPropertySet<WarningProperty> propertySet = new WarningPropertySet<>();
Set<Location> derefLocationSet = Collections.singleton(location);
addPropertiesForDereferenceLocations(propertySet, derefLocationSet, false);
boolean duplicated = isDuplicated(propertySet, location.getHandle().getPosition(), false);
if (duplicated) {
return;
}
BugInstance warning = new BugInstance(this, "NP_NONNULL_PARAM_VIOLATION", priority)
.addClassAndMethod(classContext.getJavaClass(), method).addMethod(m)
.describe(MethodAnnotation.METHOD_CALLED).addParameterAnnotation(i, description)
.addOptionalAnnotation(variableAnnotation).addSourceLine(classContext, method, location);
propertySet.decorateBugInstance(warning);
bugReporter.reportBug(warning);
}
}
} | java |
private boolean isGoto(Instruction instruction) {
return instruction.getOpcode() == Const.GOTO || instruction.getOpcode() == Const.GOTO_W;
} | java |
public void dispose(){
classAnalysisMap.clear();
classAnalysisEngineMap.clear();
analysisLocals.clear();
databaseFactoryMap.clear();
databaseMap.clear();
methodAnalysisEngineMap.clear();
} | java |
public <E> void reuseClassAnalysis(Class<E> analysisClass, Map<ClassDescriptor, Object> map) {
Map<ClassDescriptor, Object> myMap = classAnalysisMap.get(analysisClass);
if (myMap != null) {
myMap.putAll(map);
} else {
myMap = createMap(classAnalysisEngineMap, analysisClass);
myMap.putAll(map);
classAnalysisMap.put(analysisClass, myMap);
}
} | java |
@SuppressWarnings("unchecked")
private <E> E analyzeMethod(ClassContext classContext, Class<E> analysisClass, MethodDescriptor methodDescriptor)
throws CheckedAnalysisException {
IMethodAnalysisEngine<E> engine = (IMethodAnalysisEngine<E>) methodAnalysisEngineMap.get(analysisClass);
if (engine == null) {
throw new IllegalArgumentException("No analysis engine registered to produce " + analysisClass.getName());
}
Profiler profiler = getProfiler();
profiler.start(engine.getClass());
try {
return engine.analyze(this, methodDescriptor);
} finally {
profiler.end(engine.getClass());
}
} | java |
private static <DescriptorType> Map<DescriptorType, Object> findOrCreateDescriptorMap(
final Map<Class<?>, Map<DescriptorType, Object>> analysisClassToDescriptorMapMap,
final Map<Class<?>, ? extends IAnalysisEngine<DescriptorType, ?>> engineMap,
final Class<?> analysisClass) {
Map<DescriptorType, Object> descriptorMap = analysisClassToDescriptorMapMap.get(analysisClass);
if (descriptorMap == null) {
descriptorMap = createMap(engineMap, analysisClass);
analysisClassToDescriptorMapMap.put(analysisClass, descriptorMap);
}
return descriptorMap;
} | java |
public void writeElementList(String tagName, Collection<String> listValues) {
for (String listValue : listValues) {
openTag(tagName);
writeText(listValue);
closeTag(tagName);
}
} | java |
public boolean isObligationType(ClassDescriptor classDescriptor) {
try {
return getObligationByType(BCELUtil.getObjectTypeInstance(classDescriptor.toDottedClassName())) != null;
} catch (ClassNotFoundException e) {
Global.getAnalysisCache().getErrorLogger().reportMissingClass(e);
return false;
}
} | java |
public Obligation[] getParameterObligationTypes(XMethod xmethod) {
Type[] paramTypes = Type.getArgumentTypes(xmethod.getSignature());
Obligation[] result = new Obligation[paramTypes.length];
for (int i = 0; i < paramTypes.length; i++) {
if (!(paramTypes[i] instanceof ObjectType)) {
continue;
}
try {
result[i] = getObligationByType((ObjectType) paramTypes[i]);
} catch (ClassNotFoundException e) {
Global.getAnalysisCache().getErrorLogger().reportMissingClass(e);
}
}
return result;
} | java |
@Override
public Fact getFactAfterLocation(Location location) throws DataflowAnalysisException {
BasicBlock basicBlock = location.getBasicBlock();
InstructionHandle handle = location.getHandle();
if (handle == (isForwards() ? basicBlock.getLastInstruction() : basicBlock.getFirstInstruction())) {
return getResultFact(basicBlock);
} else {
return getFactAtLocation(new Location(isForwards() ? handle.getNext() : handle.getPrev(), basicBlock));
}
} | java |
@Override
public void visit(JavaClass someObj) {
currentClass = someObj.getClassName();
currentMethod = null;
currentCFG = null;
currentLockDataFlow = null;
sawDateClass = false;
} | java |
private void addAuxClassPathEntries(String argument) {
StringTokenizer tok = new StringTokenizer(argument, File.pathSeparator);
while (tok.hasMoreTokens()) {
project.addAuxClasspathEntry(tok.nextToken());
}
} | java |
private void choose(String argument, String desc, Chooser chooser) {
StringTokenizer tok = new StringTokenizer(argument, ",");
while (tok.hasMoreTokens()) {
String what = tok.nextToken().trim();
if (!what.startsWith("+") && !what.startsWith("-")) {
throw new IllegalArgumentException(desc + " must start with " + "\"+\" or \"-\" (saw " + what + ")");
}
boolean enabled = what.startsWith("+");
chooser.choose(enabled, what.substring(1));
}
} | java |
public void handleXArgs() throws IOException {
if (getXargs()) {
try (BufferedReader in = UTF8.bufferedReader(System.in)) {
while (true) {
String s = in.readLine();
if (s == null) {
break;
}
project.addFile(s);
}
}
}
} | java |
private void handleAuxClassPathFromFile(String filePath) throws IOException {
try (BufferedReader in = new BufferedReader(UTF8.fileReader(filePath))) {
while (true) {
String s = in.readLine();
if (s == null) {
break;
}
project.addAuxClasspathEntry(s);
}
}
} | java |
private void handleAnalyzeFromFile(String filePath) throws IOException {
try (BufferedReader in = new BufferedReader(UTF8.fileReader(filePath))) {
while (true) {
String s = in.readLine();
if (s == null) {
break;
}
project.addFile(s);
}
}
} | java |
public Project duplicate() {
Project dup = new Project();
dup.currentWorkingDirectoryList.addAll(this.currentWorkingDirectoryList);
dup.projectName = this.projectName;
dup.analysisTargets.addAll(this.analysisTargets);
dup.srcDirList.addAll(this.srcDirList);
dup.auxClasspathEntryList.addAll(this.auxClasspathEntryList);
dup.timestampForAnalyzedClasses = timestampForAnalyzedClasses;
dup.guiCallback = guiCallback;
return dup;
} | java |
public void add(Project project2) {
analysisTargets = appendWithoutDuplicates(analysisTargets, project2.analysisTargets);
srcDirList = appendWithoutDuplicates(srcDirList, project2.srcDirList);
auxClasspathEntryList = appendWithoutDuplicates(auxClasspathEntryList, project2.auxClasspathEntryList);
} | java |
public boolean addSourceDirs(Collection<String> sourceDirs) {
boolean isNew = false;
if (sourceDirs == null || sourceDirs.isEmpty()) {
return isNew;
}
for (String dirName : sourceDirs) {
for (String dir : makeAbsoluteCwdCandidates(dirName)) {
isNew = addToListInternal(srcDirList, dir) || isNew;
}
}
IO.close(sourceFinder);
sourceFinder = new SourceFinder(this);
return isNew;
} | java |
public boolean addWorkingDir(String dirName) {
if (dirName == null) {
throw new NullPointerException();
}
return addToListInternal(currentWorkingDirectoryList, new File(dirName));
} | java |
public void removeSourceDir(int num) {
srcDirList.remove(num);
IO.close(sourceFinder);
sourceFinder = new SourceFinder(this);
isModified = true;
} | java |
@Deprecated
public void write(String outputFile, boolean useRelativePaths, String relativeBase) throws IOException {
PrintWriter writer = UTF8.printWriter(outputFile);
try {
writer.println(JAR_FILES_KEY);
for (String jarFile : analysisTargets) {
if (useRelativePaths) {
jarFile = convertToRelative(jarFile, relativeBase);
}
writer.println(jarFile);
}
writer.println(SRC_DIRS_KEY);
for (String srcDir : srcDirList) {
if (useRelativePaths) {
srcDir = convertToRelative(srcDir, relativeBase);
}
writer.println(srcDir);
}
writer.println(AUX_CLASSPATH_ENTRIES_KEY);
for (String auxClasspathEntry : auxClasspathEntryList) {
if (useRelativePaths) {
auxClasspathEntry = convertToRelative(auxClasspathEntry, relativeBase);
}
writer.println(auxClasspathEntry);
}
if (useRelativePaths) {
writer.println(OPTIONS_KEY);
writer.println(RELATIVE_PATHS + "=true");
}
} finally {
writer.close();
}
// Project successfully saved
isModified = false;
} | java |
public static Project readProject(String argument) throws IOException {
String projectFileName = argument;
File projectFile = new File(projectFileName);
if (projectFileName.endsWith(".xml") || projectFileName.endsWith(".fbp")) {
try {
return Project.readXML(projectFile);
} catch (SAXException e) {
IOException ioe = new IOException("Couldn't read saved FindBugs project");
ioe.initCause(e);
throw ioe;
}
}
throw new IllegalArgumentException("Can't read project from " + argument);
} | java |
private String convertToRelative(String srcFile, String base) {
String slash = SystemProperties.getProperty("file.separator");
if (FILE_IGNORE_CASE) {
srcFile = srcFile.toLowerCase();
base = base.toLowerCase();
}
if (base.equals(srcFile)) {
return ".";
}
if (!base.endsWith(slash)) {
base = base + slash;
}
if (base.length() <= srcFile.length()) {
String root = srcFile.substring(0, base.length());
if (root.equals(base)) {
// Strip off the base directory, make relative
return "." + SystemProperties.getProperty("file.separator") + srcFile.substring(base.length());
}
}
// See if we can build a relative path above the base using .. notation
int slashPos = srcFile.indexOf(slash);
int branchPoint;
if (slashPos >= 0) {
String subPath = srcFile.substring(0, slashPos);
if ((subPath.length() == 0) || base.startsWith(subPath)) {
branchPoint = slashPos + 1;
slashPos = srcFile.indexOf(slash, branchPoint);
while (slashPos >= 0) {
subPath = srcFile.substring(0, slashPos);
if (base.startsWith(subPath)) {
branchPoint = slashPos + 1;
} else {
break;
}
slashPos = srcFile.indexOf(slash, branchPoint);
}
int slashCount = 0;
slashPos = base.indexOf(slash, branchPoint);
while (slashPos >= 0) {
slashCount++;
slashPos = base.indexOf(slash, slashPos + 1);
}
StringBuilder path = new StringBuilder();
String upDir = ".." + slash;
for (int i = 0; i < slashCount; i++) {
path.append(upDir);
}
path.append(srcFile.substring(branchPoint));
return path.toString();
}
}
return srcFile;
} | java |
private String makeAbsoluteCWD(String fileName) {
List<String> candidates = makeAbsoluteCwdCandidates(fileName);
return candidates.get(0);
} | java |
private List<String> makeAbsoluteCwdCandidates(String fileName) {
List<String> candidates = new ArrayList<>();
boolean hasProtocol = (URLClassPath.getURLProtocol(fileName) != null);
if (hasProtocol) {
candidates.add(fileName);
return candidates;
}
if (new File(fileName).isAbsolute()) {
candidates.add(fileName);
return candidates;
}
for (File currentWorkingDirectory : currentWorkingDirectoryList) {
File relativeToCurrent = new File(currentWorkingDirectory, fileName);
if (relativeToCurrent.exists()) {
candidates.add(relativeToCurrent.toString());
}
}
if (candidates.isEmpty()) {
candidates.add(fileName);
}
return candidates;
} | java |
private <T> boolean addToListInternal(Collection<T> list, T value) {
if (!list.contains(value)) {
list.add(value);
isModified = true;
return true;
} else {
return false;
}
} | java |
private boolean doRedundantLoadElimination() {
if (!REDUNDANT_LOAD_ELIMINATION) {
return false;
}
XField xfield = loadedFieldSet.getField(handle);
if (xfield == null) {
return false;
}
// TODO: support two-slot fields
return !(xfield.getSignature().equals("D") || xfield.getSignature().equals("J"));
} | java |
private boolean doForwardSubstitution() {
if (!REDUNDANT_LOAD_ELIMINATION) {
return false;
}
XField xfield = loadedFieldSet.getField(handle);
if (xfield == null) {
return false;
}
if(xfield.getSignature().equals("D") || xfield.getSignature().equals("J")) {
return false;
}
// Don't do forward substitution for fields that
// are never read.
return loadedFieldSet.isLoaded(xfield);
} | java |
@Override
public void modelNormalInstruction(Instruction ins, int numWordsConsumed, int numWordsProduced) {
int flags = 0;
if (ins instanceof InvokeInstruction) {
flags = ValueNumber.RETURN_VALUE;
} else if (ins instanceof ArrayInstruction) {
flags = ValueNumber.ARRAY_VALUE;
} else if (ins instanceof ConstantPushInstruction) {
flags = ValueNumber.CONSTANT_VALUE;
}
// Get the input operands to this instruction.
ValueNumber[] inputValueList = popInputValues(numWordsConsumed);
// See if we have the output operands in the cache.
// If not, push default (fresh) values for the output,
// and add them to the cache.
ValueNumber[] outputValueList = getOutputValues(inputValueList, numWordsProduced, flags);
if (VERIFY_INTEGRITY) {
checkConsumedAndProducedValues(ins, inputValueList, outputValueList);
}
// Push output operands on stack.
pushOutputValues(outputValueList);
} | java |
private ValueNumber[] popInputValues(int numWordsConsumed) {
ValueNumberFrame frame = getFrame();
ValueNumber[] inputValueList = allocateValueNumberArray(numWordsConsumed);
// Pop off the input operands.
try {
frame.getTopStackWords(inputValueList);
while (numWordsConsumed-- > 0) {
frame.popValue();
}
} catch (DataflowAnalysisException e) {
throw new InvalidBytecodeException("Error getting input operands", e);
}
return inputValueList;
} | java |
private void pushOutputValues(ValueNumber[] outputValueList) {
ValueNumberFrame frame = getFrame();
for (ValueNumber aOutputValueList : outputValueList) {
frame.pushValue(aOutputValueList);
}
} | java |
private void loadInstanceField(XField instanceField, Instruction obj) {
if (RLE_DEBUG) {
System.out.println("[loadInstanceField for field " + instanceField + " in instruction " + handle);
}
ValueNumberFrame frame = getFrame();
try {
ValueNumber reference = frame.popValue();
AvailableLoad availableLoad = new AvailableLoad(reference, instanceField);
if (RLE_DEBUG) {
System.out.println("[getfield of " + availableLoad + "]");
}
ValueNumber[] loadedValue = frame.getAvailableLoad(availableLoad);
if (loadedValue == null) {
// Get (or create) the cached result for this instruction
ValueNumber[] inputValueList = new ValueNumber[] { reference };
loadedValue = getOutputValues(inputValueList, getNumWordsProduced(obj));
// Make the load available
frame.addAvailableLoad(availableLoad, loadedValue);
if (RLE_DEBUG) {
System.out.println("[Making load available " + availableLoad + " <- " + vlts(loadedValue) + "]");
}
} else {
// Found an available load!
if (RLE_DEBUG) {
System.out.println("[Found available load " + availableLoad + " <- " + vlts(loadedValue) + "]");
}
}
pushOutputValues(loadedValue);
if (VERIFY_INTEGRITY) {
checkConsumedAndProducedValues(obj, new ValueNumber[] { reference }, loadedValue);
}
} catch (DataflowAnalysisException e) {
throw new InvalidBytecodeException("Error loading from instance field", e);
}
} | java |
private void loadStaticField(XField staticField, Instruction obj) {
if (RLE_DEBUG) {
System.out.println("[loadStaticField for field " + staticField + " in instruction " + handle);
}
ValueNumberFrame frame = getFrame();
AvailableLoad availableLoad = new AvailableLoad(staticField);
ValueNumber[] loadedValue = frame.getAvailableLoad(availableLoad);
if (loadedValue == null) {
// Make the load available
int numWordsProduced = getNumWordsProduced(obj);
loadedValue = getOutputValues(EMPTY_INPUT_VALUE_LIST, numWordsProduced);
frame.addAvailableLoad(availableLoad, loadedValue);
if (RLE_DEBUG) {
System.out.println("[making load of " + staticField + " available]");
}
} else {
if (RLE_DEBUG) {
System.out.println("[found available load of " + staticField + "]");
}
}
if (VERIFY_INTEGRITY) {
checkConsumedAndProducedValues(obj, EMPTY_INPUT_VALUE_LIST, loadedValue);
}
pushOutputValues(loadedValue);
} | java |
private void storeInstanceField(XField instanceField, Instruction obj, boolean pushStoredValue) {
if (RLE_DEBUG) {
System.out.println("[storeInstanceField for field " + instanceField + " in instruction " + handle);
}
ValueNumberFrame frame = getFrame();
int numWordsConsumed = getNumWordsConsumed(obj);
/*
* System.out.println("Instruction is " + handle);
* System.out.println("numWordsConsumed="+numWordsConsumed);
*/
ValueNumber[] inputValueList = popInputValues(numWordsConsumed);
ValueNumber reference = inputValueList[0];
ValueNumber[] storedValue = allocateValueNumberArray(inputValueList.length - 1);
System.arraycopy(inputValueList, 1, storedValue, 0, inputValueList.length - 1);
if (pushStoredValue) {
pushOutputValues(storedValue);
}
// Kill all previous loads of the same field,
// in case there is aliasing we don't know about
frame.killLoadsOfField(instanceField);
// Forward substitution
frame.addAvailableLoad(new AvailableLoad(reference, instanceField), storedValue);
if (RLE_DEBUG) {
System.out.println("[making store of " + instanceField + " available]");
}
if (VERIFY_INTEGRITY) {
/*
* System.out.println("pushStoredValue="+pushStoredValue);
*/
checkConsumedAndProducedValues(obj, inputValueList, pushStoredValue ? storedValue : EMPTY_INPUT_VALUE_LIST);
}
} | java |
private void storeStaticField(XField staticField, Instruction obj, boolean pushStoredValue) {
if (RLE_DEBUG) {
System.out.println("[storeStaticField for field " + staticField + " in instruction " + handle);
}
ValueNumberFrame frame = getFrame();
AvailableLoad availableLoad = new AvailableLoad(staticField);
int numWordsConsumed = getNumWordsConsumed(obj);
ValueNumber[] inputValueList = popInputValues(numWordsConsumed);
if (pushStoredValue) {
pushOutputValues(inputValueList);
}
// Kill loads of this field
frame.killLoadsOfField(staticField);
// Make load available
frame.addAvailableLoad(availableLoad, inputValueList);
if (RLE_DEBUG) {
System.out.println("[making store of " + staticField + " available]");
}
if (VERIFY_INTEGRITY) {
checkConsumedAndProducedValues(obj, inputValueList, pushStoredValue ? inputValueList : EMPTY_INPUT_VALUE_LIST);
}
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.