jdk-sandbox: comparison langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeprscan/scan/Scan.java

equal deleted inserted replaced

-:471a0cb1b986
+:98b049c8b848
 package com.sun.tools.jdeprscan.scan;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.Enumeration;
 final List<String> classPath;
 final DeprDB db;
 final boolean verbose;
 final ClassFinder finder;
-boolean error = false;
+boolean errorOccurred = false;
 public Scan(PrintStream out,
 PrintStream err,
 List<String> classPath,
 DeprDB db,
 } else {
 return "class";
 }
 }
-void printType(String key, ClassFile cf, String cname, boolean forRemoval)
+String dep(boolean forRemoval) {
-throws ConstantPoolException {
+return Messages.get(forRemoval ? "scan.dep.removal" : "scan.dep.normal");
-String dep = Messages.get(forRemoval ? "scan.dep.removal" : "scan.dep.normal");
+}
-out.println(Messages.get(key, typeKind(cf), cf.getName(), cname, dep));
+void printType(String key, ClassFile cf, String cname, boolean r)
+throws ConstantPoolException {
+out.println(Messages.get(key, typeKind(cf), cf.getName(), cname, dep(r)));
 }
 void printMethod(String key, ClassFile cf, String cname, String mname, String rtype,
-boolean forRemoval) throws ConstantPoolException {
+boolean r) throws ConstantPoolException {
-String dep = Messages.get(forRemoval ? "scan.dep.removal" : "scan.dep.normal");
+out.println(Messages.get(key, typeKind(cf), cf.getName(), cname, mname, rtype, dep(r)));
-out.println(Messages.get(key, typeKind(cf), cf.getName(), cname, mname, rtype, dep));
 }
 void printField(String key, ClassFile cf, String cname, String fname,
-boolean forRemoval) throws ConstantPoolException {
+boolean r) throws ConstantPoolException {
-String dep = Messages.get(forRemoval ? "scan.dep.removal" : "scan.dep.normal");
+out.println(Messages.get(key, typeKind(cf), cf.getName(), cname, fname, dep(r)));
-out.println(Messages.get(key, typeKind(cf), cf.getName(), cname, fname, dep));
 }
 void printFieldType(String key, ClassFile cf, String cname, String fname, String type,
-boolean forRemoval) throws ConstantPoolException {
+boolean r) throws ConstantPoolException {
-String dep = Messages.get(forRemoval ? "scan.dep.removal" : "scan.dep.normal");
+out.println(Messages.get(key, typeKind(cf), cf.getName(), cname, fname, type, dep(r)));
-out.println(Messages.get(key, typeKind(cf), cf.getName(), cname, fname, type, dep));
+}
-}
+void printHasField(ClassFile cf, String fname, String type, boolean r)
-void printHasField(ClassFile cf, String fname, String type, boolean forRemoval)
+throws ConstantPoolException {
-throws ConstantPoolException {
+out.println(Messages.get("scan.out.hasfield", typeKind(cf), cf.getName(), fname, type, dep(r)));
-String dep = Messages.get(forRemoval ? "scan.dep.removal" : "scan.dep.normal");
+}
-out.println(Messages.get("scan.out.hasfield", typeKind(cf), cf.getName(), fname, type, dep));
-}
+void printHasMethodParmType(ClassFile cf, String mname, String parmType, boolean r)
+throws ConstantPoolException {
-void printHasMethodParmType(ClassFile cf, String mname, String parmType, boolean forRemoval)
+out.println(Messages.get("scan.out.methodparmtype", typeKind(cf), cf.getName(), mname, parmType, dep(r)));
-throws ConstantPoolException {
+}
-String dep = Messages.get(forRemoval ? "scan.dep.removal" : "scan.dep.normal");
-out.println(Messages.get("scan.out.methodparmtype", typeKind(cf), cf.getName(), mname, parmType, dep));
+void printHasMethodRetType(ClassFile cf, String mname, String retType, boolean r)
-}
+throws ConstantPoolException {
+out.println(Messages.get("scan.out.methodrettype", typeKind(cf), cf.getName(), mname, retType, dep(r)));
-void printHasMethodRetType(ClassFile cf, String mname, String retType, boolean forRemoval)
+}
-throws ConstantPoolException {
-String dep = Messages.get(forRemoval ? "scan.dep.removal" : "scan.dep.normal");
+void printHasOverriddenMethod(ClassFile cf, String overridden, String mname, String desc, boolean r)
-out.println(Messages.get("scan.out.methodrettype", typeKind(cf), cf.getName(), mname, retType, dep));
+throws ConstantPoolException {
-}
-void printHasOverriddenMethod(ClassFile cf, String overridden, String mname, String desc, boolean forRemoval)
-throws ConstantPoolException {
-String dep = Messages.get(forRemoval ? "scan.dep.removal" : "scan.dep.normal");
 out.println(Messages.get("scan.out.methodoverride", typeKind(cf), cf.getName(), overridden,
-mname, desc, dep));
+mname, desc, dep(r)));
 }
