private Set<JavaClass> getMtClasses() { if (mtClasses != null) { return mtClasses; } mtClasses = new HashSet<>(); try { mtClasses.add(Repository.lookupClass(STRUTS_ACTION_NAME)); } catch (ClassNotFoundException cnfe) { // probably would be annoying to report } try { mtClasses.add(Repository.lookupClass(SERVLET_NAME)); } catch (ClassNotFoundException cnfe) { // probably would be annoying to report } return mtClasses; }
public static @DottedClassName String findSuperImplementor(@DottedClassName String clazz, String name, String signature, BugReporter bugReporter) { try { JavaClass c = findImplementor(Repository.getSuperClasses(clazz), name, signature); return (c != null) ? c.getClassName() : clazz; } catch (ClassNotFoundException e) { bugReporter.reportMissingClass(e); return clazz; } }
JavaClass castJavaClass = Repository.lookupClass(castName); JavaClass refJavaClass = Repository.lookupClass(refName); boolean upcast = Repository.instanceOf(refJavaClass, castJavaClass); if (upcast || typesAreEqual) { if (!isCast) { boolean castMayThrow = !Repository.instanceOf(refJavaClass, castJavaClass); boolean downCast = Repository.instanceOf(castJavaClass, refJavaClass);
/** * @return list of super classes of clazz in ascending order, i.e., * Object is always the last element. * @throws ClassNotFoundException if the named class or any of its * superclasses can't be found */ public static JavaClass[] getSuperClasses( final String class_name ) throws ClassNotFoundException { final JavaClass jc = lookupClass(class_name); return getSuperClasses(jc); }
/** * @return true, if clazz is an implementation of interface inter * @throws ClassNotFoundException if clazz, inter, or any superclasses * or superinterfaces of clazz can't be found */ public static boolean implementationOf( final String clazz, final String inter ) throws ClassNotFoundException { return implementationOf(lookupClass(clazz), lookupClass(inter)); }
/** * @return all interfaces implemented by class and its super * classes and the interfaces that extend those interfaces, and so on * @throws ClassNotFoundException if the named class can't be found, * or if any of its superclasses or superinterfaces can't be found */ public static JavaClass[] getInterfaces( final String class_name ) throws ClassNotFoundException { return getInterfaces(lookupClass(class_name)); }
.lookupClass(args[k]); for (int i=0; i<jc.getMethods().length; i++){ vr = v.doPass3a(i); org.apache.bcel.Repository.clearCache(); System.gc();
private boolean isImageIOInputStream() { try { if (lastCallClass.startsWith("[")) { return false; } return Repository.instanceOf(lastCallClass, "javax.imageio.stream.ImageInputStream"); } catch (ClassNotFoundException e) { return false; } }
/** * Parse the class file into a JavaClass object. If successful, the new * JavaClass is entered into the Repository. * * @return the parsed JavaClass * @throws IOException * if the class cannot be parsed */ public JavaClass parse() throws IOException { JavaClass jclass = classParser.parse(); Repository.addClass(jclass); return jclass; } }
/** * @return list of super classes of clazz in ascending order, i.e., * Object is always the last element. return "null", if class * cannot be found. */ public static JavaClass[] getSuperClasses(String class_name) { JavaClass jc = lookupClass(class_name); return (jc == null? null : getSuperClasses(jc)); }
/** * @return true, if clazz is an implementation of interface inter */ public static boolean implementationOf(String clazz, JavaClass inter) { return implementationOf(lookupClass(clazz), inter); } }
/** * @return all interfaces implemented by class and its super * classes and the interfaces that extend those interfaces, and so on */ public static JavaClass[] getInterfaces(String class_name) { return getInterfaces(lookupClass(class_name)); }
System.out.println("Pass 2:\n" + vr); if (vr == VerificationResult.VR_OK) { final JavaClass jc = org.apache.bcel.Repository.lookupClass(args[k]); for (int i = 0; i < jc.getMethods().length; i++) { vr = v.doPass3a(i); org.apache.bcel.Repository.clearCache(); System.gc(); } catch (final ClassNotFoundException e) {
private boolean isBufferedInputStream() { try { if (lastCallClass.startsWith("[")) { return false; } return Repository.instanceOf(lastCallClass, "java.io.BufferedInputStream"); } catch (ClassNotFoundException e) { return false; } }
public RegenerateClassFeatures execute() throws IOException { bugCollection.clearClassFeatures(); ArrayList<JavaClass> classList = new ArrayList<>(); try (ZipFile zipFile = new ZipFile(jarFile)){ // Add all classes to repository (for hierarchy queries) Enumeration<? extends ZipEntry> entries = zipFile.entries(); while (entries.hasMoreElements()) { ZipEntry entry = entries.nextElement(); if (!entry.getName().endsWith(".class")) { continue; } ClassParser parser = new ClassParser(zipFile.getInputStream(entry), entry.getName()); JavaClass javaClass = parser.parse(); Repository.addClass(javaClass); classList.add(javaClass); } } for (JavaClass javaClass : classList) { ClassFeatureSet classFeatureSet = new ClassFeatureSet().initialize(javaClass); bugCollection.setClassFeatureSet(classFeatureSet); } return this; }
public BadAppletConstructor(BugReporter bugReporter) { this.bugReporter = bugReporter; JavaClass appletClass = null; try { appletClass = Repository.lookupClass("java.applet.Applet"); } catch (ClassNotFoundException cnfe) { bugReporter.reportMissingClass(cnfe); } this.appletClass = appletClass; }
try { if ((confusingMethodNamesWrongCapitalization(m, m2) || confusingMethodNamesWrongPackage(m, m2)) && Repository.instanceOf(m.getClassName(), m2.getClassName())) { WarningPropertySet<NamingProperty> propertySet = new WarningPropertySet<>(); XMethod m3 = null; try { JavaClass clazz = Repository.lookupClass(m.getClassName()); if ((m3 = definedIn(clazz, m2)) != null) {
JavaClass[] thiz_sups = Repository.getSuperClasses(thiz.getClassName()); JavaClass[] other_sups = Repository.getSuperClasses(other.getClassName()); System.arraycopy(thiz_sups, 0, this_sups, 1, thiz_sups.length); System.arraycopy(other_sups, 0, t_sups, 1, other_sups.length); this_sups[0] = Repository.lookupClass(thiz.getClassName()); t_sups[0] = Repository.lookupClass(other.getClassName());
/** * @return true, if clazz is an implementation of interface inter */ public static boolean implementationOf(String clazz, String inter) { return implementationOf(lookupClass(clazz), lookupClass(inter)); }
@Nullable private CheckReturnValueAnnotation getResolvedAnnotationOnConstructor(XMethod m) { try { if (throwableClass != null && Repository.instanceOf(m.getClassName(), throwableClass)) { return CheckReturnValueAnnotation.CHECK_RETURN_VALUE_VERY_HIGH; } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } if ("java.lang.Thread".equals(m.getClassName())) { return CheckReturnValueAnnotation.CHECK_RETURN_VALUE_VERY_HIGH; } try { if (threadClass != null && Repository.instanceOf(m.getClassName(), threadClass)) { return CheckReturnValueAnnotation.CHECK_RETURN_VALUE_LOW; } } catch (ClassNotFoundException e) { AnalysisContext.reportMissingClass(e); } return null; }