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

equal deleted inserted replaced

-:e00cf18e2593
+:c16b6cc93272
 throw new BadArgs("err.command.set", task.command, opt);
 }
 task.command = task.listModuleDeps(CommandOption.PRINT_MODULE_DEPS);
 }
 },
+new Option(false, "--ignore-missing-deps") {
+void process(JdepsTask task, String opt, String arg) {
+task.options.ignoreMissingDeps = true;
+}
+},
 // ---- Target filtering options ----
 new Option(true, "-p", "-package", "--package") {
 void process(JdepsTask task, String opt, String arg) {
 task.options.packageNames.add(arg);
 task.options.filterSamePackage = false;
 break;
 }
 }
 },
+new Option(false, "--missing-deps") {
+void process(JdepsTask task, String opt, String arg) {
+task.options.findMissingDeps = true;
+}
+},
 // ---- Source filtering options ----
 new Option(true, "-include") {
 void process(JdepsTask task, String opt, String arg) throws BadArgs {
 task.options.includePattern = Pattern.compile(arg);
 void process(JdepsTask task, String opt, String arg) throws BadArgs {
 task.options.showProfile = true;
 }
 },
-new Option(false, "-R", "-recursive") {
+new Option(false, "-R", "-recursive", "--recursive") {
-void process(JdepsTask task, String opt, String arg) {
+void process(JdepsTask task, String opt, String arg) throws BadArgs {
-task.options.depth = 0;
+task.options.recursive = Options.RECURSIVE;
 // turn off filtering
 task.options.filterSameArchive = false;
 task.options.filterSamePackage = false;
 }
 },
+new Option(false, "--no-recursive") {
+void process(JdepsTask task, String opt, String arg) throws BadArgs {
+task.options.recursive = Options.NO_RECURSIVE;
+}
+},
 new Option(false, "-I", "--inverse") {
 void process(JdepsTask task, String opt, String arg) {
 task.options.inverse = true;
 // equivalent to the inverse of compile-time view analysis
 task.options.compileTimeView = true;
 },
 new Option(false, "--compile-time") {
 void process(JdepsTask task, String opt, String arg) {
 task.options.compileTimeView = true;
+task.options.recursive = Options.RECURSIVE;
 task.options.filterSamePackage = true;
 task.options.filterSameArchive = true;
-task.options.depth = 0;
 }
 },
 new HiddenOption(false, "-fullversion") {
 void process(JdepsTask task, String opt, String arg) {
 }
 return new GenModuleInfo(dir, openModule);
 }
 private ListModuleDeps listModuleDeps(CommandOption option) throws BadArgs {
+// do transitive dependence analysis unless --no-recursive is set
+if (options.recursive != Options.NO_RECURSIVE) {
+options.recursive = Options.RECURSIVE;
+}
+// no need to record the dependences on the same archive or same package
+options.filterSameArchive = true;
+options.filterSamePackage = true;
 switch (option) {
 case LIST_DEPS:
 return new ListModuleDeps(option, true, false);
 case LIST_REDUCED_DEPS:
 return new ListModuleDeps(option, true, true);
 super(option);
 }
 @Override
 boolean checkOptions() {
-if (options.findJDKInternals) {
+if (options.findJDKInternals || options.findMissingDeps) {
 // cannot set any filter, -verbose and -summary option
 if (options.showSummary || options.verbose != null) {
 reportError("err.invalid.options", "-summary or -verbose",
-"-jdkinternals");
+options.findJDKInternals ? "-jdkinternals" : "--missing-deps");
 return false;
 }
 if (options.hasFilter()) {
 reportError("err.invalid.options", "--package, --regex, --require",
-"-jdkinternals");
+options.findJDKInternals ? "-jdkinternals" : "--missing-deps");
 return false;
 }
 }
 if (options.showSummary) {
 // -summary cannot use with -verbose option
 */
 Type getAnalyzerType() {
 if (options.showSummary)
 return Type.SUMMARY;
-if (options.findJDKInternals)
+if (options.findJDKInternals || options.findMissingDeps)
 return Type.CLASS;
 // default to package-level verbose
 return options.verbose != null ? options.verbose : PACKAGE;
 }
 dependencyFilter(config),
 writer,
 type,
 options.apiOnly);
-boolean ok = analyzer.run(options.compileTimeView, options.depth);
+boolean ok = analyzer.run(options.compileTimeView, options.depth());
 // print skipped entries, if any
 if (!options.nowarning) {
 analyzer.archives()
 .forEach(archive -> archive.reader()
 InverseAnalyzeDeps() {
 }
 @Override
 boolean checkOptions() {
-if (options.depth != 1) {
+if (options.recursive != -1 || options.depth != -1) {
-reportError("err.invalid.options", "-R", "--inverse");
+reportError("err.invalid.options", "--recursive and --no-recursive", "--inverse");
 return false;
 }
 if (options.numFilters() == 0) {
 reportError("err.filter.not.specified");
 = new ModuleInfoBuilder(config, inputArgs, dir, openModule);
 boolean ok = builder.run();
 if (!ok && !options.nowarning) {
 reportError("err.missing.dependences");
-builder.visitMissingDeps(
+builder.visitMissingDeps(new SimpleDepVisitor());
-(origin, originArchive, target, targetArchive) -> {
-if (builder.notFound(targetArchive))
-log.format("   %-50s -> %-50s %s%n",
-origin, target, targetArchive.getName());
-});
 }
 return ok;
 }
 private String toPackageName(String name) {
 }
 @Override
 boolean checkOptions() {
 if (options.showSummary || options.verbose != null) {
-reportError("err.invalid.options", "-summary or -verbose",
+reportError("err.invalid.options", "-summary or -verbose", option);
-option);
 return false;
 }
 if (options.findJDKInternals) {
-reportError("err.invalid.options", "-jdkinternals",
+reportError("err.invalid.options", "-jdkinternals", option);
-option);
+return false;
+}
+if (options.findMissingDeps) {
+reportError("err.invalid.options", "--missing-deps", option);
 return false;
 }
 if (!inputArgs.isEmpty() && !options.rootModules.isEmpty()) {
 reportError("err.invalid.arg.for.option", "-m");
 return true;
 }
 @Override
 boolean run(JdepsConfiguration config) throws IOException {
-return new ModuleExportsAnalyzer(config,
+ModuleExportsAnalyzer analyzer = new ModuleExportsAnalyzer(config,
 dependencyFilter(config),
 jdkinternals,
 reduced,
 log,
-separator).run();
+separator);
-}
+boolean ok = analyzer.run(options.depth(), options.ignoreMissingDeps);
-}
+if (!ok) {
+reportError("err.cant.list.module.deps");
+log.println();
+analyzer.visitMissingDeps(new SimpleDepVisitor());
+}
+return ok;
+}
+}
 class GenDotFile extends AnalyzeDeps {
 final Path dotOutputDir;
 GenDotFile(Path dotOutputDir) {
 super(CommandOption.GENERATE_DOT_FILE);
 options.showLabel);
 return run(config, writer, type);
 }
 }
+class SimpleDepVisitor implements Analyzer.Visitor {
+private Archive source;
+@Override
+public void visitDependence(String origin, Archive originArchive, String target, Archive targetArchive) {
+if (source != originArchive) {
+source = originArchive;
+log.format("%s%n", originArchive);
+}
+log.format("   %-50s -> %-50s %s%n", origin, target, targetArchive.getName());
+}
+}
 /**
 * Returns a filter used during dependency analysis
 */
 private JdepsFilter dependencyFilter(JdepsConfiguration config) {
 // Filter specified by -filter, -package, -regex, and --require options
 builder.includePattern(options.includePattern);
 // target filters
 builder.filter(options.filterSamePackage, options.filterSameArchive);
 builder.findJDKInternals(options.findJDKInternals);
+builder.findMissingDeps(options.findMissingDeps);
 // --require
 if (!options.requires.isEmpty()) {
 options.requires.stream()
 .forEach(mn -> {
 }
 private String version(String key) {
 // key=version:  mm.nn.oo[-milestone]
 // key=full:     mm.mm.oo[-milestone]-build
-if (ResourceBundleHelper.versionRB == null) {
-return System.getProperty("java.version");
-}
 try {
-return ResourceBundleHelper.versionRB.getString(key);
+return ResourceBundleHelper.getVersion(key);
 } catch (MissingResourceException e) {
 return getMessage("version.unknown", System.getProperty("java.version"));
 }
 }
 static String getMessage(String key, Object... args) {
 try {
-return MessageFormat.format(ResourceBundleHelper.bundle.getString(key), args);
+return MessageFormat.format(ResourceBundleHelper.getMessage(key), args);
 } catch (MissingResourceException e) {
 throw new InternalError("Missing message: " + key);
 }
 }
 private static class Options {
+static final int NO_RECURSIVE = 0;
+static final int RECURSIVE = 1;
 boolean help;
 boolean version;
 boolean fullVersion;
 boolean showProfile;
 boolean showModule = true;
 boolean showSummary;
 boolean apiOnly;
 boolean showLabel;
 boolean findJDKInternals;
+boolean findMissingDeps;
+boolean ignoreMissingDeps;
 boolean nowarning = false;
 Analyzer.Type verbose;
 // default filter references from same package
 boolean filterSamePackage = true;
 boolean filterSameArchive = false;
 Pattern filterRegex;
 String classpath;
-int depth = 1;
+int recursive = -1;     // 0: --no-recursive, 1: --recursive
+int depth = -1;
 Set<String> requires = new HashSet<>();
 Set<String> packageNames = new HashSet<>();
 Pattern regex;             // apply to the dependences
 Pattern includePattern;
 boolean inverse = false;
 if (requires.size() > 0) count++;
 if (regex != null) count++;
 if (packageNames.size() > 0) count++;
 return count;
 }
+int depth() {
+// ignore -depth if --no-recursive is set
+if (recursive == NO_RECURSIVE)
+return 1;
+// depth == 0 if recursive
+if (recursive == RECURSIVE && depth == -1)
+return 0;
+// default depth is 1 unless specified via -depth option
+return depth == -1 ? 1 : depth;
+}
 }
 private static class ResourceBundleHelper {
+static final String LS = System.lineSeparator();
 static final ResourceBundle versionRB;
 static final ResourceBundle bundle;
 static final ResourceBundle jdkinternals;
 static {
 try {
 jdkinternals = ResourceBundle.getBundle("com.sun.tools.jdeps.resources.jdkinternals");
 } catch (MissingResourceException e) {
 throw new InternalError("Cannot find jdkinternals resource bundle");
 }
+}
+static String getMessage(String key) {
+return bundle.getString(key).replace("\n", LS);
+}
+static String getVersion(String key) {
+if (ResourceBundleHelper.versionRB == null) {
+return System.getProperty("java.version");
+}
+return versionRB.getString(key).replace("\n", LS);
+}
+static String getSuggestedReplacement(String key) {
+return ResourceBundleHelper.jdkinternals.getString(key).replace("\n", LS);
 }
 }
 /**
 * Returns the recommended replacement API for the given classname;
 private Optional<String> replacementFor(String cn) {
 String name = cn;
 String value = null;
 while (value == null && name != null) {
 try {
-value = ResourceBundleHelper.jdkinternals.getString(name);
+value = ResourceBundleHelper.getSuggestedReplacement(name);
 } catch (MissingResourceException e) {
 // go up one subpackage level
 int i = name.lastIndexOf('.');
 name = i > 0 ? name.substring(0, i) : null;
 }

changeset 52650	c16b6cc93272
parent 48543	7067fe4e054e