-// format should not have a newline
+void errorException(Exception ex) {
-void err(String format, Object... args) {
+errorOccurred = true;
-error = true;
+err.println(Messages.get("scan.err.exception", ex.toString()));
-err.print("error: ");
-err.printf(format, args);
-err.println();
-}
-void printException(Exception ex) {
-err.print(Messages.get("error.prefix"));
-err.print(" ");
 if (verbose) {
 ex.printStackTrace(err);
-} else {
+}
-err.print(ex);
+}
-}
+void errorNoClass(String className) {
+errorOccurred = true;
+err.println(Messages.get("scan.err.noclass", className));
+}
+void errorNoFile(String fileName) {
+errorOccurred = true;
+err.println(Messages.get("scan.err.nofile", fileName));
+}
+void errorNoMethod(String className, String methodName, String desc) {
+errorOccurred = true;
+err.println(Messages.get("scan.err.nomethod", className, methodName, desc));
 }
 /**
 * Checks whether a member (method or field) is present in a class.
 * The checkMethod parameter determines whether this checks for a method
 if (cf.getName().equals(startClassName)) {
 startClass = cf;
 } else {
 startClass = finder.find(startClassName);
 if (startClass == null) {
-err("can't find class %s", startClassName);
+errorNoClass(startClassName);
 return startClassName;
 }
 }
 // follow super_class until it's 0, meaning we've reached Object
 }
 String superName = curClass.getSuperclassName();
 curClass = finder.find(superName);
 if (curClass == null) {
-err("can't find class %s", superName);
+errorNoClass(superName);
 break;
 }
 addInterfaces(intfs, curClass);
 }
 addInterfaces(intfs, startClass);
 while (intfs.size() > 0) {
 String intf = intfs.removeFirst();
 curClass = finder.find(intf);
 if (curClass == null) {
-err("can't find interface %s", intf);
+errorNoClass(intf);
 break;
 }
 if (isMemberPresent(curClass, findName, findDesc, resolveMethod)) {
 break;
 }
 }
 if (curClass == null) {
 if (checkStartClass) {
-err("can't resolve methodref %s %s %s",
+errorNoMethod(startClassName, findName, findDesc);
-startClassName, findName, findDesc);
 return startClassName;
 } else {
 // TODO: refactor this
 // checkStartClass == false means we're checking for overrides
 // so not being able to resolve a method simply means there's
 }
 }
 }
 /**
-* Checks types referred to from the constant pool.
+* Checks Class_info entries in the constant pool.
 *
 * @param cf the ClassFile of this class
 * @param entries constant pool entries collected from this class
 * @throws ConstantPoolException if a constant pool entry cannot be found
 */
