/** * Visit all superclass methods which the given method overrides. * * @param method * the method * @param chooser * chooser which visits each superclass method * @return the chosen method, or null if no method is chosen * @throws ClassNotFoundException */ public static JavaClassAndMethod visitSuperClassMethods(JavaClassAndMethod method, JavaClassAndMethodChooser chooser) throws ClassNotFoundException { return findMethod(method.getJavaClass().getSuperClasses(), method.getMethod().getName(), method.getMethod() .getSignature(), chooser); }
JavaClass[] superclassList = javaClass.getSuperClasses(); if (superclassList != null) { JavaClassAndMethod match = Hierarchy.findMethod(superclassList, method.getName(), method.getSignature(),
/** * @return list of super classes of clazz in ascending order, i.e., * Object is always the last element */ public static JavaClass[] getSuperClasses(JavaClass clazz) { return clazz.getSuperClasses(); }
/** * @return list of super classes of clazz in ascending order, i.e., * Object is always the last element * @throws ClassNotFoundException if any of the superclasses can't be found */ public static JavaClass[] getSuperClasses( final JavaClass clazz ) throws ClassNotFoundException { return clazz.getSuperClasses(); }
/** Equivalent to runtime "instanceof" operator. * * @return true if this JavaClass is derived from teh super class */ public final boolean instanceOf(JavaClass super_class) { if(this.equals(super_class)) return true; JavaClass[] super_classes = getSuperClasses(); for(int i=0; i < super_classes.length; i++) { if(super_classes[i].equals(super_class)) { return true; } } if(super_class.isInterface()) { return implementationOf(super_class); } return false; }
private Set<MethodAndSink> getSuperSinks(JavaClass javaClass, String method) throws ClassNotFoundException { for (JavaClass superClass : javaClass.getSuperClasses()) { String fullMethodName = superClass.getClassName().replace('.', '/').concat(method); Set<InjectionSink> sinks = injectionSinks.get(fullMethodName); if (sinks != null) { return getMethodAndSinks(fullMethodName, sinks); } } for (JavaClass interfaceClass : javaClass.getAllInterfaces()) { String fullMethodName = interfaceClass.getClassName().replace('.', '/').concat(method); Set<InjectionSink> sinks = injectionSinks.get(fullMethodName); if (sinks != null) { return getMethodAndSinks(fullMethodName, sinks); } } return Collections.emptySet(); }
private Set<MethodAndSink> getSuperSinks(JavaClass javaClass, String method) throws ClassNotFoundException { for (JavaClass superClass : javaClass.getSuperClasses()) { String fullMethodName = superClass.getClassName().replace('.', '/').concat(method); Set<InjectionSink> sinks = injectionSinks.get(fullMethodName); if (sinks != null) { return getMethodAndSinks(fullMethodName, sinks); } } for (JavaClass interfaceClass : javaClass.getAllInterfaces()) { String fullMethodName = interfaceClass.getClassName().replace('.', '/').concat(method); Set<InjectionSink> sinks = injectionSinks.get(fullMethodName); if (sinks != null) { return getMethodAndSinks(fullMethodName, sinks); } } return Collections.emptySet(); }
public static boolean isInheritedMethod(JavaClass cls, String methodName, String signature) throws ClassNotFoundException { JavaClass[] infs = cls.getAllInterfaces(); if (findInheritedMethod(infs, methodName, signature) != null) { return true; } JavaClass[] supers = cls.getSuperClasses(); for (int i = 0; i < supers.length; i++) { if (Values.DOTTED_JAVA_LANG_OBJECT.equals(supers[i].getClassName())) { supers[i] = null; } } return findInheritedMethod(supers, methodName, signature) != null; }
public static boolean isInheritedMethod(JavaClass cls, String methodName, String signature) throws ClassNotFoundException { JavaClass[] infs = cls.getAllInterfaces(); if (findInheritedMethod(infs, methodName, signature) != null) { return true; } JavaClass[] supers = cls.getSuperClasses(); for (int i = 0; i < supers.length; i++) { if (Values.DOTTED_JAVA_LANG_OBJECT.equals(supers[i].getClassName())) { supers[i] = null; } } return findInheritedMethod(supers, methodName, signature) != null; }
private static Method findMethod( JavaClass javaClass, String methodName, Type argumentTypes[]) throws ClassNotFoundException { for (Method method : javaClass.getMethods()) { if (method.getName().equals(methodName)) { if (Arrays.equals(argumentTypes, method.getArgumentTypes())) { return method; } } } for (JavaClass superClass : javaClass.getSuperClasses()) { Method method = findMethod(superClass, methodName, argumentTypes); if (method != null) { return method; } } return null; } }
try { JavaClass cls = classContext.getJavaClass(); JavaClass[] superClasses = cls.getSuperClasses(); for (JavaClass superCls : superClasses) { if (tagClasses.contains(superCls.getClassName())) {
/** * implements the visitor to collect classes that constrains this class (super classes/interfaces) and to reset the opcode stack * * @param classContext * the currently parse class */ @Override public void visitClassContext(ClassContext classContext) { try { cls = classContext.getJavaClass(); if (!isaConversionClass(cls)) { JavaClass[] infs = cls.getAllInterfaces(); JavaClass[] sups = cls.getSuperClasses(); constrainingClasses = new JavaClass[infs.length + sups.length]; System.arraycopy(infs, 0, constrainingClasses, 0, infs.length); System.arraycopy(sups, 0, constrainingClasses, infs.length, sups.length); parameterDefiners = new HashMap<>(); usedParameters = new BitSet(); stack = new OpcodeStack(); super.visitClassContext(classContext); } } catch (ClassNotFoundException cnfe) { bugReporter.reportMissingClass(cnfe); } finally { constrainingClasses = null; parameterDefiners = null; usedParameters = null; stack = null; } }
/** * looks to see if this method is derived from a super class. If it is we don't want to report on it, as that would entail changing a whole hierarchy * * @param m * the current method * @return if the method is inherited * * @throws ClassNotFoundException * if the super class(s) aren't found */ private boolean isInherited(Method m) throws ClassNotFoundException { JavaClass[] infs = javaClass.getAllInterfaces(); for (JavaClass inf : infs) { if (hasMethod(inf, m)) { return true; } } JavaClass[] sups = javaClass.getSuperClasses(); for (JavaClass sup : sups) { if (hasMethod(sup, m)) { return true; } } return false; }
public TaintMethodConfig getSuperMethodConfig(String className, String methodId) { try { if (className.endsWith("]")) { // not a real class return null; } JavaClass javaClass = Repository.lookupClass(className); assert javaClass != null; TaintMethodConfig methodConfig = getSuperMethodConfig(javaClass.getSuperClasses(), methodId); if (methodConfig != null) { return methodConfig; } return getSuperMethodConfig(javaClass.getAllInterfaces(), methodId); } catch (ClassNotFoundException ex) { AnalysisContext.reportMissingClass(ex); return null; } }
/** * looks to see if this method is derived from a super class. If it is we don't want to report on it, as that would entail changing a whole hierarchy * * @param m * the current method * @return if the method is inherited * * @throws ClassNotFoundException * if the super class(s) aren't found */ private boolean isInherited(Method m) throws ClassNotFoundException { JavaClass[] infs = javaClass.getAllInterfaces(); for (JavaClass inf : infs) { if (hasMethod(inf, m)) { return true; } } JavaClass[] sups = javaClass.getSuperClasses(); for (JavaClass sup : sups) { if (hasMethod(sup, m)) { return true; } } return false; }
public TaintMethodConfig getSuperMethodConfig(String className, String methodId) { try { if (className.endsWith("]")) { // not a real class return null; } JavaClass javaClass = Repository.lookupClass(className); assert javaClass != null; TaintMethodConfig methodConfig = getSuperMethodConfig(javaClass.getSuperClasses(), methodId); if (methodConfig != null) { return methodConfig; } return getSuperMethodConfig(javaClass.getAllInterfaces(), methodId); } catch (ClassNotFoundException ex) { AnalysisContext.reportMissingClass(ex); return null; } }
/** Equivalent to runtime "instanceof" operator. * * @return true if this JavaClass is derived from the super class * @throws ClassNotFoundException if superclasses or superinterfaces * of this object can't be found */ public final boolean instanceOf( final JavaClass super_class ) throws ClassNotFoundException { if (this.equals(super_class)) { return true; } final JavaClass[] super_classes = getSuperClasses(); for (final JavaClass super_classe : super_classes) { if (super_classe.equals(super_class)) { return true; } } if (super_class.isInterface()) { return implementationOf(super_class); } return false; }
/** * implements the detector to collect the super classes * * @param classContext * the context object for the currently parsed class */ @Override public void visitClassContext(ClassContext classContext) { try { clsContext = classContext; JavaClass cls = classContext.getJavaClass(); if (cls.isInterface()) return; superClasses = cls.getSuperClasses(); cls.accept(this); } catch (ClassNotFoundException cnfe) { bugReporter.reportMissingClass(cnfe); } finally { clsContext = null; superClasses = null; } }
/** * implements the detector to collect the super classes * * @param classContext * the context object for the currently parsed class */ @Override public void visitClassContext(ClassContext classContext) { try { clsContext = classContext; JavaClass cls = classContext.getJavaClass(); if (cls.isInterface()) return; superClasses = cls.getSuperClasses(); cls.accept(this); } catch (ClassNotFoundException cnfe) { bugReporter.reportMissingClass(cnfe); } finally { clsContext = null; superClasses = null; } }
/** * Visit all superclass methods which the given method overrides. * * @param method * the method * @param chooser * chooser which visits each superclass method * @return the chosen method, or null if no method is chosen * @throws ClassNotFoundException */ public static JavaClassAndMethod visitSuperClassMethods(JavaClassAndMethod method, JavaClassAndMethodChooser chooser) throws ClassNotFoundException { return findMethod(method.getJavaClass().getSuperClasses(), method.getMethod().getName(), method.getMethod() .getSignature(), chooser); }