| /* |
| * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package com.sun.tools.jdeps; |
| |
| import static com.sun.tools.jdeps.Analyzer.Type.*; |
| import static com.sun.tools.jdeps.JdepsWriter.*; |
| import static com.sun.tools.jdeps.ModuleAnalyzer.Graph; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.lang.module.ResolutionException; |
| import java.nio.file.DirectoryStream; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.MissingResourceException; |
| import java.util.Optional; |
| import java.util.ResourceBundle; |
| import java.util.Set; |
| import java.util.TreeMap; |
| import java.util.regex.Pattern; |
| import java.util.stream.Collectors; |
| import java.util.stream.Stream; |
| |
| /** |
| * Implementation for the jdeps tool for static class dependency analysis. |
| */ |
| class JdepsTask { |
| static class BadArgs extends Exception { |
| static final long serialVersionUID = 8765093759964640721L; |
| BadArgs(String key, Object... args) { |
| super(JdepsTask.getMessage(key, args)); |
| this.key = key; |
| this.args = args; |
| } |
| |
| BadArgs showUsage(boolean b) { |
| showUsage = b; |
| return this; |
| } |
| final String key; |
| final Object[] args; |
| boolean showUsage; |
| } |
| |
| static abstract class Option { |
| Option(boolean hasArg, String... aliases) { |
| this.hasArg = hasArg; |
| this.aliases = aliases; |
| } |
| |
| boolean isHidden() { |
| return false; |
| } |
| |
| boolean matches(String opt) { |
| for (String a : aliases) { |
| if (a.equals(opt)) |
| return true; |
| if (hasArg && opt.startsWith(a + "=")) |
| return true; |
| } |
| return false; |
| } |
| |
| boolean ignoreRest() { |
| return false; |
| } |
| |
| abstract void process(JdepsTask task, String opt, String arg) throws BadArgs; |
| final boolean hasArg; |
| final String[] aliases; |
| } |
| |
| static abstract class HiddenOption extends Option { |
| HiddenOption(boolean hasArg, String... aliases) { |
| super(hasArg, aliases); |
| } |
| |
| boolean isHidden() { |
| return true; |
| } |
| } |
| |
| static Option[] recognizedOptions = { |
| new Option(false, "-h", "-?", "-help") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.help = true; |
| } |
| }, |
| new Option(true, "-dotoutput") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| Path p = Paths.get(arg); |
| if (Files.exists(p) && (!Files.isDirectory(p) || !Files.isWritable(p))) { |
| throw new BadArgs("err.invalid.path", arg); |
| } |
| task.options.dotOutputDir = arg; |
| } |
| }, |
| new Option(false, "-s", "-summary") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.showSummary = true; |
| task.options.verbose = SUMMARY; |
| } |
| }, |
| new Option(false, "-v", "-verbose", |
| "-verbose:package", |
| "-verbose:class") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| switch (opt) { |
| case "-v": |
| case "-verbose": |
| task.options.verbose = VERBOSE; |
| task.options.filterSameArchive = false; |
| task.options.filterSamePackage = false; |
| break; |
| case "-verbose:package": |
| task.options.verbose = PACKAGE; |
| break; |
| case "-verbose:class": |
| task.options.verbose = CLASS; |
| break; |
| default: |
| throw new BadArgs("err.invalid.arg.for.option", opt); |
| } |
| } |
| }, |
| new Option(true, "-p", "-package") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.packageNames.add(arg); |
| } |
| }, |
| new Option(true, "-e", "-regex") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.regex = Pattern.compile(arg); |
| } |
| }, |
| new Option(true, "-module") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.requires.add(arg); |
| } |
| }, |
| new Option(true, "-f", "-filter") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.filterRegex = Pattern.compile(arg); |
| } |
| }, |
| new Option(false, "-filter:package", |
| "-filter:archive", "-filter:module", |
| "-filter:none") { |
| void process(JdepsTask task, String opt, String arg) { |
| switch (opt) { |
| case "-filter:package": |
| task.options.filterSamePackage = true; |
| task.options.filterSameArchive = false; |
| break; |
| case "-filter:archive": |
| case "-filter:module": |
| task.options.filterSameArchive = true; |
| task.options.filterSamePackage = false; |
| break; |
| case "-filter:none": |
| task.options.filterSameArchive = false; |
| task.options.filterSamePackage = false; |
| break; |
| } |
| } |
| }, |
| new Option(true, "-include") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| task.options.includePattern = Pattern.compile(arg); |
| } |
| }, |
| new Option(false, "-P", "-profile") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| task.options.showProfile = true; |
| task.options.showModule = false; |
| } |
| }, |
| new Option(false, "-M") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| task.options.showModule = true; |
| task.options.showProfile = false; |
| } |
| }, |
| new Option(false, "-apionly") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.apiOnly = true; |
| } |
| }, |
| new Option(false, "-R", "-recursive") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.depth = 0; |
| // turn off filtering |
| task.options.filterSameArchive = false; |
| task.options.filterSamePackage = false; |
| } |
| }, |
| new Option(true, "-genmoduleinfo") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| Path p = Paths.get(arg); |
| if (Files.exists(p) && (!Files.isDirectory(p) || !Files.isWritable(p))) { |
| throw new BadArgs("err.invalid.path", arg); |
| } |
| task.options.genModuleInfo = arg; |
| } |
| }, |
| new Option(false, "-ct", "-compile-time") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.compileTimeView = true; |
| task.options.filterSamePackage = true; |
| task.options.filterSameArchive = true; |
| task.options.depth = 0; |
| } |
| }, |
| new Option(false, "-jdkinternals") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.findJDKInternals = true; |
| task.options.verbose = CLASS; |
| if (task.options.includePattern == null) { |
| task.options.includePattern = Pattern.compile(".*"); |
| } |
| } |
| }, |
| new Option(true, "-cp", "-classpath") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.classpath = arg; |
| } |
| }, |
| new Option(true, "-mp", "-modulepath") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| task.options.modulePath = arg; |
| task.options.showModule = true; |
| } |
| }, |
| new Option(true, "-upgrademodulepath") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| task.options.upgradeModulePath = arg; |
| task.options.showModule = true; |
| } |
| }, |
| new Option(true, "-m") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| task.options.rootModule = arg; |
| task.options.includes.add(arg); |
| task.options.showModule = true; |
| } |
| }, |
| new Option(false, "-check") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| task.options.checkModuleDeps = true; |
| } |
| }, |
| new HiddenOption(true, "-include-modules") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| Arrays.stream(arg.split(",")) |
| .forEach(task.options.includes::add); |
| task.options.showModule = true; |
| } |
| }, |
| new HiddenOption(true, "-exclude-modules") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| Arrays.stream(arg.split(",")) |
| .forEach(task.options.excludes::add); |
| task.options.showModule = true; |
| } |
| }, |
| new Option(false, "-q", "-quiet") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.nowarning = true; |
| } |
| }, |
| |
| new Option(false, "-version") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.version = true; |
| } |
| }, |
| new HiddenOption(false, "-fullversion") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.fullVersion = true; |
| } |
| }, |
| new HiddenOption(false, "-showlabel") { |
| void process(JdepsTask task, String opt, String arg) { |
| task.options.showLabel = true; |
| } |
| }, |
| |
| new HiddenOption(true, "-depth") { |
| void process(JdepsTask task, String opt, String arg) throws BadArgs { |
| try { |
| task.options.depth = Integer.parseInt(arg); |
| } catch (NumberFormatException e) { |
| throw new BadArgs("err.invalid.arg.for.option", opt); |
| } |
| } |
| }, |
| }; |
| |
| private static final String PROGNAME = "jdeps"; |
| private final Options options = new Options(); |
| private final List<String> classes = new ArrayList<>(); |
| |
| private PrintWriter log; |
| void setLog(PrintWriter out) { |
| log = out; |
| } |
| |
| /** |
| * Result codes. |
| */ |
| static final int EXIT_OK = 0, // Completed with no errors. |
| EXIT_ERROR = 1, // Completed but reported errors. |
| EXIT_CMDERR = 2, // Bad command-line arguments |
| EXIT_SYSERR = 3, // System error or resource exhaustion. |
| EXIT_ABNORMAL = 4;// terminated abnormally |
| |
| int run(String[] args) { |
| if (log == null) { |
| log = new PrintWriter(System.out); |
| } |
| try { |
| handleOptions(args); |
| if (options.help) { |
| showHelp(); |
| } |
| if (options.version || options.fullVersion) { |
| showVersion(options.fullVersion); |
| } |
| if (options.rootModule != null && !classes.isEmpty()) { |
| reportError("err.invalid.module.option", options.rootModule, classes); |
| return EXIT_CMDERR; |
| } |
| if (options.checkModuleDeps && options.rootModule == null) { |
| reportError("err.root.module.not.set"); |
| return EXIT_CMDERR; |
| } |
| if (classes.isEmpty() && options.rootModule == null && options.includePattern == null) { |
| if (options.help || options.version || options.fullVersion) { |
| return EXIT_OK; |
| } else { |
| showHelp(); |
| return EXIT_CMDERR; |
| } |
| } |
| if (options.genModuleInfo != null) { |
| if (options.dotOutputDir != null || !options.classpath.isEmpty() || options.hasFilter()) { |
| showHelp(); |
| return EXIT_CMDERR; |
| } |
| // default to compile time view analysis |
| options.compileTimeView = true; |
| for (String fn : classes) { |
| Path p = Paths.get(fn); |
| if (!Files.exists(p) || !fn.endsWith(".jar")) { |
| reportError("err.genmoduleinfo.not.jarfile", fn); |
| return EXIT_CMDERR; |
| } |
| } |
| } |
| |
| if (options.numFilters() > 1) { |
| reportError("err.invalid.filters"); |
| return EXIT_CMDERR; |
| } |
| |
| if ((options.findJDKInternals) && (options.hasFilter() || options.showSummary)) { |
| showHelp(); |
| return EXIT_CMDERR; |
| } |
| if (options.showSummary && options.verbose != SUMMARY) { |
| showHelp(); |
| return EXIT_CMDERR; |
| } |
| |
| boolean ok = run(); |
| return ok ? EXIT_OK : EXIT_ERROR; |
| } catch (BadArgs e) { |
| reportError(e.key, e.args); |
| if (e.showUsage) { |
| log.println(getMessage("main.usage.summary", PROGNAME)); |
| } |
| return EXIT_CMDERR; |
| } catch (ResolutionException e) { |
| reportError("err.exception.message", e.getMessage()); |
| return EXIT_CMDERR; |
| } catch (IOException e) { |
| e.printStackTrace(); |
| return EXIT_ABNORMAL; |
| } finally { |
| log.flush(); |
| } |
| } |
| |
| private ModulePaths modulePaths; |
| private boolean run() throws BadArgs, IOException { |
| DependencyFinder dependencyFinder = |
| new DependencyFinder(options.compileTimeView); |
| |
| buildArchive(dependencyFinder); |
| |
| if (options.rootModule != null && |
| (options.checkModuleDeps || (options.dotOutputDir != null && |
| options.verbose == SUMMARY))) { |
| // -dotfile -s prints the configuration of the given root |
| // -checkModuleDeps prints the suggested module-info.java |
| return analyzeModules(dependencyFinder); |
| } |
| |
| // otherwise analyze the dependencies |
| if (options.genModuleInfo != null) { |
| return genModuleInfo(dependencyFinder); |
| } else { |
| return analyzeDeps(dependencyFinder); |
| } |
| } |
| |
| private void buildArchive(DependencyFinder dependencyFinder) |
| throws BadArgs, IOException |
| { |
| // If -genmoduleinfo is specified, the input arguments must be JAR files |
| // Treat them as automatic modules for analysis |
| List<Path> jarfiles = options.genModuleInfo != null |
| ? classes.stream().map(Paths::get) |
| .collect(Collectors.toList()) |
| : Collections.emptyList(); |
| // Set module paths |
| this.modulePaths = new ModulePaths(options.upgradeModulePath, options.modulePath, jarfiles); |
| |
| // add modules to dependency finder for analysis |
| Map<String, Module> modules = modulePaths.getModules(); |
| modules.values().stream() |
| .forEach(dependencyFinder::addModule); |
| |
| // If -m option is set, add the specified module and its transitive dependences |
| // to the root set |
| if (options.rootModule != null) { |
| modulePaths.dependences(options.rootModule) |
| .forEach(dependencyFinder::addRoot); |
| } |
| |
| // check if any module specified in -requires is missing |
| Optional<String> req = options.requires.stream() |
| .filter(mn -> !modules.containsKey(mn)) |
| .findFirst(); |
| if (req.isPresent()) { |
| throw new BadArgs("err.module.not.found", req.get()); |
| } |
| |
| // classpath |
| for (Path p : getClassPaths(options.classpath)) { |
| if (Files.exists(p)) { |
| dependencyFinder.addClassPathArchive(p); |
| } |
| } |
| |
| // if -genmoduleinfo is not set, the input arguments are considered as |
| // unnamed module. Add them to the root set |
| if (options.genModuleInfo == null) { |
| // add root set |
| for (String s : classes) { |
| Path p = Paths.get(s); |
| if (Files.exists(p)) { |
| // add to the initial root set |
| dependencyFinder.addRoot(p); |
| } else { |
| if (isValidClassName(s)) { |
| dependencyFinder.addClassName(s); |
| } else { |
| warning("warn.invalid.arg", s); |
| } |
| } |
| } |
| } |
| } |
| |
| private boolean analyzeDeps(DependencyFinder dependencyFinder) throws IOException { |
| JdepsFilter filter = dependencyFilter(); |
| |
| // parse classfiles and find all dependencies |
| findDependencies(dependencyFinder, filter, options.apiOnly); |
| |
| // analyze the dependencies collected |
| Analyzer analyzer = new Analyzer(options.verbose, filter); |
| analyzer.run(dependencyFinder.archives()); |
| |
| // output result |
| final JdepsWriter writer; |
| if (options.dotOutputDir != null) { |
| Path dir = Paths.get(options.dotOutputDir); |
| Files.createDirectories(dir); |
| writer = new DotFileWriter(dir, options.verbose, |
| options.showProfile, |
| options.showModule, |
| options.showLabel); |
| } else { |
| writer = new SimpleWriter(log, options.verbose, |
| options.showProfile, |
| options.showModule); |
| } |
| |
| // Targets for reporting - include the root sets and other analyzed archives |
| final List<Archive> targets; |
| if (options.rootModule == null) { |
| // no module as the root set |
| targets = dependencyFinder.archives() |
| .filter(filter::accept) |
| .filter(a -> !a.getModule().isNamed()) |
| .collect(Collectors.toList()); |
| } else { |
| // named modules in topological order |
| Stream<Module> modules = dependencyFinder.archives() |
| .filter(a -> a.getModule().isNamed()) |
| .map(Archive::getModule); |
| Graph<Module> graph = ModuleAnalyzer.graph(modulePaths, modules.toArray(Module[]::new)); |
| // then add unnamed module |
| targets = graph.orderedNodes() |
| .filter(filter::accept) |
| .collect(Collectors.toList()); |
| |
| // in case any reference not found |
| dependencyFinder.archives() |
| .filter(a -> !a.getModule().isNamed()) |
| .forEach(targets::add); |
| } |
| |
| writer.generateOutput(targets, analyzer); |
| if (options.findJDKInternals && !options.nowarning) { |
| showReplacements(targets, analyzer); |
| } |
| return true; |
| } |
| |
| private JdepsFilter dependencyFilter() { |
| // Filter specified by -filter, -package, -regex, and -module options |
| JdepsFilter.Builder builder = new JdepsFilter.Builder(); |
| |
| // Exclude JDK modules from analysis and reporting if -m specified. |
| modulePaths.getModules().values().stream() |
| .filter(m -> m.isJDK()) |
| .map(Module::name) |
| .forEach(options.excludes::add); |
| |
| // source filters |
| builder.includePattern(options.includePattern); |
| builder.includeModules(options.includes); |
| builder.excludeModules(options.excludes); |
| |
| builder.filter(options.filterSamePackage, options.filterSameArchive); |
| builder.findJDKInternals(options.findJDKInternals); |
| |
| // -module |
| if (!options.requires.isEmpty()) { |
| Map<String, Module> modules = modulePaths.getModules(); |
| builder.packages(options.requires.stream() |
| .map(modules::get) |
| .flatMap(m -> m.packages().stream()) |
| .collect(Collectors.toSet())); |
| } |
| // -regex |
| if (options.regex != null) |
| builder.regex(options.regex); |
| // -package |
| if (!options.packageNames.isEmpty()) |
| builder.packages(options.packageNames); |
| // -filter |
| if (options.filterRegex != null) |
| builder.filter(options.filterRegex); |
| |
| return builder.build(); |
| } |
| |
| private void findDependencies(DependencyFinder dependencyFinder, |
| JdepsFilter filter, |
| boolean apiOnly) |
| throws IOException |
| { |
| dependencyFinder.findDependencies(filter, apiOnly, options.depth); |
| |
| // print skipped entries, if any |
| for (Archive a : dependencyFinder.roots()) { |
| for (String name : a.reader().skippedEntries()) { |
| warning("warn.skipped.entry", name, a.getPathName()); |
| } |
| } |
| } |
| |
| private boolean genModuleInfo(DependencyFinder dependencyFinder) throws IOException { |
| ModuleInfoBuilder builder = new ModuleInfoBuilder(modulePaths, dependencyFinder); |
| boolean result = builder.run(options.verbose, options.nowarning); |
| builder.build(Paths.get(options.genModuleInfo)); |
| return result; |
| } |
| |
| private boolean analyzeModules(DependencyFinder dependencyFinder) |
| throws IOException |
| { |
| ModuleAnalyzer analyzer = new ModuleAnalyzer(modulePaths, |
| dependencyFinder, |
| options.rootModule); |
| if (options.checkModuleDeps) { |
| return analyzer.run(); |
| } |
| if (options.dotOutputDir != null && options.verbose == SUMMARY) { |
| Path dir = Paths.get(options.dotOutputDir); |
| Files.createDirectories(dir); |
| analyzer.genDotFile(dir); |
| return true; |
| } |
| return false; |
| } |
| |
| private boolean isValidClassName(String name) { |
| if (!Character.isJavaIdentifierStart(name.charAt(0))) { |
| return false; |
| } |
| for (int i=1; i < name.length(); i++) { |
| char c = name.charAt(i); |
| if (c != '.' && !Character.isJavaIdentifierPart(c)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| 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]; |
| Option option = getOption(name); |
| String param = null; |
| if (option.hasArg) { |
| if (name.startsWith("-") && name.indexOf('=') > 0) { |
| param = name.substring(name.indexOf('=') + 1, name.length()); |
| } else if (i + 1 < args.length) { |
| param = args[++i]; |
| } |
| if (param == null || param.isEmpty() || param.charAt(0) == '-') { |
| throw new BadArgs("err.missing.arg", name).showUsage(true); |
| } |
| } |
| option.process(this, name, param); |
| if (option.ignoreRest()) { |
| i = args.length; |
| } |
| } else { |
| // process rest of the input arguments |
| for (; i < args.length; i++) { |
| String name = args[i]; |
| if (name.charAt(0) == '-') { |
| throw new BadArgs("err.option.after.class", name).showUsage(true); |
| } |
| classes.add(name); |
| } |
| } |
| } |
| } |
| |
| private Option getOption(String name) throws BadArgs { |
| for (Option o : recognizedOptions) { |
| if (o.matches(name)) { |
| return o; |
| } |
| } |
| throw new BadArgs("err.unknown.option", name).showUsage(true); |
| } |
| |
| private void reportError(String key, Object... args) { |
| log.println(getMessage("error.prefix") + " " + getMessage(key, args)); |
| } |
| |
| private void warning(String key, Object... args) { |
| log.println(getMessage("warn.prefix") + " " + getMessage(key, args)); |
| } |
| |
| private void showHelp() { |
| log.println(getMessage("main.usage", PROGNAME)); |
| for (Option o : recognizedOptions) { |
| String name = o.aliases[0].substring(1); // there must always be at least one name |
| name = name.charAt(0) == '-' ? name.substring(1) : name; |
| if (o.isHidden() || name.equals("h") || name.startsWith("filter:")) { |
| continue; |
| } |
| log.println(getMessage("main.opt." + name)); |
| } |
| } |
| |
| private void showVersion(boolean full) { |
| log.println(version(full ? "full" : "release")); |
| } |
| |
| 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); |
| } 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); |
| } catch (MissingResourceException e) { |
| throw new InternalError("Missing message: " + key); |
| } |
| } |
| |
| private static class Options { |
| boolean help; |
| boolean version; |
| boolean fullVersion; |
| boolean showProfile; |
| boolean showModule; |
| boolean showSummary; |
| boolean apiOnly; |
| boolean showLabel; |
| boolean findJDKInternals; |
| boolean nowarning = false; |
| // default is to show package-level dependencies |
| // and filter references from same package |
| Analyzer.Type verbose = PACKAGE; |
| boolean filterSamePackage = true; |
| boolean filterSameArchive = false; |
| Pattern filterRegex; |
| String dotOutputDir; |
| String genModuleInfo; |
| String classpath = ""; |
| int depth = 1; |
| Set<String> requires = new HashSet<>(); |
| Set<String> packageNames = new HashSet<>(); |
| Pattern regex; // apply to the dependences |
| Pattern includePattern; // apply to classes |
| boolean compileTimeView = false; |
| boolean checkModuleDeps = false; |
| String upgradeModulePath; |
| String modulePath; |
| String rootModule; |
| // modules to be included or excluded |
| Set<String> includes = new HashSet<>(); |
| Set<String> excludes = new HashSet<>(); |
| |
| boolean hasFilter() { |
| return numFilters() > 0; |
| } |
| |
| int numFilters() { |
| int count = 0; |
| if (requires.size() > 0) count++; |
| if (regex != null) count++; |
| if (packageNames.size() > 0) count++; |
| return count; |
| } |
| |
| boolean isRootModule() { |
| return rootModule != null; |
| } |
| } |
| private static class ResourceBundleHelper { |
| static final ResourceBundle versionRB; |
| static final ResourceBundle bundle; |
| static final ResourceBundle jdkinternals; |
| |
| static { |
| Locale locale = Locale.getDefault(); |
| try { |
| bundle = ResourceBundle.getBundle("com.sun.tools.jdeps.resources.jdeps", locale); |
| } catch (MissingResourceException e) { |
| throw new InternalError("Cannot find jdeps resource bundle for locale " + locale); |
| } |
| try { |
| versionRB = ResourceBundle.getBundle("com.sun.tools.jdeps.resources.version"); |
| } catch (MissingResourceException e) { |
| throw new InternalError("version.resource.missing"); |
| } |
| try { |
| jdkinternals = ResourceBundle.getBundle("com.sun.tools.jdeps.resources.jdkinternals"); |
| } catch (MissingResourceException e) { |
| throw new InternalError("Cannot find jdkinternals resource bundle"); |
| } |
| } |
| } |
| |
| /* |
| * Returns the list of Archive specified in cpaths and not included |
| * initialArchives |
| */ |
| private List<Path> getClassPaths(String cpaths) throws IOException |
| { |
| if (cpaths.isEmpty()) { |
| return Collections.emptyList(); |
| } |
| List<Path> paths = new ArrayList<>(); |
| for (String p : cpaths.split(File.pathSeparator)) { |
| if (p.length() > 0) { |
| // wildcard to parse all JAR files e.g. -classpath dir/* |
| int i = p.lastIndexOf(".*"); |
| if (i > 0) { |
| Path dir = Paths.get(p.substring(0, i)); |
| try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, "*.jar")) { |
| for (Path entry : stream) { |
| paths.add(entry); |
| } |
| } |
| } else { |
| paths.add(Paths.get(p)); |
| } |
| } |
| } |
| return paths; |
| } |
| |
| /** |
| * Returns the recommended replacement API for the given classname; |
| * or return null if replacement API is not known. |
| */ |
| private String replacementFor(String cn) { |
| String name = cn; |
| String value = null; |
| while (value == null && name != null) { |
| try { |
| value = ResourceBundleHelper.jdkinternals.getString(name); |
| } catch (MissingResourceException e) { |
| // go up one subpackage level |
| int i = name.lastIndexOf('.'); |
| name = i > 0 ? name.substring(0, i) : null; |
| } |
| } |
| return value; |
| }; |
| |
| private void showReplacements(List<Archive> archives, Analyzer analyzer) { |
| Map<String,String> jdkinternals = new TreeMap<>(); |
| boolean useInternals = false; |
| for (Archive source : archives) { |
| useInternals = useInternals || analyzer.hasDependences(source); |
| for (String cn : analyzer.dependences(source)) { |
| String repl = replacementFor(cn); |
| if (repl != null) { |
| jdkinternals.putIfAbsent(cn, repl); |
| } |
| } |
| } |
| if (useInternals) { |
| log.println(); |
| warning("warn.replace.useJDKInternals", getMessage("jdeps.wiki.url")); |
| } |
| if (!jdkinternals.isEmpty()) { |
| log.println(); |
| log.format("%-40s %s%n", "JDK Internal API", "Suggested Replacement"); |
| log.format("%-40s %s%n", "----------------", "---------------------"); |
| for (Map.Entry<String,String> e : jdkinternals.entrySet()) { |
| log.format("%-40s %s%n", e.getKey(), e.getValue()); |
| } |
| } |
| } |
| |
| } |
