code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
@Override
@Nonnull
public String getLabel() {
ASTVisitor labelFixingVisitor = getCustomLabelVisitor();
if (labelFixingVisitor instanceof CustomLabelVisitor) {
if (customizedLabel == null) {
String labelReplacement = findLabelReplacement(labelFixingVisitor);
customizedLabel = label.replace(BugResolution.PLACEHOLDER_STRING, labelReplacement);
}
return customizedLabel;
}
return label;
} | java |
private void runInternal(IMarker marker) throws CoreException {
Assert.isNotNull(marker);
PendingRewrite pending = resolveWithoutWriting(marker);
if(pending == null){
return;
}
try {
IRegion region = completeRewrite(pending);
if(region == null){
return;
}
IEditorPart part = EditorUtility.isOpenInEditor(pending.originalUnit);
if (part instanceof ITextEditor) {
((ITextEditor) part).selectAndReveal(region.getOffset(), region.getLength());
}
} finally {
pending.originalUnit.discardWorkingCopy();
}
} | java |
@CheckForNull
protected ICompilationUnit getCompilationUnit(IMarker marker) {
IResource res = marker.getResource();
if (res instanceof IFile && res.isAccessible()) {
IJavaElement element = JavaCore.create((IFile) res);
if (element instanceof ICompilationUnit) {
return (ICompilationUnit) element;
}
}
return null;
} | java |
protected void reportException(Exception e) {
Assert.isNotNull(e);
FindbugsPlugin.getDefault().logException(e, e.getLocalizedMessage());
MessageDialog.openError(FindbugsPlugin.getShell(), "BugResolution failed.", e.getLocalizedMessage());
} | java |
public int getSizeOfSurroundingTryBlock(String vmNameOfExceptionClass, int pc) {
if (code == null) {
throw new IllegalStateException("Not visiting Code");
}
return Util.getSizeOfSurroundingTryBlock(constantPool, code, vmNameOfExceptionClass, pc);
} | java |
public String getFullyQualifiedMethodName() {
if (!visitingMethod) {
throw new IllegalStateException("getFullyQualifiedMethodName called while not visiting method");
}
if (fullyQualifiedMethodName == null) {
getMethodName();
getDottedMethodSig();
StringBuilder ref = new StringBuilder(5 + dottedClassName.length() + methodName.length() + dottedMethodSig.length());
ref.append(dottedClassName).append(".").append(methodName).append(" : ").append(dottedMethodSig);
fullyQualifiedMethodName = ref.toString();
}
return fullyQualifiedMethodName;
} | java |
public String getMethodName() {
if (!visitingMethod) {
throw new IllegalStateException("getMethodName called while not visiting method");
}
if (methodName == null) {
methodName = getStringFromIndex(method.getNameIndex());
}
return methodName;
} | java |
public static boolean hasInterestingMethod(ConstantPool cp, Collection<MethodDescriptor> methods) {
for(Constant c : cp.getConstantPool()) {
if(c instanceof ConstantMethodref || c instanceof ConstantInterfaceMethodref) {
ConstantCP desc = (ConstantCP)c;
ConstantNameAndType nameAndType = (ConstantNameAndType) cp.getConstant(desc.getNameAndTypeIndex());
String className = cp.getConstantString(desc.getClassIndex(), Const.CONSTANT_Class);
String name = ((ConstantUtf8)cp.getConstant(nameAndType.getNameIndex())).getBytes();
String signature = ((ConstantUtf8)cp.getConstant(nameAndType.getSignatureIndex())).getBytes();
// We don't know whether method is static thus cannot use equals
int hash = FieldOrMethodDescriptor.getNameSigHashCode(name, signature);
for(MethodDescriptor method : methods) {
if (method.getNameSigHashCode() == hash
&& (method.getSlashedClassName().isEmpty() || method.getSlashedClassName().equals(className))
&& method.getName().equals(name) && method.getSignature().equals(signature)) {
return true;
}
}
}
}
return false;
} | java |
public String getMethodSig() {
if (!visitingMethod) {
throw new IllegalStateException("getMethodSig called while not visiting method");
}
if (methodSig == null) {
methodSig = getStringFromIndex(method.getSignatureIndex());
}
return methodSig;
} | java |
public String getDottedMethodSig() {
if (!visitingMethod) {
throw new IllegalStateException("getDottedMethodSig called while not visiting method");
}
if (dottedMethodSig == null) {
dottedMethodSig = getMethodSig().replace('/', '.');
}
return dottedMethodSig;
} | java |
public String getFieldName() {
if (!visitingField) {
throw new IllegalStateException("getFieldName called while not visiting field");
}
if (fieldName == null) {
fieldName = getStringFromIndex(field.getNameIndex());
}
return fieldName;
} | java |
public String getFieldSig() {
if (!visitingField) {
throw new IllegalStateException("getFieldSig called while not visiting field");
}
if (fieldSig == null) {
fieldSig = getStringFromIndex(field.getSignatureIndex());
}
return fieldSig;
} | java |
public String getFullyQualifiedFieldName() {
if (!visitingField) {
throw new IllegalStateException("getFullyQualifiedFieldName called while not visiting field");
}
if (fullyQualifiedFieldName == null) {
fullyQualifiedFieldName = getDottedClassName() + "." + getFieldName() + " : " + getFieldSig();
}
return fullyQualifiedFieldName;
} | java |
@Deprecated
public String getDottedFieldSig() {
if (!visitingField) {
throw new IllegalStateException("getDottedFieldSig called while not visiting field");
}
if (dottedFieldSig == null) {
dottedFieldSig = fieldSig.replace('/', '.');
}
return dottedFieldSig;
} | java |
public ClassNotFoundException toClassNotFoundException() {
ClassDescriptor classDescriptor = DescriptorFactory.createClassDescriptorFromResourceName(resourceName);
return new ClassNotFoundException("ResourceNotFoundException while looking for class "
+ classDescriptor.toDottedClassName() + ": " + getMessage());
} | java |
private ICodeBaseEntry search(List<? extends ICodeBase> codeBaseList, String resourceName) {
for (ICodeBase codeBase : codeBaseList) {
ICodeBaseEntry resource = codeBase.lookupResource(resourceName);
if (resource != null) {
return resource;
}
// Ignore, continue trying other codebases
}
return null;
} | java |
public void copyFrom(StateSet other) {
this.isTop = other.isTop;
this.isBottom = other.isBottom;
this.onExceptionPath = other.onExceptionPath;
this.stateMap.clear();
for (State state : other.stateMap.values()) {
State dup = state.duplicate();
this.stateMap.put(dup.getObligationSet(), dup);
}
} | java |
public void addObligation(final Obligation obligation, int basicBlockId) throws ObligationAcquiredOrReleasedInLoopException {
Map<ObligationSet, State> updatedStateMap = new HashMap<>();
if (stateMap.isEmpty()) {
State s = new State(factory);
s.getObligationSet().add(obligation);
updatedStateMap.put(s.getObligationSet(), s);
} else {
for (State state : stateMap.values()) {
checkCircularity(state, obligation, basicBlockId);
state.getObligationSet().add(obligation);
updatedStateMap.put(state.getObligationSet(), state);
}
}
replaceMap(updatedStateMap);
} | java |
public void deleteObligation(final Obligation obligation, int basicBlockId)
throws ObligationAcquiredOrReleasedInLoopException {
Map<ObligationSet, State> updatedStateMap = new HashMap<>();
for (Iterator<State> i = stateIterator(); i.hasNext();) {
State state = i.next();
checkCircularity(state, obligation, basicBlockId);
ObligationSet obligationSet = state.getObligationSet();
obligationSet.remove(obligation);
if (!obligationSet.isEmpty()) {
updatedStateMap.put(obligationSet, state);
}
}
replaceMap(updatedStateMap);
} | java |
private void checkCircularity(State state, Obligation obligation, int basicBlockId)
throws ObligationAcquiredOrReleasedInLoopException {
if (state.getPath().hasComponent(basicBlockId)) {
throw new ObligationAcquiredOrReleasedInLoopException(obligation);
}
} | java |
public List<State> getPrefixStates(Path path) {
List<State> result = new LinkedList<>();
for (State state : stateMap.values()) {
if (state.getPath().isPrefixOf(path)) {
result.add(state);
}
}
return result;
} | java |
private static boolean acquireAnalysisPermitUnlessCancelled(IProgressMonitor monitor) throws InterruptedException {
do {
if (analysisSem.tryAcquire(1, TimeUnit.SECONDS)) {
return true;
}
} while (!monitor.isCanceled());
return false;
} | java |
public void setTimestamp(String timestamp) throws ParseException {
this.analysisTimestamp = new SimpleDateFormat(TIMESTAMP_FORMAT, Locale.ENGLISH).parse(timestamp);
} | java |
public void addBug(BugInstance bug) {
SourceLineAnnotation source = bug.getPrimarySourceLineAnnotation();
PackageStats stat = getPackageStats(source.getPackageName());
stat.addError(bug);
++totalErrors[0];
int priority = bug.getPriority();
if (priority >= 1) {
++totalErrors[Math.min(priority, totalErrors.length - 1)];
}
} | java |
public void clearBugCounts() {
for (int i = 0; i < totalErrors.length; i++) {
totalErrors[i] = 0;
}
for (PackageStats stats : packageStatsMap.values()) {
stats.clearBugCounts();
}
} | java |
public void transformSummaryToHTML(Writer htmlWriter) throws IOException, TransformerException {
ByteArrayOutputStream summaryOut = new ByteArrayOutputStream(8096);
reportSummary(summaryOut);
StreamSource in = new StreamSource(new ByteArrayInputStream(summaryOut.toByteArray()));
StreamResult out = new StreamResult(htmlWriter);
InputStream xslInputStream = this.getClass().getClassLoader().getResourceAsStream("summary.xsl");
if (xslInputStream == null) {
throw new IOException("Could not load summary stylesheet");
}
StreamSource xsl = new StreamSource(xslInputStream);
TransformerFactory tf = TransformerFactory.newInstance();
Transformer transformer = tf.newTransformer(xsl);
transformer.transform(in, out);
Reader rdr = in.getReader();
if (rdr != null) {
rdr.close();
}
htmlWriter.close();
InputStream is = xsl.getInputStream();
if (is != null) {
is.close();
}
} | java |
JPopupMenu createBugPopupMenu() {
JPopupMenu popupMenu = new JPopupMenu();
JMenuItem filterMenuItem = MainFrameHelper.newJMenuItem("menu.filterBugsLikeThis", "Filter bugs like this");
filterMenuItem.addActionListener(evt -> {
new NewFilterFromBug(new FilterFromBugPicker(currentSelectedBugLeaf.getBug(),
Arrays.asList(mainFrame.getAvailableSortables())),
new ApplyNewFilter(mainFrame.getProject().getSuppressionFilter(),
PreferencesFrame.getInstance(),
new FilterActivityNotifier()));
mainFrame.setProjectChanged(true);
mainFrame.getTree().setSelectionRow(0); // Selects the top of the Jtree so the CommentsArea syncs up.
});
popupMenu.add(filterMenuItem);
return popupMenu;
} | java |
JPopupMenu createBranchPopUpMenu() {
JPopupMenu popupMenu = new JPopupMenu();
JMenuItem filterMenuItem = MainFrameHelper.newJMenuItem("menu.filterTheseBugs", "Filter these bugs");
filterMenuItem.addActionListener(evt -> {
// TODO This code does a smarter version of filtering that is
// only possible for branches, and does so correctly
// However, it is still somewhat of a hack, because if we ever
// add more tree listeners than simply the bugtreemodel,
// They will not be called by this code. Using FilterActivity to
// notify all listeners will however destroy any
// benefit of using the smarter deletion method.
try {
int startCount;
TreePath path = MainFrame.getInstance().getTree().getSelectionPath();
TreePath deletePath = path;
startCount = ((BugAspects) (path.getLastPathComponent())).getCount();
int count = ((BugAspects) (path.getParentPath().getLastPathComponent())).getCount();
while (count == startCount) {
deletePath = deletePath.getParentPath();
if (deletePath.getParentPath() == null)// We are at the
// top of the
// tree, don't
// let this be
// removed,
// rebuild tree
// from root.
{
Matcher m1 = mainFrame.getCurrentSelectedBugAspects().getMatcher();
Filter suppressionFilter1 = MainFrame.getInstance().getProject().getSuppressionFilter();
suppressionFilter1.addChild(m1);
PreferencesFrame.getInstance().updateFilterPanel();
FilterActivity.notifyListeners(FilterListener.Action.FILTERING, null);
return;
}
count = ((BugAspects) (deletePath.getParentPath().getLastPathComponent())).getCount();
}
/*
* deletePath should now be a path to the highest ancestor
* branch with the same number of elements as the branch to
* be deleted in other words, the branch that we actually
* have to remove in order to correctly remove the selected
* branch.
*/
BugTreeModel model = MainFrame.getInstance().getBugTreeModel();
TreeModelEvent event = new TreeModelEvent(mainFrame, deletePath.getParentPath(),
new int[] { model.getIndexOfChild(deletePath.getParentPath().getLastPathComponent(),
deletePath.getLastPathComponent()) }, new Object[] { deletePath.getLastPathComponent() });
Matcher m2 = mainFrame.getCurrentSelectedBugAspects().getMatcher();
Filter suppressionFilter2 = MainFrame.getInstance().getProject().getSuppressionFilter();
suppressionFilter2.addChild(m2);
PreferencesFrame.getInstance().updateFilterPanel();
model.sendEvent(event, BugTreeModel.TreeModification.REMOVE);
// FilterActivity.notifyListeners(FilterListener.Action.FILTERING,
// null);
mainFrame.setProjectChanged(true);
MainFrame.getInstance().getTree().setSelectionRow(0);// Selects
// the
// top
// of
// the
// Jtree
// so
// the
// CommentsArea
// syncs
// up.
} catch (RuntimeException e) {
MainFrame.getInstance().showMessageDialog("Unable to create filter: " + e.getMessage());
}
});
popupMenu.add(filterMenuItem);
return popupMenu;
} | java |
public void accumulateBug(BugInstance bug, SourceLineAnnotation sourceLine) {
if (sourceLine == null) {
throw new NullPointerException("Missing source line");
}
int priority = bug.getPriority();
if (!performAccumulation) {
bug.addSourceLine(sourceLine);
} else {
bug.setPriority(Priorities.NORMAL_PRIORITY);
}
lastBug = bug;
lastSourceLine = sourceLine;
Data d = map.get(bug);
if (d == null) {
String hash = bug.getInstanceHash();
BugInstance conflictingBug = hashes.get(hash);
if (conflictingBug != null) {
if (conflictingBug.getPriority() <= priority) {
return;
}
map.remove(conflictingBug);
}
d = new Data(priority, sourceLine);
map.put(bug, d);
hashes.put(hash, bug);
} else if (d.priority > priority) {
if (d.priority >= Priorities.LOW_PRIORITY) {
reportBug(bug, d);
d.allSource.clear();
}
d.priority = priority;
d.primarySource = sourceLine;
} else if (priority >= Priorities.LOW_PRIORITY && priority > d.priority) {
bug.setPriority(priority);
reporter.reportBug(bug);
return;
}
d.allSource.add(sourceLine);
} | java |
public void accumulateBug(BugInstance bug, BytecodeScanningDetector visitor) {
SourceLineAnnotation source = SourceLineAnnotation.fromVisitedInstruction(visitor);
accumulateBug(bug, source);
} | java |
public void reportAccumulatedBugs() {
for (Map.Entry<BugInstance, Data> e : map.entrySet()) {
BugInstance bug = e.getKey();
Data d = e.getValue();
reportBug(bug, d);
}
clearBugs();
} | java |
public void rebuild() {
if (TRACE) {
System.out.println("rebuilding bug tree model");
}
NewFilterFromBug.closeAll();
// If this thread is not interrupting a previous thread, set the paths
// to be opened when the new tree is complete
// If the thread is interrupting another thread, don't do this, because
// you don't have the tree with the correct paths selected
// As of now, it should be impossible to interrupt a rebuilding thread,
// in another version this may change, so this if statement check is
// left in, even though it should always be true.
if (rebuildingThread == null) {
setOldSelectedBugs();
}
Debug.println("Please Wait called right before starting rebuild thread");
mainFrame.acquireDisplayWait();
rebuildingThread = edu.umd.cs.findbugs.util.Util.runInDameonThread(new Runnable() {
BugTreeModel newModel;
@Override
public void run() {
try {
newModel = new BugTreeModel(BugTreeModel.this);
newModel.listeners = listeners;
newModel.resetData();
newModel.bugSet.sortList();
} finally {
rebuildingThread = null;
SwingUtilities.invokeLater(() -> {
if (newModel != null) {
JTree newTree = new JTree(newModel);
newModel.tree = newTree;
mainFrame.mainFrameTree.newTree(newTree, newModel);
mainFrame.releaseDisplayWait();
}
getOffListenerList();
});
}
}
}, "Rebuilding thread");
} | java |
public static Collection<TypeQualifierValue<?>> getComplementaryExclusiveTypeQualifierValue(TypeQualifierValue<?> tqv) {
assert tqv.isExclusiveQualifier();
LinkedList<TypeQualifierValue<?>> result = new LinkedList<>();
for (TypeQualifierValue<?> t : instance.get().allKnownTypeQualifiers) {
//
// Any TypeQualifierValue with the same
// annotation class but a different value is a complementary
// type qualifier.
//
if (t.typeQualifier.equals(tqv.typeQualifier) && !Objects.equals(t.value, tqv.value)) {
result.add(t);
}
}
return result;
} | java |
private int getIntValue(int stackDepth, int defaultValue) {
if (stack.getStackDepth() < stackDepth) {
return defaultValue;
}
OpcodeStack.Item it = stack.getStackItem(stackDepth);
Object value = it.getConstant();
if (!(value instanceof Integer)) {
return defaultValue;
}
return ((Number) value).intValue();
} | java |
public static synchronized SortedMap<String, String> getContributedDetectors() {
if (contributedDetectors != null) {
return new TreeMap<>(contributedDetectors);
}
TreeMap<String, String> set = new TreeMap<>();
IExtensionRegistry registry = Platform.getExtensionRegistry();
for (IConfigurationElement configElt : registry.getConfigurationElementsFor(EXTENSION_POINT_ID)) {
addContribution(set, configElt);
}
contributedDetectors = set;
return new TreeMap<>(contributedDetectors);
} | java |
@CheckForNull
private static String resolvePluginClassesDir(String bundleName, File sourceDir) {
if (sourceDir.listFiles() == null) {
FindbugsPlugin.getDefault().logException(new IllegalStateException("No files in the bundle!"),
"Failed to create temporary detector package for bundle " + sourceDir);
return null;
}
String outputDir = getBuildDirectory(bundleName, sourceDir);
if (outputDir.length() == 0) {
FindbugsPlugin.getDefault().logException(new IllegalStateException("No output directory in build.properties"),
"No output directory in build.properties " + sourceDir);
return null;
}
File classDir = new File(sourceDir, outputDir);
if (classDir.listFiles() == null) {
FindbugsPlugin.getDefault().logException(new IllegalStateException("No files in the bundle output dir!"),
"Failed to create temporary detector package for bundle " + sourceDir);
return null;
}
File etcDir = new File(sourceDir, "etc");
if (etcDir.listFiles() == null) {
FindbugsPlugin.getDefault().logException(new IllegalStateException("No files in the bundle etc dir!"),
"Failed to create temporary detector package for bundle " + sourceDir);
return null;
}
return classDir.getAbsolutePath();
} | java |
public static LocalVariableAnnotation getParameterLocalVariableAnnotation(Method method, int local) {
LocalVariableAnnotation lva = getLocalVariableAnnotation(method, local, 0, 0);
if (lva.isNamed()) {
lva.setDescription(LocalVariableAnnotation.PARAMETER_NAMED_ROLE);
} else {
lva.setDescription(LocalVariableAnnotation.PARAMETER_ROLE);
}
return lva;
} | java |
@Override
public char next() {
++docPos;
if (docPos < segmentEnd || segmentEnd >= doc.getLength()) {
return text.next();
}
try {
doc.getText(segmentEnd, doc.getLength() - segmentEnd, text);
} catch (BadLocationException e) {
throw new RuntimeException(e);
}
segmentEnd += text.count;
return text.current();
} | java |
public static String rewriteMethodSignature(ClassNameRewriter classNameRewriter, String methodSignature) {
if (classNameRewriter != IdentityClassNameRewriter.instance()) {
SignatureParser parser = new SignatureParser(methodSignature);
StringBuilder buf = new StringBuilder();
buf.append('(');
for (Iterator<String> i = parser.parameterSignatureIterator(); i.hasNext();) {
buf.append(rewriteSignature(classNameRewriter, i.next()));
}
buf.append(')');
buf.append(rewriteSignature(classNameRewriter, parser.getReturnTypeSignature()));
methodSignature = buf.toString();
}
return methodSignature;
} | java |
public static String rewriteSignature(ClassNameRewriter classNameRewriter, String signature) {
if (classNameRewriter != IdentityClassNameRewriter.instance() && signature.startsWith("L")) {
String className = signature.substring(1, signature.length() - 1).replace('/', '.');
className = classNameRewriter.rewriteClassName(className);
signature = "L" + className.replace('.', '/') + ";";
}
return signature;
} | java |
public static MethodAnnotation convertMethodAnnotation(ClassNameRewriter classNameRewriter, MethodAnnotation annotation) {
if (classNameRewriter != IdentityClassNameRewriter.instance()) {
annotation = new MethodAnnotation(classNameRewriter.rewriteClassName(annotation.getClassName()),
annotation.getMethodName(), rewriteMethodSignature(classNameRewriter, annotation.getMethodSignature()),
annotation.isStatic());
}
return annotation;
} | java |
public static FieldAnnotation convertFieldAnnotation(ClassNameRewriter classNameRewriter, FieldAnnotation annotation) {
if (classNameRewriter != IdentityClassNameRewriter.instance()) {
annotation = new FieldAnnotation(classNameRewriter.rewriteClassName(annotation.getClassName()),
annotation.getFieldName(), rewriteSignature(classNameRewriter, annotation.getFieldSignature()),
annotation.isStatic());
}
return annotation;
} | java |
private InterproceduralCallGraphVertex findVertex(XMethod xmethod) {
InterproceduralCallGraphVertex vertex;
vertex = callGraph.lookupVertex(xmethod.getMethodDescriptor());
if (vertex == null) {
vertex = new InterproceduralCallGraphVertex();
vertex.setXmethod(xmethod);
callGraph.addVertex(vertex);
}
return vertex;
} | java |
public boolean hasComponent(int blockId) {
for (int i = 0; i < length; i++) {
if (blockIdList[i] == blockId) {
return true;
}
}
return false;
} | java |
public void copyFrom(Path other) {
grow(other.length - 1);
System.arraycopy(other.blockIdList, 0, this.blockIdList, 0, other.length);
this.length = other.length;
this.cachedHashCode = other.cachedHashCode;
} | java |
public void acceptVisitor(CFG cfg, PathVisitor visitor) {
if (getLength() > 0) {
BasicBlock startBlock = cfg.lookupBlockByLabel(getBlockIdAt(0));
acceptVisitorStartingFromLocation(cfg, visitor, startBlock, startBlock.getFirstInstruction());
}
} | java |
public void acceptVisitorStartingFromLocation(CFG cfg, PathVisitor visitor, BasicBlock startBlock,
InstructionHandle startHandle) {
// Find the start block in the path
int index;
for (index = 0; index < getLength(); index++) {
if (getBlockIdAt(index) == startBlock.getLabel()) {
break;
}
}
assert index < getLength();
Iterator<InstructionHandle> i = startBlock.instructionIterator();
// Position iterator at start instruction handle
if (startHandle != startBlock.getFirstInstruction()) {
while (i.hasNext()) {
InstructionHandle handle = i.next();
if (handle.getNext() == startHandle) {
break;
}
}
}
BasicBlock basicBlock = startBlock;
while (true) {
// visit block
visitor.visitBasicBlock(basicBlock);
// visit instructions in block
while (i.hasNext()) {
visitor.visitInstructionHandle(i.next());
}
// end of path?
index++;
if (index >= getLength()) {
break;
}
// visit edge
BasicBlock next = cfg.lookupBlockByLabel(getBlockIdAt(index));
Edge edge = cfg.lookupEdge(basicBlock, next);
assert edge != null;
visitor.visitEdge(edge);
// continue to next block
basicBlock = next;
i = basicBlock.instructionIterator();
}
} | java |
public boolean isPrefixOf(Path path) {
if (this.getLength() > path.getLength()) {
return false;
}
for (int i = 0; i < getLength(); i++) {
if (this.getBlockIdAt(i) != path.getBlockIdAt(i)) {
return false;
}
}
return true;
} | java |
private void produce(IsNullValue value) {
IsNullValueFrame frame = getFrame();
frame.pushValue(value);
newValueOnTOS();
} | java |
private void handleInvoke(InvokeInstruction obj) {
if (obj instanceof INVOKEDYNAMIC) {
// should not happen
return;
}
Type returnType = obj.getReturnType(getCPG());
Location location = getLocation();
if (trackValueNumbers) {
try {
ValueNumberFrame vnaFrame = vnaDataflow.getFactAtLocation(location);
Set<ValueNumber> nonnullParameters = UnconditionalValueDerefAnalysis.checkAllNonNullParams(location, vnaFrame,
cpg, null, null, typeDataflow);
if (!nonnullParameters.isEmpty()) {
IsNullValue kaboom = IsNullValue.noKaboomNonNullValue(location);
IsNullValueFrame frame = getFrame();
for (ValueNumber vn : nonnullParameters) {
IsNullValue knownValue = frame.getKnownValue(vn);
if (knownValue != null && !knownValue.isDefinitelyNotNull()) {
if (knownValue.isDefinitelyNull()) {
frame.setTop();
return;
}
frame.setKnownValue(vn, kaboom);
}
for (int i = 0; i < vnaFrame.getNumSlots(); i++) {
IsNullValue value = frame.getValue(i);
if (vnaFrame.getValue(i).equals(vn) && !value.isDefinitelyNotNull()) {
frame.setValue(i, kaboom);
if (value.isDefinitelyNull()) {
frame.setTop();
return;
}
}
}
}
}
} catch (DataflowAnalysisException e) {
AnalysisContext.logError("Error looking up nonnull parameters for invoked method", e);
}
}
// Determine if we are going to model the return value of this call.
boolean modelCallReturnValue = MODEL_NONNULL_RETURN && returnType instanceof ReferenceType;
if (!modelCallReturnValue) {
// Normal case: Assume returned values are non-reporting non-null.
handleNormalInstruction(obj);
} else {
// Special case: some special value is pushed on the stack for the
// return value
IsNullValue result = null;
TypeFrame typeFrame;
try {
typeFrame = typeDataflow.getFactAtLocation(location);
Set<XMethod> targetSet = Hierarchy2.resolveMethodCallTargets(obj, typeFrame, cpg);
if (targetSet.isEmpty()) {
XMethod calledMethod = XFactory.createXMethod(obj, getCPG());
result = getReturnValueNullness(calledMethod);
} else {
for (XMethod calledMethod : targetSet) {
IsNullValue pushValue = getReturnValueNullness(calledMethod);
if (result == null) {
result = pushValue;
} else {
result = IsNullValue.merge(result, pushValue);
}
}
}
} catch (DataflowAnalysisException e) {
result = IsNullValue.nonReportingNotNullValue();
} catch (ClassNotFoundException e) {
result = IsNullValue.nonReportingNotNullValue();
}
modelInstruction(obj, getNumWordsConsumed(obj), getNumWordsProduced(obj), result);
newValueOnTOS();
}
} | java |
private boolean checkForKnownValue(Instruction obj) {
if (trackValueNumbers) {
try {
// See if the value number loaded here is a known value
ValueNumberFrame vnaFrameAfter = vnaDataflow.getFactAfterLocation(getLocation());
if (vnaFrameAfter.isValid()) {
ValueNumber tosVN = vnaFrameAfter.getTopValue();
IsNullValue knownValue = getFrame().getKnownValue(tosVN);
if (knownValue != null) {
// System.out.println("Produce known value!");
// The value produced by this instruction is known.
// Push the known value.
modelNormalInstruction(obj, getNumWordsConsumed(obj), 0);
produce(knownValue);
return true;
}
}
} catch (DataflowAnalysisException e) {
// Ignore...
}
}
return false;
} | java |
public static String trimComma(String s) {
if (s.endsWith(",")) {
s = s.substring(0, s.length() - 1);
}
return s;
} | java |
public static boolean initializeUnescapePattern() {
if (paternIsInitialized == true) {
return true;
}
synchronized (unescapeInitLockObject) {
if (paternIsInitialized == true) {
return true;
}
try {
unescapePattern = Pattern.compile(unicodeUnescapeMatchExpression);
} catch (PatternSyntaxException pse) {
/*
* the pattern is compiled from a final string, so this
* exception should never be thrown
*/
System.err.println("Imposible error: " + "static final regular expression pattern "
+ "failed to compile. Exception: " + pse.toString());
return false;
}
paternIsInitialized = true;
}
return true;
} | java |
public String getReturnTypeSignature() {
int endOfParams = signature.lastIndexOf(')');
if (endOfParams < 0) {
throw new IllegalArgumentException("Bad method signature: " + signature);
}
return signature.substring(endOfParams + 1);
} | java |
public int getNumParameters() {
int count = 0;
for (Iterator<String> i = parameterSignatureIterator(); i.hasNext();) {
i.next();
++count;
}
return count;
} | java |
public static boolean compareSignatures(String plainSignature, String genericSignature) {
GenericSignatureParser plainParser = new GenericSignatureParser(plainSignature);
GenericSignatureParser genericParser = new GenericSignatureParser(genericSignature);
return plainParser.getNumParameters() == genericParser.getNumParameters();
} | java |
public static String findCodeBaseInClassPath(Pattern codeBaseNamePattern, String classPath) {
if (classPath == null) {
return null;
}
StringTokenizer tok = new StringTokenizer(classPath, File.pathSeparator);
while (tok.hasMoreTokens()) {
String t = tok.nextToken();
File f = new File(t);
Matcher m = codeBaseNamePattern.matcher(f.getName());
if (m.matches()) {
return t;
}
}
return null;
} | java |
public static void skipFully(InputStream in, long bytes) throws IOException {
if (bytes < 0) {
throw new IllegalArgumentException("Can't skip " + bytes + " bytes");
}
long remaining = bytes;
while (remaining > 0) {
long skipped = in.skip(remaining);
if (skipped <= 0) {
throw new EOFException("Reached EOF while trying to skip a total of " + bytes);
}
remaining -= skipped;
}
} | java |
public static Type fromExceptionSet(ExceptionSet exceptionSet) throws ClassNotFoundException {
Type commonSupertype = exceptionSet.getCommonSupertype();
if (commonSupertype.getType() != Const.T_OBJECT) {
return commonSupertype;
}
ObjectType exceptionSupertype = (ObjectType) commonSupertype;
String className = exceptionSupertype.getClassName();
if ("java.lang.Throwable".equals(className)) {
return exceptionSupertype;
}
return new ExceptionObjectType(className, exceptionSet);
} | java |
public String parseNext() {
StringBuilder result = new StringBuilder();
if (signature.startsWith("[")) {
int dimensions = 0;
do {
++dimensions;
signature = signature.substring(1);
} while (signature.charAt(0) == '[');
result.append(parseNext());
while (dimensions-- > 0) {
result.append("[]");
}
} else if (signature.startsWith("L")) {
int semi = signature.indexOf(';');
if (semi < 0) {
throw new IllegalStateException("missing semicolon in signature " + signature);
}
result.append(signature.substring(1, semi).replace('/', '.'));
signature = signature.substring(semi + 1);
} else {
switch (signature.charAt(0)) {
case 'B':
result.append("byte");
break;
case 'C':
result.append("char");
break;
case 'D':
result.append("double");
break;
case 'F':
result.append("float");
break;
case 'I':
result.append("int");
break;
case 'J':
result.append("long");
break;
case 'S':
result.append("short");
break;
case 'Z':
result.append("boolean");
break;
case 'V':
result.append("void");
break;
default:
throw new IllegalArgumentException("bad signature " + signature);
}
skip();
}
return result.toString();
} | java |
static public void reportMissingClass(ClassNotFoundException e) {
requireNonNull(e, "argument is null");
String missing = AbstractBugReporter.getMissingClassName(e);
if (skipReportingMissingClass(missing)) {
return;
}
if (!analyzingApplicationClass()) {
return;
}
RepositoryLookupFailureCallback lookupFailureCallback = getCurrentLookupFailureCallback();
if (lookupFailureCallback != null) {
lookupFailureCallback.reportMissingClass(e);
}
} | java |
public final void loadInterproceduralDatabases() {
loadPropertyDatabase(getFieldStoreTypeDatabase(), FieldStoreTypeDatabase.DEFAULT_FILENAME, "field store type database");
loadPropertyDatabase(getUnconditionalDerefParamDatabase(), UNCONDITIONAL_DEREF_DB_FILENAME,
"unconditional param deref database");
loadPropertyDatabase(getReturnValueNullnessPropertyDatabase(), NONNULL_RETURN_DB_FILENAME, "nonnull return db database");
} | java |
public final void setDatabaseInputDir(String databaseInputDir) {
if (DEBUG) {
System.out.println("Setting database input directory: " + databaseInputDir);
}
this.databaseInputDir = databaseInputDir;
} | java |
public final void setDatabaseOutputDir(String databaseOutputDir) {
if (DEBUG) {
System.out.println("Setting database output directory: " + databaseOutputDir);
}
this.databaseOutputDir = databaseOutputDir;
} | java |
public <DatabaseType extends PropertyDatabase<KeyType, Property>, KeyType extends FieldOrMethodDescriptor, Property> void storePropertyDatabase(
DatabaseType database, String fileName, String description) {
try {
File dbFile = new File(getDatabaseOutputDir(), fileName);
if (DEBUG) {
System.out.println("Writing " + description + " to " + dbFile.getPath() + "...");
}
database.writeToFile(dbFile.getPath());
} catch (IOException e) {
getLookupFailureCallback().logError("Error writing " + description, e);
}
} | java |
public static void setCurrentAnalysisContext(AnalysisContext analysisContext) {
currentAnalysisContext.set(analysisContext);
if (Global.getAnalysisCache() != null) {
currentXFactory.set(new XFactory());
}
} | java |
public ClassContext getClassContext(JavaClass javaClass) {
// This is a bit silly since we're doing an unnecessary
// ClassDescriptor->JavaClass lookup.
// However, we can be assured that it will succeed.
ClassDescriptor classDescriptor = DescriptorFactory.instance().getClassDescriptor(
ClassName.toSlashedClassName(javaClass.getClassName()));
try {
return Global.getAnalysisCache().getClassAnalysis(ClassContext.class, classDescriptor);
} catch (CheckedAnalysisException e) {
IllegalStateException ise = new IllegalStateException("Could not get ClassContext for JavaClass");
ise.initCause(e);
throw ise;
}
} | java |
public void copyFrom(BlockType other) {
this.isValid = other.isValid;
this.isTop = other.isTop;
if (isValid) {
this.depth = other.depth;
this.clear();
this.or(other);
}
} | java |
public boolean sameAs(BlockType other) {
if (!this.isValid) {
return !other.isValid && (this.isTop == other.isTop);
} else {
if (!other.isValid) {
return false;
} else {
// Both facts are valid
if (this.depth != other.depth) {
return false;
}
// Compare bits
for (int i = 0; i < this.depth; ++i) {
if (this.get(i) != other.get(i)) {
return false;
}
}
return true;
}
}
} | java |
public void mergeWith(BlockType other) {
if (this.isTop() || other.isBottom()) {
copyFrom(other);
} else if (isValid()) {
// To merge, we take the common prefix
int pfxLen = Math.min(this.depth, other.depth);
int commonLen;
for (commonLen = 0; commonLen < pfxLen; ++commonLen) {
if (this.get(commonLen) != other.get(commonLen)) {
break;
}
}
this.depth = commonLen;
}
} | java |
public static synchronized Map<String, List<QuickFixContribution>> getContributedQuickFixes() {
if (contributedQuickFixes != null) {
return contributedQuickFixes;
}
HashMap<String, List<QuickFixContribution>> set = new HashMap<>();
IExtensionRegistry registry = Platform.getExtensionRegistry();
for (IConfigurationElement configElt : registry.getConfigurationElementsFor(EXTENSION_POINT_ID)) {
addContribution(set, configElt);
}
Set<Entry<String, List<QuickFixContribution>>> entrySet = set.entrySet();
for (Entry<String, List<QuickFixContribution>> entry : entrySet) {
entry.setValue(Collections.unmodifiableList(entry.getValue()));
}
contributedQuickFixes = Collections.unmodifiableMap(set);
return contributedQuickFixes;
} | java |
public static void getDirectApplications(Set<TypeQualifierAnnotation> result, XMethod o, int parameter) {
Collection<AnnotationValue> values = getDirectAnnotation(o, parameter);
for (AnnotationValue v : values) {
constructTypeQualifierAnnotation(result, v);
}
} | java |
public static void getDirectApplications(Set<TypeQualifierAnnotation> result, AnnotatedObject o, ElementType e) {
if (!o.getElementType().equals(e)) {
return;
}
Collection<AnnotationValue> values = getDirectAnnotation(o);
for (AnnotationValue v : values) {
constructTypeQualifierAnnotation(result, v);
}
} | java |
public static TypeQualifierAnnotation constructTypeQualifierAnnotation(AnnotationValue v) {
assert v != null;
EnumValue whenValue = (EnumValue) v.getValue("when");
When when = whenValue == null ? When.ALWAYS : When.valueOf(whenValue.value);
ClassDescriptor annotationClass = v.getAnnotationClass();
TypeQualifierValue<?> tqv = TypeQualifierValue.getValue(annotationClass, v.getValue("value"));
TypeQualifierAnnotation tqa = TypeQualifierAnnotation.getValue(tqv, when);
return tqa;
} | java |
public static void constructTypeQualifierAnnotation(Set<TypeQualifierAnnotation> set, AnnotationValue v) {
assert set != null;
TypeQualifierAnnotation tqa = constructTypeQualifierAnnotation(v);
set.add(tqa);
} | java |
private static @CheckForNull
TypeQualifierAnnotation findMatchingTypeQualifierAnnotation(Collection<TypeQualifierAnnotation> typeQualifierAnnotations,
TypeQualifierValue<?> typeQualifierValue) {
for (TypeQualifierAnnotation typeQualifierAnnotation : typeQualifierAnnotations) {
if (typeQualifierAnnotation.typeQualifier.equals(typeQualifierValue)) {
return typeQualifierAnnotation;
}
}
return null;
} | java |
private static @CheckForNull
TypeQualifierAnnotation getDefaultAnnotation(AnnotatedObject o, TypeQualifierValue<?> typeQualifierValue, ElementType elementType) {
//
// Try to find a default annotation using the standard JSR-305
// default annotation mechanism.
//
TypeQualifierAnnotation result;
Collection<AnnotationValue> values = TypeQualifierResolver.resolveTypeQualifierDefaults(o.getAnnotations(), elementType);
TypeQualifierAnnotation tqa = extractAnnotation(values, typeQualifierValue);
if (tqa != null) {
// System.out.println("Found default annotation of " + tqa +
// " for element " + elementType + " in " + o);
return tqa;
}
//
// Try one of the FindBugs-specific default annotation mechanisms.
//
if ((result = checkFindBugsDefaultAnnotation(FindBugsDefaultAnnotations.DEFAULT_ANNOTATION, o, typeQualifierValue)) != null) {
return result;
}
switch (elementType) {
case FIELD:
result = checkFindBugsDefaultAnnotation(FindBugsDefaultAnnotations.DEFAULT_ANNOTATION_FOR_FIELDS, o,
typeQualifierValue);
break;
case METHOD:
result = checkFindBugsDefaultAnnotation(FindBugsDefaultAnnotations.DEFAULT_ANNOTATION_FOR_METHODS, o,
typeQualifierValue);
break;
case PARAMETER:
result = checkFindBugsDefaultAnnotation(FindBugsDefaultAnnotations.DEFAULT_ANNOTATION_FOR_PARAMETERS, o,
typeQualifierValue);
break;
default:
// ignore
break;
}
// Try out default JDT (Eclipse) annotations
if(result == null){
AnnotationValue annotationValue = o.getAnnotation(TypeQualifierResolver.eclipseNonNullByDefault);
if(annotationValue != null){
Collection<AnnotationValue> resolvedTypeQualifiers = TypeQualifierResolver.resolveTypeQualifiers(annotationValue);
tqa = extractAnnotation(resolvedTypeQualifiers, typeQualifierValue);
if(tqa != null){
return tqa;
}
}
}
return result;
} | java |
private static TypeQualifierAnnotation getDirectTypeQualifierAnnotation(AnnotatedObject o,
TypeQualifierValue<?> typeQualifierValue) {
TypeQualifierAnnotation result;
Set<TypeQualifierAnnotation> applications = new HashSet<>();
getDirectApplications(applications, o, o.getElementType());
result = findMatchingTypeQualifierAnnotation(applications, typeQualifierValue);
return result;
} | java |
public static TypeQualifierAnnotation getInheritedTypeQualifierAnnotation(XMethod o, TypeQualifierValue<?> typeQualifierValue) {
assert !o.isStatic();
ReturnTypeAnnotationAccumulator accumulator = new ReturnTypeAnnotationAccumulator(typeQualifierValue, o);
try {
AnalysisContext.currentAnalysisContext().getSubtypes2().traverseSupertypesDepthFirst(o.getClassDescriptor(), accumulator);
TypeQualifierAnnotation result = accumulator.getResult().getEffectiveTypeQualifierAnnotation();
if (result == null && accumulator.overrides()) {
return TypeQualifierAnnotation.OVERRIDES_BUT_NO_ANNOTATION;
}
return result;
} catch (ClassNotFoundException e) {
AnalysisContext.currentAnalysisContext().getLookupFailureCallback().reportMissingClass(e);
return null;
}
} | java |
public static @CheckForNull @CheckReturnValue
TypeQualifierAnnotation getDirectTypeQualifierAnnotation(XMethod xmethod, int parameter, TypeQualifierValue<?> typeQualifierValue) {
XMethod bridge = xmethod.bridgeTo();
if (bridge != null) {
xmethod = bridge;
}
Set<TypeQualifierAnnotation> applications = new HashSet<>();
getDirectApplications(applications, xmethod, parameter);
if (DEBUG_METHOD != null && DEBUG_METHOD.equals(xmethod.getName())) {
System.out.println(" Direct applications are: " + applications);
}
return findMatchingTypeQualifierAnnotation(applications, typeQualifierValue);
} | java |
public static @CheckForNull
TypeQualifierAnnotation getInheritedTypeQualifierAnnotation(XMethod xmethod, int parameter,
TypeQualifierValue<?> typeQualifierValue) {
assert !xmethod.isStatic();
ParameterAnnotationAccumulator accumulator = new ParameterAnnotationAccumulator(typeQualifierValue, xmethod, parameter);
try {
AnalysisContext.currentAnalysisContext().getSubtypes2().traverseSupertypesDepthFirst(xmethod.getClassDescriptor(), accumulator);
TypeQualifierAnnotation result = accumulator.getResult().getEffectiveTypeQualifierAnnotation();
if (result == null && accumulator.overrides()) {
return TypeQualifierAnnotation.OVERRIDES_BUT_NO_ANNOTATION;
}
return result;
} catch (ClassNotFoundException e) {
AnalysisContext.currentAnalysisContext().getLookupFailureCallback().reportMissingClass(e);
return null;
}
} | java |
private void setSorterCheckBoxes() {
SorterTableColumnModel sorter = MainFrame.getInstance().getSorter();
for (SortableCheckBox c : checkBoxSortList) {
c.setSelected(sorter.isShown(c.sortable));
}
} | java |
public static MethodAnnotation fromVisitedMethod(PreorderVisitor visitor) {
String className = visitor.getDottedClassName();
MethodAnnotation result = new MethodAnnotation(className, visitor.getMethodName(), visitor.getMethodSig(), visitor
.getMethod().isStatic());
// Try to find the source lines for the method
SourceLineAnnotation srcLines = SourceLineAnnotation.fromVisitedMethod(visitor);
result.setSourceLines(srcLines);
return result;
} | java |
public static MethodAnnotation fromCalledMethod(DismantleBytecode visitor) {
String className = visitor.getDottedClassConstantOperand();
String methodName = visitor.getNameConstantOperand();
String methodSig = visitor.getSigConstantOperand();
if (visitor instanceof OpcodeStackDetector && visitor.getOpcode() != Const.INVOKESTATIC) {
int params = PreorderVisitor.getNumberArguments(methodSig);
OpcodeStackDetector oVisitor = (OpcodeStackDetector) visitor;
if (!oVisitor.getStack().isTop() && oVisitor.getStack().getStackDepth() > params) {
OpcodeStack.Item item = oVisitor.getStack().getStackItem(params);
String cName = ClassName.fromFieldSignature(item.getSignature());
if (cName != null) {
className = cName;
}
}
}
return fromCalledMethod(className, methodName, methodSig, visitor.getOpcode() == Const.INVOKESTATIC);
} | java |
public static MethodAnnotation fromCalledMethod(String className, String methodName, String methodSig, boolean isStatic) {
MethodAnnotation methodAnnotation = fromForeignMethod(className, methodName, methodSig, isStatic);
methodAnnotation.setDescription(METHOD_CALLED);
return methodAnnotation;
} | java |
public static MethodAnnotation fromXMethod(XMethod xmethod) {
return fromForeignMethod(xmethod.getClassName(), xmethod.getName(), xmethod.getSignature(), xmethod.isStatic());
} | java |
public static MethodAnnotation fromMethodDescriptor(MethodDescriptor methodDescriptor) {
return fromForeignMethod(methodDescriptor.getSlashedClassName(), methodDescriptor.getName(),
methodDescriptor.getSignature(), methodDescriptor.isStatic());
} | java |
public void execute() throws CheckedAnalysisException, IOException, InterruptedException {
File dir = new File(rootSourceDirectory);
if (!dir.isDirectory()) {
throw new IOException("Path " + rootSourceDirectory + " is not a directory");
}
// Find all directories underneath the root source directory
progress.startRecursiveDirectorySearch();
RecursiveFileSearch rfs = new RecursiveFileSearch(rootSourceDirectory, pathname -> pathname.isDirectory());
rfs.search();
progress.doneRecursiveDirectorySearch();
List<String> candidateSourceDirList = rfs.getDirectoriesScanned();
// Build the classpath
IClassFactory factory = ClassFactory.instance();
IClassPathBuilder builder = factory.createClassPathBuilder(errorLogger);
try (IClassPath classPath = buildClassPath(builder, factory)) {
// From the application classes, find the full list of
// fully-qualified source file names.
List<String> fullyQualifiedSourceFileNameList = findFullyQualifiedSourceFileNames(builder, classPath);
// Attempt to find source directories for all source files,
// and add them to the discoveredSourceDirectoryList
if (DEBUG) {
System.out.println("looking for " + fullyQualifiedSourceFileNameList.size() + " files");
}
findSourceDirectoriesForAllSourceFiles(fullyQualifiedSourceFileNameList, candidateSourceDirList);
}
} | java |
public static void addFiles(final Project findBugsProject, File clzDir, final Pattern pat) {
if (clzDir.isDirectory()) {
clzDir.listFiles(new FileCollector(pat, findBugsProject));
}
} | java |
private static void mapResource(WorkItem resource, Map<IProject, List<WorkItem>> projectsMap, boolean checkJavaProject) {
IProject project = resource.getProject();
if (checkJavaProject && !ProjectUtilities.isJavaProject(project)) {
// non java projects: can happen only for changesets
return;
}
List<WorkItem> resources = projectsMap.get(project);
if (resources == null) {
resources = new ArrayList<>();
projectsMap.put(project, resources);
}
// do not need to check for duplicates, cause user cannot select
// the same element twice
if (!containsParents(resources, resource)) {
resources.add(resource);
}
} | java |
@SuppressWarnings("restriction")
public static List<WorkItem> getResources(ChangeSet set) {
if (set != null && !set.isEmpty()) {
IResource[] resources = set.getResources();
List<WorkItem> filtered = new ArrayList<>();
for (IResource resource : resources) {
if (resource.getType() == IResource.FILE && !Util.isJavaArtifact(resource)) {
// Ignore non java files
continue;
}
if (resource.exists()) {
// add only resources which are NOT deleted
filtered.add(new WorkItem(resource));
}
}
return filtered;
}
return EMPTY;
} | java |
@javax.annotation.CheckForNull
public static IResource getResource(Object element) {
if (element instanceof IJavaElement) {
return ((IJavaElement) element).getResource();
}
return Util.getAdapter(IResource.class, element);
} | java |
private ClassDescriptor getNullnessAnnotationClassDescriptor(NullnessAnnotation n) {
if (n == NullnessAnnotation.CHECK_FOR_NULL) {
return JSR305NullnessAnnotations.CHECK_FOR_NULL;
} else if (n == NullnessAnnotation.NONNULL) {
return JSR305NullnessAnnotations.NONNULL;
} else if (n == NullnessAnnotation.NULLABLE) {
return JSR305NullnessAnnotations.NULLABLE;
} else if (n == NullnessAnnotation.UNKNOWN_NULLNESS) {
return JSR305NullnessAnnotations.NULLABLE;
} else {
throw new IllegalArgumentException("Unknown NullnessAnnotation: " + n);
}
} | java |
public void addAll(Collection<BugInstance> collection, boolean updateActiveTime) {
for (BugInstance warning : collection) {
add(warning, updateActiveTime);
}
} | java |
@Override
public AppVersion getCurrentAppVersion() {
return new AppVersion(getSequenceNumber()).setReleaseName(getReleaseName()).setTimestamp(getTimestamp())
.setNumClasses(getProjectStats().getNumClasses()).setCodeSize(getProjectStats().getCodeSize());
} | java |
public void readXML(File file) throws IOException, DocumentException {
project.setCurrentWorkingDirectory(file.getParentFile());
dataSource = file.getAbsolutePath();
InputStream in = progessMonitoredInputStream(file, "Loading analysis");
try {
readXML(in, file);
} catch (IOException e) {
throw newIOException(file, e);
} catch (DocumentException e) {
throw new DocumentException("Failing reading " + file, e);
}
} | java |
@Override
public Document toDocument() {
// if (project == null) throw new NullPointerException("No project");
assert project != null;
DocumentFactory docFactory = new DocumentFactory();
Document document = docFactory.createDocument();
Dom4JXMLOutput treeBuilder = new Dom4JXMLOutput(document);
try {
writeXML(treeBuilder);
} catch (IOException e) {
// Can't happen
}
return document;
} | java |
public static void cloneAll(Collection<BugInstance> dest, Collection<BugInstance> source) {
for (BugInstance obj : source) {
dest.add((BugInstance) obj.clone());
}
} | java |
public static void writeXML(XMLOutput xmlOutput, String elementName, BugAnnotation annotation,
XMLAttributeList attributeList, boolean addMessages) throws IOException {
SourceLineAnnotation src = null;
if (annotation instanceof BugAnnotationWithSourceLines) {
src = ((BugAnnotationWithSourceLines) annotation).getSourceLines();
}
if (addMessages || src != null) {
xmlOutput.openTag(elementName, attributeList);
if (src != null) {
src.writeXML(xmlOutput, addMessages, false);
}
if (addMessages) {
xmlOutput.openTag(BugAnnotation.MESSAGE_TAG);
xmlOutput.writeText(annotation.toString());
xmlOutput.closeTag(BugAnnotation.MESSAGE_TAG);
}
xmlOutput.closeTag(elementName);
} else {
xmlOutput.openCloseTag(elementName, attributeList);
}
} | java |
public InnerClassAccess getInnerClassAccess(String className, String methodName) throws ClassNotFoundException {
Map<String, InnerClassAccess> map = getAccessMapForClass(className);
return map.get(methodName);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.