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

equal deleted inserted replaced

-:8bf9d5ba7dc6
+:b0b4f52de7ea
 import com.sun.tools.classfile.ClassFile;
 import com.sun.tools.classfile.ConstantPoolException;
 import com.sun.tools.classfile.Dependencies;
 import com.sun.tools.classfile.Dependencies.ClassFileError;
 import com.sun.tools.classfile.Dependency;
-import com.sun.tools.classfile.Dependency.Location;
 import java.io.*;
 import java.text.MessageFormat;
 import java.util.*;
 import java.util.regex.Pattern;
 */
 class JdepsTask {
 class BadArgs extends Exception {
 static final long serialVersionUID = 8765093759964640721L;
 BadArgs(String key, Object... args) {
-super(JdepsTask.this.getMessage(key, args));
+super(JdepsTask.getMessage(key, args));
 this.key = key;
 this.args = args;
 }
 BadArgs showUsage(boolean b) {
 }
 },
 new Option(false, "-s", "--summary") {
 void process(JdepsTask task, String opt, String arg) {
 task.options.showSummary = true;
-task.options.verbose = Options.Verbose.SUMMARY;
+task.options.verbose = Analyzer.Type.SUMMARY;
 }
 },
 new Option(false, "-v", "--verbose") {
 void process(JdepsTask task, String opt, String arg) {
-task.options.verbose = Options.Verbose.VERBOSE;
+task.options.verbose = Analyzer.Type.VERBOSE;
 }
 },
 new Option(true, "-V", "--verbose-level") {
 void process(JdepsTask task, String opt, String arg) throws BadArgs {
-switch (arg) {
+if ("package".equals(arg)) {
-case "package":
+task.options.verbose = Analyzer.Type.PACKAGE;
-task.options.verbose = Options.Verbose.PACKAGE;
+} else if ("class".equals(arg)) {
-break;
+task.options.verbose = Analyzer.Type.CLASS;
-case "class":
+} else {
-task.options.verbose = Options.Verbose.CLASS;
+throw task.new BadArgs("err.invalid.arg.for.option", opt);
-break;
-default:
-throw task.new BadArgs("err.invalid.arg.for.option", opt);
 }
 }
 },
 new Option(true, "-c", "--classpath") {
 void process(JdepsTask task, String opt, String arg) {
 new HiddenOption(false, "--fullversion") {
 void process(JdepsTask task, String opt, String arg) {
 task.options.fullVersion = true;
 }
 },
 };
 private static final String PROGNAME = "jdeps";
 private final Options options = new Options();
 private final List<String> classes = new ArrayList<String>();
 }
 if (options.regex != null && options.packageNames.size() > 0) {
 showHelp();
 return EXIT_CMDERR;
 }
-if (options.showSummary && options.verbose != Options.Verbose.SUMMARY) {
+if (options.showSummary && options.verbose != Analyzer.Type.SUMMARY) {
 showHelp();
 return EXIT_CMDERR;
 }
 boolean ok = run();
 return ok ? EXIT_OK : EXIT_ERROR;
 log.flush();
 }
 }
 private final List<Archive> sourceLocations = new ArrayList<Archive>();
-private final Archive NOT_FOUND = new Archive(getMessage("artifact.not.found"));
 private boolean run() throws IOException {
 findDependencies();
-switch (options.verbose) {
+Analyzer analyzer = new Analyzer(options.verbose);
-case VERBOSE:
+analyzer.run(sourceLocations);
-case CLASS:
+if (options.verbose == Analyzer.Type.SUMMARY) {
-printClassDeps(log);
+printSummary(log, analyzer);
-break;
+} else {
-case PACKAGE:
+printDependencies(log, analyzer);
-printPackageDeps(log);
-break;
-case SUMMARY:
-for (Archive origin : sourceLocations) {
-for (Archive target : origin.getRequiredArchives()) {
-log.format("%-30s -> %s%n", origin, target);
-}
-}
-break;
-default:
-throw new InternalError("Should not reach here");
 }
 return true;
 }
 private boolean isValidClassName(String name) {
 try {
 classFileName = cf.getName();
 } catch (ConstantPoolException e) {
 throw new ClassFileError(e);
 }
-a.addClass(classFileName);
 if (!doneClasses.contains(classFileName)) {
 doneClasses.add(classFileName);
 }
 for (Dependency d : finder.findDependencies(cf)) {
 if (filter.accepts(d)) {
 String cn = d.getTarget().getName();
 if (!doneClasses.contains(cn) && !deque.contains(cn)) {
 deque.add(cn);
 }
-a.addDependency(d);
+a.addClass(d.getOrigin(), d.getTarget());
 }
 }
 }
 }
 try {
 classFileName = cf.getName();
 } catch (ConstantPoolException e) {
 throw new ClassFileError(e);
 }
-a.addClass(classFileName);
 if (!doneClasses.contains(classFileName)) {
 // if name is a fully-qualified class name specified
 // from command-line, this class might already be parsed
 doneClasses.add(classFileName);
-if (depth > 0) {
+for (Dependency d : finder.findDependencies(cf)) {
-for (Dependency d : finder.findDependencies(cf)) {
+if (depth == 0) {
-if (filter.accepts(d)) {
+// ignore the dependency
-String cn = d.getTarget().getName();
+a.addClass(d.getOrigin());
-if (!doneClasses.contains(cn) && !deque.contains(cn)) {
+break;
-deque.add(cn);
+} else if (filter.accepts(d)) {
-}
+a.addClass(d.getOrigin(), d.getTarget());
-a.addDependency(d);
+String cn = d.getTarget().getName();
+if (!doneClasses.contains(cn) && !deque.contains(cn)) {
+deque.add(cn);
 }
 }
 }
 }
 break;
 }
 }
 if (cf == null) {
-NOT_FOUND.addClass(name);
+doneClasses.add(name);
 }
 }
 unresolved = deque;
 deque = new LinkedList<String>();
 } while (!unresolved.isEmpty() && depth-- > 0);
 }
