public static @CheckForNull JavaClass findSuperDefiner(JavaClass clazz, String name, String signature, BugReporter bugReporter) { try { JavaClass c = clazz; while (true) { c = c.getSuperClass(); if (c == null) { return null; } Method m = findImplementation(c, name, signature); if (m != null) { return c; } } } catch (ClassNotFoundException e) { bugReporter.reportMissingClass(e); return null; } }
private static void printClass(ClassParser parser) throws IOException { JavaClass java_class; java_class = parser.parse(); if (superClasses) { try { while (java_class != null) { System.out.print(java_class.getClassName() + " "); java_class = java_class.getSuperClass(); } } catch (ClassNotFoundException e) { System.out.println(e.getMessage()); } System.out.println(); return; } if (constants || code) { System.out.println(java_class); // Dump the contents } if (constants) { System.out.println(java_class.getConstantPool()); } if (code) { printCode(java_class.getMethods()); } }
@Override public void visit(JavaClass obj) { try { methodMap.clear(); badOverrideMap.clear(); JavaClass superClass = obj.getSuperClass(); if (superClass == null) { return; } String packageName = superClass.getPackageName(); String className = superClass.getClassName(); // A more generic way to add Adapters would be nice here isAdapter = ((className.endsWith("Adapter")) && ("java.awt.event".equals(packageName) || "javax.swing.event".equals(packageName))) || (("DefaultHandler".equals(className) && ("org.xml.sax.helpers".equals(packageName)))); if (isAdapter) { Method[] methods = superClass.getMethods(); for (Method method1 : methods) { methodMap.put(method1.getName(), method1.getSignature()); } } } catch (ClassNotFoundException cnfe) { bugReporter.reportMissingClass(cnfe); } }
public static @CheckForNull JavaClass findSuperImplementor(JavaClass clazz, String name, String signature, BugReporter bugReporter) { try { JavaClass c = clazz; while (true) { c = c.getSuperClass(); if (c == null) { return null; } Method m = findImplementation(c, name, signature); if (m != null && !m.isAbstract()) { return c; } } } catch (ClassNotFoundException e) { bugReporter.reportMissingClass(e); return null; } }
/** * Find a field with given name defined in given class. * * @param className * the name of the class * @param fieldName * the name of the field * @return the Field, or null if no such field could be found */ public static Field findField(String className, String fieldName) throws ClassNotFoundException { JavaClass jclass = Repository.lookupClass(className); while (jclass != null) { Field[] fieldList = jclass.getFields(); for (Field field : fieldList) { if (field.getName().equals(fieldName)) { return field; } } jclass = jclass.getSuperClass(); } return null; }
public static @CheckForNull XMethod findSuperImplementorAsXMethod(JavaClass clazz, String name, String signature, BugReporter bugReporter) { try { JavaClass c = clazz; while (true) { c = c.getSuperClass(); if (c == null) { return null; } Method m = findImplementation(c, name, signature); if (m != null && !m.isAbstract()) { return XFactory.createXMethod(c, m); } } } catch (ClassNotFoundException e) { bugReporter.reportMissingClass(e); return null; } }
public static @CheckForNull JavaClassAndMethod findInvocationLeastUpperBound(JavaClass jClass, String methodName, String methodSig, JavaClassAndMethodChooser methodChooser, boolean invokeInterface) throws ClassNotFoundException { JavaClassAndMethod result = findMethod(jClass, methodName, methodSig, methodChooser); if (result != null) { return result; } if (invokeInterface) { for (JavaClass i : jClass.getInterfaces()) { result = findInvocationLeastUpperBound(i, methodName, methodSig, methodChooser, invokeInterface); if (result != null) { return null; } } } else { JavaClass sClass = jClass.getSuperClass(); if (sClass != null) { return findInvocationLeastUpperBound(sClass, methodName, methodSig, methodChooser, invokeInterface); } } return null; }
private boolean find(JavaClass target, String name, String signature) throws ClassNotFoundException { if (target == null) { return false; } String ref = getMemberName(target.getClassName(), name, signature); if (defined.contains(ref)) { return true; } if (find(target.getSuperClass(), name, signature)) { return true; } for (JavaClass i : target.getInterfaces()) { if (find(i, name, signature)) { return true; } } return false; }
@Override public void visitJavaClass(JavaClass obj) { try { obj.getSuperClass(); } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); return; } String superclassName2 = getSuperclassName(); boolean weird = "java.lang.Object".equals(superclassName2) && obj.getInterfaceIndices().length == 0; boolean hasAnonymousName = ClassName.isLocalOrAnonymous(obj.getClassName()); boolean isAnonymousInnerClass = hasAnonymousName && !weird; if (isAnonymousInnerClass) { super.visitJavaClass(obj); } }
private boolean hasTestMethods(JavaClass jClass) { boolean foundTest = false; Method[] methods = jClass.getMethods(); for (Method m : methods) { if (m.isPublic() && m.getName().startsWith("test") && m.getSignature().equals("()V")) { return true; } if (m.getName().startsWith("runTest") && m.getSignature().endsWith("()V")) { return true; } } if (hasSuite(methods)) { return true; } try { JavaClass sClass = jClass.getSuperClass(); if (sClass != null) { return hasTestMethods(sClass); } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } return false; }
JavaClass superCls = curClass.getSuperClass(); if (superCls.getClassName().equals(newClsName.replace('/', '.'))) { return;
JavaClass superObj = obj.getSuperClass(); SortedSet<String> redundantInfNames = new TreeSet<>();
visitJavaClass(obj.getSuperClass()); } catch (ClassNotFoundException e) {
o = o.getSuperClass(); } catch (ClassNotFoundException e) { break;
boolean definedInSuperClassOrInterface(JavaClass clazz, String method) throws ClassNotFoundException { if (clazz == null) { return false; } JavaClass superClass = clazz.getSuperClass(); if (superClass == null) { return false; } try { XClass xClass = Global.getAnalysisCache().getClassAnalysis(XClass.class, DescriptorFactory.createClassDescriptorFromDottedClassName(superClass.getClassName())); if (xClass.hasStubs()) { return true; } } catch (CheckedAnalysisException e) { return true; } if (definedInThisClassOrSuper(superClass, method)) { return true; } for (JavaClass i : clazz.getInterfaces()) { if (definedInThisClassOrSuper(i, method)) { return true; } } return false; }
if (!factory.isCalled(xmethod) && (obj.isStatic() || !definedInSuperClassOrInterface(clazz, key))) { int priority = NORMAL_PRIORITY; JavaClass superClass = clazz.getSuperClass(); String superClassName = superClass.getClassName(); if ("java.lang.Object".equals(superClassName)) {
/** * @return list of super classes of this class in ascending order, i.e., * java.lang.Object is always the last element * @throws ClassNotFoundException if any of the superclasses can't be found */ public JavaClass[] getSuperClasses() throws ClassNotFoundException { JavaClass clazz = this; final List<JavaClass> allSuperClasses = new ArrayList<>(); for (clazz = clazz.getSuperClass(); clazz != null; clazz = clazz.getSuperClass()) { allSuperClasses.add(clazz); } return allSuperClasses.toArray(new JavaClass[allSuperClasses.size()]); }
/** * @return list of super classes of this class in ascending order, i.e., * java.lang.Object is always the last element */ public JavaClass[] getSuperClasses() { JavaClass clazz = this; ClassVector vec = new ClassVector(); for(clazz = clazz.getSuperClass(); clazz != null; clazz = clazz.getSuperClass()) { vec.addElement(clazz); } return vec.toArray(); }
private boolean hasToString(JavaClass cls) throws ClassNotFoundException { if (Values.DOTTED_JAVA_LANG_OBJECT.equals(cls.getClassName())) { return false; } for (Method m : cls.getMethods()) { if (Values.TOSTRING.equals(m.getName()) && SignatureBuilder.SIG_VOID_TO_STRING.equals(m.getSignature())) { return true; } } return hasToString(cls.getSuperClass()); }
private boolean hasToString(JavaClass cls) throws ClassNotFoundException { if (Values.DOTTED_JAVA_LANG_OBJECT.equals(cls.getClassName())) { return false; } for (Method m : cls.getMethods()) { if (Values.TOSTRING.equals(m.getName()) && SignatureBuilder.SIG_VOID_TO_STRING.equals(m.getSignature())) { return true; } } return hasToString(cls.getSuperClass()); }