public int compareClasses(BugCollection lhsCollection, BugCollection rhsCollection, ClassAnnotation lhsClass, ClassAnnotation rhsClass) { if (lhsClass == null || rhsClass == null) { return compareNullElements(lhsClass, rhsClass); } else { return compareClassesByName(lhsCollection, rhsCollection, lhsClass.getClassName(), rhsClass.getClassName()); } }
@Override public int compare(BugInstance lhs, BugInstance rhs) { ClassAnnotation lca = lhs.getPrimaryClass(); ClassAnnotation rca = rhs.getPrimaryClass(); if (lca == null || rca == null) { throw new IllegalStateException("null class annotation: " + lca + "," + rca); } int cmp = lca.getClassName().compareTo(rca.getClassName()); if (cmp != 0) { return cmp; } return lhs.compareTo(rhs); }
@Override public boolean match(BugInstance bugInstance) { if (!super.match(bugInstance)) { return false; } ClassAnnotation primaryClassAnnotation = bugInstance.getPrimaryClass(); if (DEBUG) { System.out.println("Compare " + primaryClassAnnotation + " with " + packageName); } String className = primaryClassAnnotation.getClassName(); return className.startsWith(packageName); } }
/** * Find set of classes referenced in given BugCollection. * * @param bugCollection * @return set of classes referenced in the BugCollection */ private Set<String> buildClassSet(BugCollection bugCollection) { Set<String> classSet = new HashSet<>(); for (Iterator<BugInstance> i = bugCollection.iterator(); i.hasNext();) { BugInstance warning = i.next(); for (Iterator<BugAnnotation> j = warning.annotationIterator(); j.hasNext();) { BugAnnotation annotation = j.next(); if (!(annotation instanceof ClassAnnotation)) { continue; } classSet.add(((ClassAnnotation) annotation).getClassName()); } } return classSet; }
/** * Compare class annotations. * * @param lhs * left hand class annotation * @param rhs * right hand class annotation * @return comparison of the class annotations */ private int compareClassesAllowingNull(ClassAnnotation lhs, ClassAnnotation rhs) { if (lhs == null || rhs == null) { return compareNullElements(lhs, rhs); } String lhsClassName = classNameRewriter.rewriteClassName(lhs.getClassName()); String rhsClassName = classNameRewriter.rewriteClassName(rhs.getClassName()); if (DEBUG) { System.err.println("Comparing " + lhsClassName + " and " + rhsClassName); } int cmp = lhsClassName.compareTo(rhsClassName); if (DEBUG) { System.err.println("\t==> " + cmp); } return cmp; }
@Override protected String formatPackageMember(String key, ClassAnnotation primaryClass) { if ("".equals(key) || "hash".equals(key)) { return className + "." + fieldName; } else if ("givenClass".equals(key)) { String primaryClassName = primaryClass.getClassName(); if (className.equals(primaryClassName)) { return getNameInClass(primaryClass); } else { return shorten(primaryClass.getPackageName(), className) + "." + fieldName; } } else if ("name".equals(key)) { return fieldName; } else if ("fullField".equals(key)) { SignatureConverter converter = new SignatureConverter(fieldSig); StringBuilder result = new StringBuilder(); if (isStatic) { result.append("static "); } result.append(converter.parseNext()); result.append(' '); result.append(className); result.append('.'); result.append(fieldName); return result.toString(); } else { throw new IllegalArgumentException("unknown key " + key); } }
@Override public boolean match(BugInstance bugInstance) { ClassAnnotation classAnnotation = bugInstance.getPrimaryClass(); if (role != null && !"".equals(role)) { for (BugAnnotation a : bugInstance.getAnnotations()) { if (a instanceof ClassAnnotation && role.equals(a.getDescription())) { classAnnotation = (ClassAnnotation) a; break; } } } String bugClassName = classAnnotation.getClassName(); boolean result = className.match(bugClassName); if (DEBUG) { System.out.println("Matching " + bugClassName + " with " + className + ", result = " + result); } return result; }
static ClassAnnotation obfuscate(ClassAnnotation m) { ClassAnnotation result = new ClassAnnotation(hashClass(m.getClassName())); result.setDescription(m.getDescription()); return result; }
return "new " + shorten(primaryClass.getPackageName(), className) + getSignatureInClass(primaryClass); if (className.equals(primaryClass.getClassName())) { return getNameInClass(primaryClass); } else {
if (primaryClass != null && !AnalysisContext.currentAnalysisContext().isApplicationClass(primaryClass.getClassName())) { if (DEBUG) { System.out.println("AbstractBugReporter: Filtering due to non-primary class");
|| (!(primeClass.getClassName().equals(fieldClass) || primeClass.getClassName().equals(methodClass)))) { optionalAdd(result, primeClass);
String fullName = classAnn.getClassName(); int startDot = fullName.lastIndexOf(".") + 1; int endDollar = fullName.indexOf('$'); MethodAnnotation methodAnn = extractBugAnnotation(bugInstance, MethodAnnotation.class); ClassAnnotation classAnn = extractBugAnnotation(bugInstance, ClassAnnotation.class); String fullClassName = classAnn.getClassName(); if (methodAnn == null) { return false; String fullName = classAnn.getClassName().replaceAll("\\.","/").replaceAll("_005f","_").replaceAll("_jsp", ".jsp");
String lhsClassName = classNameRewriter.rewriteClassName(((ClassAnnotation) lhsAnnotation).getClassName()); String rhsClassName = classNameRewriter.rewriteClassName(((ClassAnnotation) rhsAnnotation).getClassName());
@Override public void writeXML(XMLOutput xmlOutput, boolean addMessages, boolean isPrimary) throws IOException { XMLAttributeList attributeList = new XMLAttributeList().addAttribute("classname", getClassName()); if (isPrimary) { attributeList.addAttribute("primary", "true"); } String role = getDescription(); if (!DEFAULT_ROLE.equals(role)) { attributeList.addAttribute("role", role); } xmlOutput.openTag(ELEMENT_NAME, attributeList); getSourceLines().writeXML(xmlOutput, addMessages, false); if (addMessages) { xmlOutput.openTag(BugAnnotation.MESSAGE_TAG); xmlOutput.writeText(this.toString()); xmlOutput.closeTag(BugAnnotation.MESSAGE_TAG); } xmlOutput.closeTag(ELEMENT_NAME); } }
return false; if (classPattern != null && !classPattern.matcher(bug.getPrimaryClass().getClassName()).find()) { return false;
String className = classBugFoundIn.getClassName(); String sourceFile = classBugFoundIn.getSourceFileName(); boolean fixed = sourceFile != null && analyzedSourceFiles.contains(sourceFile) String className = classBugFoundIn.getClassName(); if (origCollection.getProjectStats().getClassStats(className) != null) { newBug.setIntroducedByChangeOfExistingClass(true);
public void toElement(BugInstance bugInstance) { String className = bugInstance.getPrimaryClass().getClassName(); Element element = (Element) root.selectSingleNode(FILE_ELEMENT_NAME + "[@classname='" + className + "']"); if (element == null) { element = root.addElement(FILE_ELEMENT_NAME); element.addAttribute("classname", className); } element = element.addElement(ELEMENT_NAME); element.addAttribute("type", bugInstance.getType()); switch (bugInstance.getPriority()) { case Priorities.EXP_PRIORITY: element.addAttribute("priority", "Experimental"); break; case Priorities.LOW_PRIORITY: element.addAttribute("priority", "Low"); break; case Priorities.NORMAL_PRIORITY: element.addAttribute("priority", "Normal"); break; case Priorities.HIGH_PRIORITY: element.addAttribute("priority", "High"); break; default: assert false; } element.addAttribute("message", xmlEscape(bugInstance.getMessage())); SourceLineAnnotation line = bugInstance.getPrimarySourceLineAnnotation(); element.addAttribute("line", Integer.toString(line.getStartLine())); }
public int compareClasses(BugCollection lhsCollection, BugCollection rhsCollection, ClassAnnotation lhsClass, ClassAnnotation rhsClass) { if (lhsClass == null || rhsClass == null) { return compareNullElements(lhsClass, rhsClass); } else { return compareClassesByName(lhsCollection, rhsCollection, lhsClass.getClassName(), rhsClass.getClassName()); } }
@Override public String getFrom(BugInstance bug) { ProjectPackagePrefixes p = MainFrame.getInstance().getProjectPackagePrefixes(); Collection<String> projects = p.getProjects(bug.getPrimaryClass().getClassName()); if (projects.size() == 0) { return "unclassified"; } String result = projects.toString(); return result.substring(1, result.length() - 1); }
static ClassAnnotation obfuscate(ClassAnnotation m) { ClassAnnotation result = new ClassAnnotation(hashClass(m.getClassName())); result.setDescription(m.getDescription()); return result; }