-private void printPackageDeps(PrintWriter out) {
+private void printSummary(final PrintWriter out, final Analyzer analyzer) {
-for (Archive source : sourceLocations) {
+Analyzer.Visitor visitor = new Analyzer.Visitor() {
-SortedMap<Location, SortedSet<Location>> deps = source.getDependencies();
+public void visit(String origin, String profile) {
-if (deps.isEmpty())
+if (options.showProfile) {
-continue;
+out.format("%-30s -> %s%n", origin, profile);
+}
-for (Archive target : source.getRequiredArchives()) {
+}
-out.format("%s -> %s%n", source, target);
+public void visit(Archive origin, Archive target) {
-}
+if (!options.showProfile) {
+out.format("%-30s -> %s%n", origin, target);
-Map<String, Archive> pkgs = new TreeMap<String, Archive>();
+}
-SortedMap<String, Archive> targets = new TreeMap<String, Archive>();
+}
-String pkg = "";
+};
-for (Map.Entry<Location, SortedSet<Location>> e : deps.entrySet()) {
+analyzer.visitSummary(visitor);
-String cn = e.getKey().getClassName();
+}
-String p = packageOf(e.getKey());
-Archive origin = Archive.find(e.getKey());
+private void printDependencies(final PrintWriter out, final Analyzer analyzer) {
-assert origin != null;
+Analyzer.Visitor visitor = new Analyzer.Visitor() {
-if (!pkgs.containsKey(p)) {
+private String pkg = "";
-pkgs.put(p, origin);
+public void visit(String origin, String target) {
-} else if (pkgs.get(p) != origin) {
+if (!origin.equals(pkg)) {
-warning("warn.split.package", p, origin, pkgs.get(p));
+pkg = origin;
-}
+out.format("   %s (%s)%n", origin, analyzer.getArchiveName(origin));
+}
-if (!p.equals(pkg)) {
+Archive source = analyzer.getArchive(target);
-printTargets(out, targets);
+String profile = options.showProfile ? analyzer.getProfile(target) : "";
-pkg = p;
+out.format("      -> %-50s %s%n", target,
-targets.clear();
+PlatformClassPath.contains(source)
-out.format("   %s (%s)%n", p, origin.getFileName());
+? profile
-}
+: analyzer.getArchiveName(target));
+}
-for (Location t : e.getValue()) {
+public void visit(Archive origin, Archive target) {
-p = packageOf(t);
+out.format("%s -> %s%n", origin, target);
-Archive target = Archive.find(t);
+}
-if (!targets.containsKey(p)) {
+};
-targets.put(p, target);
+analyzer.visit(visitor);
 }
-}
-}
-printTargets(out, targets);
-out.println();
-}
-}
-private void printTargets(PrintWriter out, Map<String, Archive> targets) {
-for (Map.Entry<String, Archive> t : targets.entrySet()) {
-String pn = t.getKey();
-out.format("      -> %-40s %s%n", pn, getPackageInfo(pn, t.getValue()));
-}
-}
-private String getPackageInfo(String pn, Archive source) {
-if (PlatformClassPath.contains(source)) {
-String name = PlatformClassPath.getProfileName(pn);
-if (name.isEmpty()) {
-return "JDK internal API (" + source.getFileName() + ")";
-}
-return options.showProfile ? name : "";
-}
-return source.getFileName();
-}
-private static String packageOf(Location loc) {
-String pkg = loc.getPackageName();
-return pkg.isEmpty() ? "<unnamed>" : pkg;
-}
-private void printClassDeps(PrintWriter out) {
-for (Archive source : sourceLocations) {
-SortedMap<Location, SortedSet<Location>> deps = source.getDependencies();
-if (deps.isEmpty())
-continue;
-for (Archive target : source.getRequiredArchives()) {
-out.format("%s -> %s%n", source, target);
-}
-out.format("%s%n", source);
-for (Map.Entry<Location, SortedSet<Location>> e : deps.entrySet()) {
-String cn = e.getKey().getClassName();
-Archive origin = Archive.find(e.getKey());
-out.format("   %s (%s)%n", cn, origin.getFileName());
-for (Location t : e.getValue()) {
-cn = t.getClassName();
-Archive target = Archive.find(t);
-out.format("      -> %-60s %s%n", cn, getPackageInfo(t.getPackageName(), target));
-}
-}
-out.println();
-}
-}
 public void handleOptions(String[] args) throws BadArgs {
 // process options
 for (int i=0; i < args.length; i++) {
 if (args[i].charAt(0) == '-') {
 String name = args[i];
 } catch (MissingResourceException e) {
 return getMessage("version.unknown", System.getProperty("java.version"));
 }
 }
-public String getMessage(String key, Object... args) {
+static String getMessage(String key, Object... args) {
 try {
 return MessageFormat.format(ResourceBundleHelper.bundle.getString(key), args);
 } catch (MissingResourceException e) {
 throw new InternalError("Missing message: " + key);
 }
 }
 private static class Options {
-enum Verbose {
-CLASS,
-PACKAGE,
-SUMMARY,
-VERBOSE
-};
 boolean help;
 boolean version;
 boolean fullVersion;
 boolean showFlags;
 boolean showProfile;
 boolean showSummary;
 boolean wildcard;
 String regex;
 String classpath = "";
 int depth = 1;
-Verbose verbose = Verbose.PACKAGE;
+Analyzer.Type verbose = Analyzer.Type.PACKAGE;
 Set<String> packageNames = new HashSet<String>();
 }
 private static class ResourceBundleHelper {
 static final ResourceBundle versionRB;

changeset 16290	b0b4f52de7ea
parent 15030	2d8dec41f029
child 16550	f20e2521f3df