-void checkTypes(ClassFile cf, CPEntries entries) throws ConstantPoolException {
+void checkClasses(ClassFile cf, CPEntries entries) throws ConstantPoolException {
 for (ConstantPool.CONSTANT_Class_info ci : entries.classes) {
-String typeName = ci.getName();
+String className = ci.getName();
-DeprData dd = db.getTypeDeprecated(flatten(typeName));
+DeprData dd = db.getTypeDeprecated(flatten(className));
 if (dd != null) {
-printType("scan.out.usestype", cf, typeName, dd.isForRemoval());
+printType("scan.out.usesclass", cf, className, dd.isForRemoval());
 }
 }
 }
 /**
 * Checks methods referred to from the constant pool.
 *
 * @param cf the ClassFile of this class
 * @param nti the NameAndType_info from a MethodRef or InterfaceMethodRef entry
 * @param clname the class name
-* @param typeKey key for the type message
+* @param msgKey message key for localization
-* @param methKey key for the method message
 * @throws ConstantPoolException if a constant pool entry cannot be found
 */
 void checkMethodRef(ClassFile cf,
+String clname,
 CONSTANT_NameAndType_info nti,
-String clname,
+String msgKey) throws ConstantPoolException {
-String typeKey,
-String methKey) throws ConstantPoolException {
-DeprData dd = db.getTypeDeprecated(flatten(clname));
-if (dd != null) {
-printType(typeKey, cf, clname, dd.isForRemoval());
-}
 String name = nti.getName();
 String type = nti.getType();
 clname = resolveMember(cf, flatten(clname), name, type, true, true);
-dd = db.getMethodDeprecated(clname, name, type);
+DeprData dd = db.getMethodDeprecated(clname, name, type);
 if (dd != null) {
-printMethod(methKey, cf, clname, name, type, dd.isForRemoval());
+printMethod(msgKey, cf, clname, name, type, dd.isForRemoval());
 }
 }
 /**
 * Checks fields referred to from the constant pool.
 * @param cf the ClassFile of this class
 * @throws ConstantPoolException if a constant pool entry cannot be found
 */
 void checkFieldRef(ClassFile cf,
 ConstantPool.CONSTANT_Fieldref_info fri) throws ConstantPoolException {
+String clname = fri.getClassName();
 CONSTANT_NameAndType_info nti = fri.getNameAndTypeInfo();
-String clname = fri.getClassName();
 String name = nti.getName();
 String type = nti.getType();
-DeprData dd = db.getTypeDeprecated(clname);
-if (dd != null) {
-printType("scan.out.usesfieldintype", cf, clname, dd.isForRemoval());
-}
 clname = resolveMember(cf, flatten(clname), name, type, false, true);
-dd = db.getFieldDeprecated(clname, name);
+DeprData dd = db.getFieldDeprecated(clname, name);
 if (dd != null) {
 printField("scan.out.usesfield", cf, clname, name, dd.isForRemoval());
-}
-dd = db.getTypeDeprecated(flatten(type));
-if (dd != null) {
-printFieldType("scan.out.usesfieldoftype", cf, clname, name, type, dd.isForRemoval());
 }
 }
 /**
 * Checks the fields declared in this class.
 CPEntries entries = CPEntries.loadFrom(cf);
 checkSuper(cf);
 checkInterfaces(cf);
-checkTypes(cf, entries);
+checkClasses(cf, entries);
 for (ConstantPool.CONSTANT_Methodref_info mri : entries.methodRefs) {
+String clname = mri.getClassName();
 CONSTANT_NameAndType_info nti = mri.getNameAndTypeInfo();
-String clname = mri.getClassName();
+checkMethodRef(cf, clname, nti, "scan.out.usesmethod");
-checkMethodRef(cf, nti, clname, "scan.out.usesmethodintype", "scan.out.usesmethod");
 }
 for (ConstantPool.CONSTANT_InterfaceMethodref_info imri : entries.intfMethodRefs) {
+String clname = imri.getClassName();
 CONSTANT_NameAndType_info nti = imri.getNameAndTypeInfo();
-String clname = imri.getClassName();
+checkMethodRef(cf, clname, nti, "scan.out.usesintfmethod");
-checkMethodRef(cf, nti, clname, "scan.out.usesintfmethodintype", "scan.out.usesintfmethod");
 }
 for (ConstantPool.CONSTANT_Fieldref_info fri : entries.fieldRefs) {
 checkFieldRef(cf, fri);
 }
 * @param jarname the jar file to process
 * @return true on success, false on failure
 */
 public boolean scanJar(String jarname) {
 try (JarFile jf = new JarFile(jarname)) {
+out.println(Messages.get("scan.head.jar", jarname));
 finder.addJar(jarname);
 Enumeration<JarEntry> entries = jf.entries();
 while (entries.hasMoreElements()) {
 JarEntry entry = entries.nextElement();
 String name = entry.getName();
 && !name.endsWith("module-info.class")) {
 processClass(ClassFile.read(jf.getInputStream(entry)));
 }
 }
 return true;
+} catch (NoSuchFileException nsfe) {
+errorNoFile(jarname);
 } catch (IOException | ConstantPoolException ex) {
-printException(ex);
+errorException(ex);
-return false;
+}
-}
+return false;
 }
 /**
 * Scans class files in the named directory hierarchy for uses of deprecated APIs.
 *
 paths.filter(p -> p.getNameCount() > baseCount)
 .filter(path -> path.toString().endsWith(".class"))
 .filter(path -> !path.toString().endsWith("package-info.class"))
 .filter(path -> !path.toString().endsWith("module-info.class"))
 .collect(Collectors.toList());
+out.println(Messages.get("scan.head.dir", dirname));
 for (Path p : classes) {
 processClass(ClassFile.read(p));
 }
 return true;
 } catch (IOException | ConstantPoolException ex) {
-printException(ex);
+errorException(ex);
 return false;
 }
 }
 /**
 */
 public boolean processClassName(String className) {
 try {
 ClassFile cf = finder.find(className);
 if (cf == null) {
-err("can't find class %s", className);
+errorNoClass(className);
 return false;
 } else {
 processClass(cf);
 return true;
 }
 } catch (ConstantPoolException ex) {
-printException(ex);
+errorException(ex);
 return false;
 }
 }
+/**
+* Scans the named class file for uses of deprecated APIs.
+*
+* @param fileName the class file to scan
+* @return true on success, false on failure
+*/
+public boolean processClassFile(String fileName) {
+Path path = Paths.get(fileName);
+try {
+ClassFile cf = ClassFile.read(path);
+processClass(cf);
+return true;
+} catch (NoSuchFileException nsfe) {
+errorNoFile(fileName);
+} catch (IOException | ConstantPoolException ex) {
+errorException(ex);
+}
+return false;
+}
 }

changeset 41863	98b049c8b848
parent 40596	43b19b36e8e6
child 44877	1ab95a256567