1 /*
   2  * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.jdeps;
  27 
  28 import com.sun.tools.jdeps.Analyzer.Type;
  29 import static com.sun.tools.jdeps.Analyzer.Type.*;
  30 import static com.sun.tools.jdeps.JdepsWriter.*;
  31 import static java.util.stream.Collectors.*;
  32 
  33 import java.io.IOException;
  34 import java.io.PrintWriter;
  35 import java.lang.module.ResolutionException;
  36 import java.nio.file.Files;
  37 import java.nio.file.Path;
  38 import java.nio.file.Paths;
  39 import java.text.MessageFormat;
  40 import java.util.*;
  41 import java.util.jar.JarFile;
  42 import java.util.regex.Pattern;
  43 import java.util.stream.Collectors;
  44 import java.util.stream.Stream;
  45 
  46 /**
  47  * Implementation for the jdeps tool for static class dependency analysis.
  48  */
  49 class JdepsTask {
  50     static interface BadArguments {
  51         String getKey();
  52         Object[] getArgs();
  53         boolean showUsage();
  54     }
  55     static class BadArgs extends Exception implements BadArguments {
  56         static final long serialVersionUID = 8765093759964640721L;
  57         BadArgs(String key, Object... args) {
  58             super(JdepsTask.getMessage(key, args));
  59             this.key = key;
  60             this.args = args;
  61         }
  62 
  63         BadArgs showUsage(boolean b) {
  64             showUsage = b;
  65             return this;
  66         }
  67         final String key;
  68         final Object[] args;
  69         boolean showUsage;
  70 
  71         @Override
  72         public String getKey() {
  73             return key;
  74         }
  75 
  76         @Override
  77         public Object[] getArgs() {
  78             return args;
  79         }
  80 
  81         @Override
  82         public boolean showUsage() {
  83             return showUsage;
  84         }
  85     }
  86 
  87     static class UncheckedBadArgs extends RuntimeException implements BadArguments {
  88         static final long serialVersionUID = -1L;
  89         final BadArgs cause;
  90         UncheckedBadArgs(BadArgs cause) {
  91             super(cause);
  92             this.cause = cause;
  93         }
  94         @Override
  95         public String getKey() {
  96             return cause.key;
  97         }
  98 
  99         @Override
 100         public Object[] getArgs() {
 101             return cause.args;
 102         }
 103 
 104         @Override
 105         public boolean showUsage() {
 106             return cause.showUsage;
 107         }
 108     }
 109 
 110     static abstract class Option {
 111         Option(boolean hasArg, String... aliases) {
 112             this.hasArg = hasArg;
 113             this.aliases = aliases;
 114         }
 115 
 116         Option(boolean hasArg, CommandOption cmd) {
 117             this(hasArg, cmd.names());
 118         }
 119 
 120         boolean isHidden() {
 121             return false;
 122         }
 123 
 124         boolean matches(String opt) {
 125             for (String a : aliases) {
 126                 if (a.equals(opt))
 127                     return true;
 128                 if (hasArg && opt.startsWith(a + "="))
 129                     return true;
 130             }
 131             return false;
 132         }
 133 
 134         boolean ignoreRest() {
 135             return false;
 136         }
 137 
 138         abstract void process(JdepsTask task, String opt, String arg) throws BadArgs;
 139         final boolean hasArg;
 140         final String[] aliases;
 141     }
 142 
 143     static abstract class HiddenOption extends Option {
 144         HiddenOption(boolean hasArg, String... aliases) {
 145             super(hasArg, aliases);
 146         }
 147 
 148         boolean isHidden() {
 149             return true;
 150         }
 151     }
 152 
 153     enum CommandOption {
 154         ANALYZE_DEPS(""),
 155         GENERATE_DOT_FILE("-dotoutput", "--dot-output"),
 156         GENERATE_MODULE_INFO("--generate-module-info"),
 157         GENERATE_OPEN_MODULE("--generate-open-module"),
 158         LIST_DEPS("--list-deps"),
 159         LIST_REDUCED_DEPS("--list-reduced-deps"),
 160         CHECK_MODULES("--check");
 161 
 162         private final String[] names;
 163         CommandOption(String... names) {
 164             this.names = names;
 165         }
 166 
 167         String[] names() {
 168             return names;
 169         }
 170 
 171         @Override
 172         public String toString() {
 173             return names[0];
 174         }
 175     }
 176 
 177     static Option[] recognizedOptions = {
 178         new Option(false, "-h", "-?", "-help", "--help") {
 179             void process(JdepsTask task, String opt, String arg) {
 180                 task.options.help = true;
 181             }
 182         },
 183         new Option(true, CommandOption.GENERATE_DOT_FILE) {
 184             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 185                 if (task.command != null) {
 186                     throw new BadArgs("err.command.set", task.command, opt);
 187                 }
 188                 task.command = task.genDotFile(Paths.get(arg));
 189             }
 190         },
 191         new Option(false, "-s", "-summary") {
 192             void process(JdepsTask task, String opt, String arg) {
 193                 task.options.showSummary = true;
 194             }
 195         },
 196         new Option(false, "-v", "-verbose",
 197                                 "-verbose:module",
 198                                 "-verbose:package",
 199                                 "-verbose:class") {
 200             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 201                 switch (opt) {
 202                     case "-v":
 203                     case "-verbose":
 204                         task.options.verbose = VERBOSE;
 205                         task.options.filterSameArchive = false;
 206                         task.options.filterSamePackage = false;
 207                         break;
 208                     case "-verbose:module":
 209                         task.options.verbose = MODULE;
 210                         break;
 211                     case "-verbose:package":
 212                         task.options.verbose = PACKAGE;
 213                         break;
 214                     case "-verbose:class":
 215                         task.options.verbose = CLASS;
 216                         break;
 217                     default:
 218                         throw new BadArgs("err.invalid.arg.for.option", opt);
 219                 }
 220             }
 221         },
 222         new Option(false, "-apionly", "--api-only") {
 223             void process(JdepsTask task, String opt, String arg) {
 224                 task.options.apiOnly = true;
 225             }
 226         },
 227 
 228         new Option(false, "-jdkinternals", "--jdk-internals") {
 229             void process(JdepsTask task, String opt, String arg) {
 230                 task.options.findJDKInternals = true;
 231                 if (task.options.includePattern == null) {
 232                     task.options.includePattern = Pattern.compile(".*");
 233                 }
 234             }
 235         },
 236 
 237         new Option(true, CommandOption.CHECK_MODULES) {
 238             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 239                 if (task.command != null) {
 240                     throw new BadArgs("err.command.set", task.command, opt);
 241                 }
 242                 Set<String> mods =  Set.of(arg.split(","));
 243                 task.options.addmods.addAll(mods);
 244                 task.command = task.checkModuleDeps(mods);
 245             }
 246         },
 247         new Option(true, CommandOption.GENERATE_MODULE_INFO) {
 248             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 249                 if (task.command != null) {
 250                     throw new BadArgs("err.command.set", task.command, opt);
 251                 }
 252                 task.command = task.genModuleInfo(Paths.get(arg), false);
 253             }
 254         },
 255         new Option(true, CommandOption.GENERATE_OPEN_MODULE) {
 256             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 257                 if (task.command != null) {
 258                     throw new BadArgs("err.command.set", task.command, opt);
 259                 }
 260                 task.command = task.genModuleInfo(Paths.get(arg), true);
 261             }
 262         },
 263         new Option(false, CommandOption.LIST_DEPS) {
 264             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 265                 if (task.command != null) {
 266                     throw new BadArgs("err.command.set", task.command, opt);
 267                 }
 268                 task.command = task.listModuleDeps(false);
 269             }
 270         },
 271         new Option(false, CommandOption.LIST_REDUCED_DEPS) {
 272             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 273                 if (task.command != null) {
 274                     throw new BadArgs("err.command.set", task.command, opt);
 275                 }
 276                 task.command = task.listModuleDeps(true);
 277             }
 278         },
 279 
 280         // ---- paths option ----
 281         new Option(true, "-cp", "-classpath", "--class-path") {
 282             void process(JdepsTask task, String opt, String arg) {
 283                 task.options.classpath = arg;
 284             }
 285         },
 286         new Option(true, "--module-path") {
 287             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 288                 task.options.modulePath = arg;
 289             }
 290         },
 291         new Option(true, "--upgrade-module-path") {
 292             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 293                 task.options.upgradeModulePath = arg;
 294             }
 295         },
 296         new Option(true, "--system") {
 297             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 298                 if (arg.equals("none")) {
 299                     task.options.systemModulePath = null;
 300                 } else {
 301                     Path path = Paths.get(arg);
 302                     if (Files.isRegularFile(path.resolve("lib").resolve("modules")))
 303                         task.options.systemModulePath = arg;
 304                     else
 305                         throw new BadArgs("err.invalid.path", arg);
 306                 }
 307             }
 308         },
 309         new Option(true, "--add-modules") {
 310             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 311                 Set<String> mods = Set.of(arg.split(","));
 312                 task.options.addmods.addAll(mods);
 313             }
 314         },
 315         new Option(true, "-m", "--module") {
 316             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 317                 task.options.rootModule = arg;
 318                 task.options.addmods.add(arg);
 319             }
 320         },
 321         new Option(true, "--multi-release") {
 322             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 323                 if (arg.equalsIgnoreCase("base")) {
 324                     task.options.multiRelease = JarFile.baseVersion();
 325                 } else {
 326                     try {
 327                         int v = Integer.parseInt(arg);
 328                         if (v < 9) {
 329                             throw new BadArgs("err.invalid.arg.for.option", arg);
 330                         }
 331                     } catch (NumberFormatException x) {
 332                         throw new BadArgs("err.invalid.arg.for.option", arg);
 333                     }
 334                     task.options.multiRelease = Runtime.Version.parse(arg);
 335                 }
 336             }
 337         },
 338 
 339         // ---- Target filtering options ----
 340         new Option(true, "-p", "-package", "--package") {
 341             void process(JdepsTask task, String opt, String arg) {
 342                 task.options.packageNames.add(arg);
 343             }
 344         },
 345         new Option(true, "-e", "-regex", "--regex") {
 346             void process(JdepsTask task, String opt, String arg) {
 347                 task.options.regex = Pattern.compile(arg);
 348             }
 349         },
 350         new Option(true, "--require") {
 351             void process(JdepsTask task, String opt, String arg) {
 352                 task.options.requires.add(arg);
 353             }
 354         },
 355         new Option(true, "-f", "-filter") {
 356             void process(JdepsTask task, String opt, String arg) {
 357                 task.options.filterRegex = Pattern.compile(arg);
 358             }
 359         },
 360         new Option(false, "-filter:package",
 361                           "-filter:archive", "-filter:module",
 362                           "-filter:none") {
 363             void process(JdepsTask task, String opt, String arg) {
 364                 switch (opt) {
 365                     case "-filter:package":
 366                         task.options.filterSamePackage = true;
 367                         task.options.filterSameArchive = false;
 368                         break;
 369                     case "-filter:archive":
 370                     case "-filter:module":
 371                         task.options.filterSameArchive = true;
 372                         task.options.filterSamePackage = false;
 373                         break;
 374                     case "-filter:none":
 375                         task.options.filterSameArchive = false;
 376                         task.options.filterSamePackage = false;
 377                         break;
 378                 }
 379             }
 380         },
 381 
 382         // ---- Source filtering options ----
 383         new Option(true, "-include") {
 384             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 385                 task.options.includePattern = Pattern.compile(arg);
 386             }
 387         },
 388 
 389         // Another alternative to list modules in --add-modules option
 390         new HiddenOption(true, "--include-system-modules") {
 391             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 392                 task.options.includeSystemModulePattern = Pattern.compile(arg);
 393             }
 394         },
 395 
 396         new Option(false, "-P", "-profile") {
 397             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 398                 task.options.showProfile = true;
 399             }
 400         },
 401 
 402         new Option(false, "-R", "-recursive") {
 403             void process(JdepsTask task, String opt, String arg) {
 404                 task.options.depth = 0;
 405                 // turn off filtering
 406                 task.options.filterSameArchive = false;
 407                 task.options.filterSamePackage = false;
 408             }
 409         },
 410 
 411         new Option(false, "-I", "--inverse") {
 412             void process(JdepsTask task, String opt, String arg) {
 413                 task.options.inverse = true;
 414                 // equivalent to the inverse of compile-time view analysis
 415                 task.options.compileTimeView = true;
 416                 task.options.filterSamePackage = true;
 417                 task.options.filterSameArchive = true;
 418             }
 419         },
 420 
 421         new Option(false, "--compile-time") {
 422             void process(JdepsTask task, String opt, String arg) {
 423                 task.options.compileTimeView = true;
 424                 task.options.filterSamePackage = true;
 425                 task.options.filterSameArchive = true;
 426                 task.options.depth = 0;
 427             }
 428         },
 429 
 430         new Option(false, "-q", "-quiet") {
 431             void process(JdepsTask task, String opt, String arg) {
 432                 task.options.nowarning = true;
 433             }
 434         },
 435 
 436         new Option(false, "-version", "--version") {
 437             void process(JdepsTask task, String opt, String arg) {
 438                 task.options.version = true;
 439             }
 440         },
 441         new HiddenOption(false, "-fullversion") {
 442             void process(JdepsTask task, String opt, String arg) {
 443                 task.options.fullVersion = true;
 444             }
 445         },
 446         new HiddenOption(false, "-showlabel") {
 447             void process(JdepsTask task, String opt, String arg) {
 448                 task.options.showLabel = true;
 449             }
 450         },
 451         new HiddenOption(false, "--hide-show-module") {
 452             void process(JdepsTask task, String opt, String arg) {
 453                 task.options.showModule = false;
 454             }
 455         },
 456         new HiddenOption(true, "-depth") {
 457             void process(JdepsTask task, String opt, String arg) throws BadArgs {
 458                 try {
 459                     task.options.depth = Integer.parseInt(arg);
 460                 } catch (NumberFormatException e) {
 461                     throw new BadArgs("err.invalid.arg.for.option", opt);
 462                 }
 463             }
 464         },
 465     };
 466 
 467     private static final String PROGNAME = "jdeps";
 468     private final Options options = new Options();
 469     private final List<String> inputArgs = new ArrayList<>();
 470 
 471     private Command command;
 472     private PrintWriter log;
 473     void setLog(PrintWriter out) {
 474         log = out;
 475     }
 476 
 477     /**
 478      * Result codes.
 479      */
 480     static final int EXIT_OK = 0,       // Completed with no errors.
 481                      EXIT_ERROR = 1,    // Completed but reported errors.
 482                      EXIT_CMDERR = 2,   // Bad command-line arguments
 483                      EXIT_SYSERR = 3,   // System error or resource exhaustion.
 484                      EXIT_ABNORMAL = 4; // terminated abnormally
 485 
 486     int run(String... args) {
 487         if (log == null) {
 488             log = new PrintWriter(System.out);
 489         }
 490         try {
 491             handleOptions(args);
 492             if (options.help) {
 493                 showHelp();
 494             }
 495             if (options.version || options.fullVersion) {
 496                 showVersion(options.fullVersion);
 497             }
 498             if (options.help || options.version || options.fullVersion) {
 499                 return EXIT_OK;
 500             }
 501 
 502             if (!inputArgs.isEmpty() && options.rootModule != null) {
 503                 reportError("err.invalid.arg.for.option", "-m");
 504             }
 505 
 506             if (options.numFilters() > 1) {
 507                 reportError("err.invalid.filters");
 508                 return EXIT_CMDERR;
 509             }
 510 
 511             // default command to analyze dependences
 512             if (command == null) {
 513                 command = analyzeDeps();
 514             }
 515             if (!command.checkOptions()) {
 516                 return EXIT_CMDERR;
 517             }
 518 
 519             boolean ok = run();
 520             return ok ? EXIT_OK : EXIT_ERROR;
 521 
 522         } catch (BadArgs|UncheckedBadArgs e) {
 523             reportError(e.getKey(), e.getArgs());
 524             if (e.showUsage()) {
 525                 log.println(getMessage("main.usage.summary", PROGNAME));
 526             }
 527             return EXIT_CMDERR;
 528         } catch (ResolutionException e) {
 529             reportError("err.exception.message", e.getMessage());
 530             return EXIT_CMDERR;
 531         } catch (IOException e) {
 532             e.printStackTrace();
 533             return EXIT_CMDERR;
 534         } catch (MultiReleaseException e) {
 535             reportError(e.getKey(), (Object)e.getMsg());
 536             return EXIT_CMDERR;  // could be EXIT_ABNORMAL sometimes
 537         } finally {
 538             log.flush();
 539         }
 540     }
 541 
 542     boolean run() throws IOException {
 543         try (JdepsConfiguration config = buildConfig(command.allModules())) {
 544 
 545             // detect split packages
 546             config.splitPackages().entrySet()
 547                 .stream()
 548                 .sorted(Map.Entry.comparingByKey())
 549                 .forEach(e -> log.println(getMessage("split.package",
 550                                                      e.getKey(),
 551                                                      e.getValue().toString())));
 552 
 553             // check if any module specified in --require is missing
 554             Stream.concat(options.addmods.stream(), options.requires.stream())
 555                 .filter(mn -> !config.isValidToken(mn))
 556                 .forEach(mn -> config.findModule(mn).orElseThrow(() ->
 557                     new UncheckedBadArgs(new BadArgs("err.module.not.found", mn))));
 558 
 559             return command.run(config);
 560         }
 561     }
 562 
 563     private JdepsConfiguration buildConfig(boolean allModules) throws IOException {
 564         JdepsConfiguration.Builder builder =
 565             new JdepsConfiguration.Builder(options.systemModulePath);
 566 
 567         builder.upgradeModulePath(options.upgradeModulePath)
 568                .appModulePath(options.modulePath)
 569                .addmods(options.addmods);
 570 
 571         if (allModules) {
 572             // check all system modules in the image
 573             builder.allModules();
 574         }
 575 
 576         if (options.classpath != null)
 577             builder.addClassPath(options.classpath);
 578 
 579         if (options.multiRelease != null)
 580             builder.multiRelease(options.multiRelease);
 581 
 582         // build the root set of archives to be analyzed
 583         for (String s : inputArgs) {
 584             Path p = Paths.get(s);
 585             if (Files.exists(p)) {
 586                 builder.addRoot(p);
 587             } else {
 588                 warning("warn.invalid.arg", s);
 589             }
 590         }
 591 
 592         return builder.build();
 593     }
 594 
 595     // ---- factory methods to create a Command
 596 
 597     private AnalyzeDeps analyzeDeps() throws BadArgs {
 598         return options.inverse ? new InverseAnalyzeDeps()
 599                                : new AnalyzeDeps();
 600     }
 601 
 602     private GenDotFile genDotFile(Path dir) throws BadArgs {
 603         if (Files.exists(dir) && (!Files.isDirectory(dir) || !Files.isWritable(dir))) {
 604             throw new BadArgs("err.invalid.path", dir.toString());
 605         }
 606         return new GenDotFile(dir);
 607     }
 608 
 609     private GenModuleInfo genModuleInfo(Path dir, boolean openModule) throws BadArgs {
 610         if (Files.exists(dir) && (!Files.isDirectory(dir) || !Files.isWritable(dir))) {
 611             throw new BadArgs("err.invalid.path", dir.toString());
 612         }
 613         return new GenModuleInfo(dir, openModule);
 614     }
 615 
 616     private ListModuleDeps listModuleDeps(boolean reduced) throws BadArgs {
 617         return reduced ? new ListReducedDeps()
 618                        : new ListModuleDeps();
 619     }
 620 
 621     private CheckModuleDeps checkModuleDeps(Set<String> mods) throws BadArgs {
 622         return new CheckModuleDeps(mods);
 623     }
 624 
 625     abstract class Command {
 626         final CommandOption option;
 627         protected Command(CommandOption option) {
 628             this.option = option;
 629         }
 630         /**
 631          * Returns true if the command-line options are all valid;
 632          * otherwise, returns false.
 633          */
 634         abstract boolean checkOptions();
 635 
 636         /**
 637          * Do analysis
 638          */
 639         abstract boolean run(JdepsConfiguration config) throws IOException;
 640 
 641         /**
 642          * Includes all modules on system module path and application module path
 643          */
 644         boolean allModules() {
 645             return false;
 646         }
 647 
 648         @Override
 649         public String toString() {
 650             return option.toString();
 651         }
 652     }
 653 
 654 
 655     /**
 656      * Analyze dependences
 657      */
 658     class AnalyzeDeps extends Command {
 659         JdepsWriter writer;
 660         AnalyzeDeps() {
 661             this(CommandOption.ANALYZE_DEPS);
 662         }
 663 
 664         AnalyzeDeps(CommandOption option) {
 665             super(option);
 666         }
 667 
 668         @Override
 669         boolean checkOptions() {
 670             if (options.findJDKInternals) {
 671                 // cannot set any filter, -verbose and -summary option
 672                 if (options.showSummary || options.verbose != null) {
 673                     reportError("err.invalid.options", "-summary or -verbose",
 674                                 "-jdkinternals");
 675                     return false;
 676                 }
 677                 if (options.hasFilter()) {
 678                     reportError("err.invalid.options", "--package, --regex, --require",
 679                                 "-jdkinternals");
 680                     return false;
 681                 }
 682             }
 683             if (options.showSummary) {
 684                 // -summary cannot use with -verbose option
 685                 if (options.verbose != null) {
 686                     reportError("err.invalid.options", "-v, -verbose", "-s, -summary");
 687                     return false;
 688                 }
 689             }
 690             if (inputArgs.isEmpty() && !options.hasSourcePath()) {
 691                 showHelp();
 692                 return false;
 693             }
 694             return true;
 695         }
 696 
 697         /*
 698          * Default is to show package-level dependencies
 699          */
 700         Type getAnalyzerType() {
 701             if (options.showSummary)
 702                 return Type.SUMMARY;
 703 
 704             if (options.findJDKInternals)
 705                 return Type.CLASS;
 706 
 707             // default to package-level verbose
 708            return options.verbose != null ? options.verbose : PACKAGE;
 709         }
 710 
 711         @Override
 712         boolean run(JdepsConfiguration config) throws IOException {
 713             Type type = getAnalyzerType();
 714             // default to package-level verbose
 715             JdepsWriter writer = new SimpleWriter(log,
 716                                                   type,
 717                                                   options.showProfile,
 718                                                   options.showModule);
 719 
 720             return run(config, writer, type);
 721         }
 722 
 723         boolean run(JdepsConfiguration config, JdepsWriter writer, Type type) throws IOException {
 724 
 725 
 726             // analyze the dependencies
 727             DepsAnalyzer analyzer = new DepsAnalyzer(config,
 728                                                      dependencyFilter(config),
 729                                                      writer,
 730                                                      type,
 731                                                      options.apiOnly);
 732 
 733             boolean ok = analyzer.run(options.compileTimeView, options.depth);
 734 
 735             // print skipped entries, if any
 736             if (!options.nowarning) {
 737                 analyzer.archives()
 738                     .forEach(archive -> archive.reader()
 739                         .skippedEntries().stream()
 740                         .forEach(name -> warning("warn.skipped.entry", name)));
 741             }
 742 
 743             if (options.findJDKInternals && !options.nowarning) {
 744                 Map<String, String> jdkInternals = new TreeMap<>();
 745                 Set<String> deps = analyzer.dependences();
 746                 // find the ones with replacement
 747                 deps.forEach(cn -> replacementFor(cn).ifPresent(
 748                     repl -> jdkInternals.put(cn, repl))
 749                 );
 750 
 751                 if (!deps.isEmpty()) {
 752                     log.println();
 753                     warning("warn.replace.useJDKInternals", getMessage("jdeps.wiki.url"));
 754                 }
 755 
 756                 if (!jdkInternals.isEmpty()) {
 757                     log.println();
 758                     String internalApiTitle = getMessage("internal.api.column.header");
 759                     String replacementApiTitle = getMessage("public.api.replacement.column.header");
 760                     log.format("%-40s %s%n", internalApiTitle, replacementApiTitle);
 761                     log.format("%-40s %s%n",
 762                                internalApiTitle.replaceAll(".", "-"),
 763                                replacementApiTitle.replaceAll(".", "-"));
 764                     jdkInternals.entrySet().stream()
 765                         .forEach(e -> {
 766                             String key = e.getKey();
 767                             String[] lines = e.getValue().split("\\n");
 768                             for (String s : lines) {
 769                                 log.format("%-40s %s%n", key, s);
 770                                 key = "";
 771                             }
 772                         });
 773                 }
 774             }
 775             return ok;
 776         }
 777     }
 778 
 779 
 780     class InverseAnalyzeDeps extends AnalyzeDeps {
 781         InverseAnalyzeDeps() {
 782         }
 783 
 784         @Override
 785         boolean checkOptions() {
 786             if (options.depth != 1) {
 787                 reportError("err.invalid.options", "-R", "--inverse");
 788                 return false;
 789             }
 790 
 791             if (options.numFilters() == 0) {
 792                 reportError("err.filter.not.specified");
 793                 return false;
 794             }
 795 
 796             if (!super.checkOptions()) {
 797                 return false;
 798             }
 799 
 800             return true;
 801         }
 802 
 803         @Override
 804         boolean run(JdepsConfiguration config) throws IOException {
 805             Type type = getAnalyzerType();
 806 
 807             InverseDepsAnalyzer analyzer =
 808                 new InverseDepsAnalyzer(config,
 809                                         dependencyFilter(config),
 810                                         writer,
 811                                         type,
 812                                         options.apiOnly);
 813             boolean ok = analyzer.run();
 814 
 815             log.println();
 816             if (!options.requires.isEmpty())
 817                 log.println(getMessage("inverse.transitive.dependencies.on",
 818                     options.requires));
 819             else
 820                 log.println(getMessage("inverse.transitive.dependencies.matching",
 821                     options.regex != null
 822                         ? options.regex.toString()
 823                         : "packages " + options.packageNames));
 824 
 825             analyzer.inverseDependences().stream()
 826                 .sorted(Comparator.comparing(this::sortPath))
 827                 .forEach(path -> log.println(path.stream()
 828                     .map(Archive::getName)
 829                     .collect(joining(" <- "))));
 830             return ok;
 831         }
 832 
 833         private String sortPath(Deque<Archive> path) {
 834             return path.peekFirst().getName();
 835         }
 836     }
 837 
 838 
 839     class GenModuleInfo extends Command {
 840         final Path dir;
 841         final boolean openModule;
 842         GenModuleInfo(Path dir, boolean openModule) {
 843             super(CommandOption.GENERATE_MODULE_INFO);
 844             this.dir = dir;
 845             this.openModule = openModule;
 846         }
 847 
 848         @Override
 849         boolean checkOptions() {
 850             if (options.classpath != null) {
 851                 reportError("err.invalid.options", "-classpath",
 852                             option);
 853                 return false;
 854             }
 855             if (options.hasFilter()) {
 856                 reportError("err.invalid.options", "--package, --regex, --require",
 857                             option);
 858                 return false;
 859             }
 860             return true;
 861         }
 862 
 863         @Override
 864         boolean run(JdepsConfiguration config) throws IOException {
 865             // check if any JAR file contains unnamed package
 866             for (String arg : inputArgs) {
 867                 try (ClassFileReader reader = ClassFileReader.newInstance(Paths.get(arg))) {
 868                     Optional<String> classInUnnamedPackage =
 869                         reader.entries().stream()
 870                              .filter(n -> n.endsWith(".class"))
 871                              .filter(cn -> toPackageName(cn).isEmpty())
 872                              .findFirst();
 873 
 874                     if (classInUnnamedPackage.isPresent()) {
 875                         if (classInUnnamedPackage.get().equals("module-info.class")) {
 876                             reportError("err.genmoduleinfo.not.jarfile", arg);
 877                         } else {
 878                             reportError("err.genmoduleinfo.unnamed.package", arg);
 879                         }
 880                         return false;
 881                     }
 882                 }
 883             }
 884 
 885             ModuleInfoBuilder builder
 886                  = new ModuleInfoBuilder(config, inputArgs, dir, openModule);
 887             boolean ok = builder.run();
 888 
 889             if (!ok && !options.nowarning) {
 890                 reportError("err.missing.dependences");
 891                 builder.visitMissingDeps(
 892                         (origin, originArchive, target, targetArchive) -> {
 893                             if (builder.notFound(targetArchive))
 894                                 log.format("   %-50s -> %-50s %s%n",
 895                                     origin, target, targetArchive.getName());
 896                         });
 897             }
 898             return ok;
 899         }
 900 
 901         private String toPackageName(String name) {
 902             int i = name.lastIndexOf('/');
 903             return i > 0 ? name.replace('/', '.').substring(0, i) : "";
 904         }
 905     }
 906 
 907     class CheckModuleDeps extends Command {
 908         final Set<String> modules;
 909         CheckModuleDeps(Set<String> mods) {
 910             super(CommandOption.CHECK_MODULES);
 911             this.modules = mods;
 912         }
 913 
 914         @Override
 915         boolean checkOptions() {
 916             if (!inputArgs.isEmpty()) {
 917                 reportError("err.invalid.options", inputArgs, "--check");
 918                 return false;
 919             }
 920             return true;
 921         }
 922 
 923         @Override
 924         boolean run(JdepsConfiguration config) throws IOException {
 925             if (!config.initialArchives().isEmpty()) {
 926                 String list = config.initialArchives().stream()
 927                                     .map(Archive::getPathName).collect(joining(" "));
 928                 throw new UncheckedBadArgs(new BadArgs("err.invalid.options",
 929                                                        list, "--check"));
 930             }
 931             return new ModuleAnalyzer(config, log, modules).run();
 932         }
 933 
 934         public boolean allModules() {
 935             return true;
 936         }
 937     }
 938 
 939     class ListReducedDeps extends ListModuleDeps {
 940         ListReducedDeps() {
 941             super(CommandOption.LIST_REDUCED_DEPS, true);
 942         }
 943     }
 944 
 945     class ListModuleDeps extends Command {
 946         final boolean reduced;
 947         ListModuleDeps() {
 948             this(CommandOption.LIST_DEPS, false);
 949         }
 950         ListModuleDeps(CommandOption option, boolean reduced) {
 951             super(option);
 952             this.reduced = reduced;
 953         }
 954 
 955         @Override
 956         boolean checkOptions() {
 957             if (options.showSummary || options.verbose != null) {
 958                 reportError("err.invalid.options", "-summary or -verbose",
 959                             option);
 960                 return false;
 961             }
 962             if (options.findJDKInternals) {
 963                 reportError("err.invalid.options", "-jdkinternals",
 964                             option);
 965                 return false;
 966             }
 967             if (inputArgs.isEmpty() && !options.hasSourcePath()) {
 968                 showHelp();
 969                 return false;
 970             }
 971             return true;
 972         }
 973 
 974         @Override
 975         boolean run(JdepsConfiguration config) throws IOException {
 976             return new ModuleExportsAnalyzer(config,
 977                                              dependencyFilter(config),
 978                                              reduced,
 979                                              log).run();
 980         }
 981 
 982         @Override
 983         boolean allModules() {
 984             return true;
 985         }
 986     }
 987 
 988 
 989     class GenDotFile extends AnalyzeDeps {
 990         final Path dotOutputDir;
 991         GenDotFile(Path dotOutputDir) {
 992             super(CommandOption.GENERATE_DOT_FILE);
 993 
 994             this.dotOutputDir = dotOutputDir;
 995         }
 996 
 997         @Override
 998         boolean run(JdepsConfiguration config) throws IOException {
 999             if ((options.showSummary || options.verbose == MODULE) &&
1000                 !options.addmods.isEmpty() && inputArgs.isEmpty()) {
1001                 // print module descriptor
1002                 return new ModuleAnalyzer(config, log).genDotFiles(dotOutputDir);
1003             }
1004 
1005             Type type = getAnalyzerType();
1006             JdepsWriter writer = new DotFileWriter(dotOutputDir,
1007                                                    type,
1008                                                    options.showProfile,
1009                                                    options.showModule,
1010                                                    options.showLabel);
1011             return run(config, writer, type);
1012         }
1013     }
1014 
1015     /**
1016      * Returns a filter used during dependency analysis
1017      */
1018     private JdepsFilter dependencyFilter(JdepsConfiguration config) {
1019         // Filter specified by -filter, -package, -regex, and --require options
1020         JdepsFilter.Builder builder = new JdepsFilter.Builder();
1021 
1022         // source filters
1023         builder.includePattern(options.includePattern);
1024         builder.includeSystemModules(options.includeSystemModulePattern);
1025 

1026         builder.filter(options.filterSamePackage, options.filterSameArchive);
1027         builder.findJDKInternals(options.findJDKInternals);
1028 
1029         // --require
1030         if (!options.requires.isEmpty()) {
1031             options.requires.stream()
1032                 .forEach(mn -> {
1033                     Module m = config.findModule(mn).get();
1034                     builder.requires(mn, m.packages());
1035                 });
1036         }
1037         // -regex
1038         if (options.regex != null)
1039             builder.regex(options.regex);
1040         // -package
1041         if (!options.packageNames.isEmpty())
1042             builder.packages(options.packageNames);
1043         // -filter
1044         if (options.filterRegex != null)
1045             builder.filter(options.filterRegex);
1046 
1047         // check if system module is set
1048         config.rootModules().stream()
1049               .map(Module::name)
1050               .forEach(builder::includeIfSystemModule);
1051 
1052         return builder.build();
1053     }
1054 
1055     public void handleOptions(String[] args) throws BadArgs {
1056         // process options
1057         for (int i=0; i < args.length; i++) {
1058             if (args[i].charAt(0) == '-') {
1059                 String name = args[i];
1060                 Option option = getOption(name);
1061                 String param = null;
1062                 if (option.hasArg) {
1063                     if (name.startsWith("-") && name.indexOf('=') > 0) {
1064                         param = name.substring(name.indexOf('=') + 1, name.length());
1065                     } else if (i + 1 < args.length) {
1066                         param = args[++i];
1067                     }
1068                     if (param == null || param.isEmpty() || param.charAt(0) == '-') {
1069                         throw new BadArgs("err.missing.arg", name).showUsage(true);
1070                     }
1071                 }
1072                 option.process(this, name, param);
1073                 if (option.ignoreRest()) {
1074                     i = args.length;
1075                 }
1076             } else {
1077                 // process rest of the input arguments
1078                 for (; i < args.length; i++) {
1079                     String name = args[i];
1080                     if (name.charAt(0) == '-') {
1081                         throw new BadArgs("err.option.after.class", name).showUsage(true);
1082                     }
1083                     inputArgs.add(name);
1084                 }
1085             }
1086         }
1087     }
1088 
1089     private Option getOption(String name) throws BadArgs {
1090         for (Option o : recognizedOptions) {
1091             if (o.matches(name)) {
1092                 return o;
1093             }
1094         }
1095         throw new BadArgs("err.unknown.option", name).showUsage(true);
1096     }
1097 
1098     private void reportError(String key, Object... args) {
1099         log.println(getMessage("error.prefix") + " " + getMessage(key, args));
1100     }
1101 
1102     void warning(String key, Object... args) {
1103         log.println(getMessage("warn.prefix") + " " + getMessage(key, args));
1104     }
1105 
1106     private void showHelp() {
1107         log.println(getMessage("main.usage", PROGNAME));
1108         for (Option o : recognizedOptions) {
1109             String name = o.aliases[0].substring(1); // there must always be at least one name
1110             name = name.charAt(0) == '-' ? name.substring(1) : name;
1111             if (o.isHidden() || name.equals("h") || name.startsWith("filter:")) {
1112                 continue;
1113             }
1114             log.println(getMessage("main.opt." + name));
1115         }
1116     }
1117 
1118     private void showVersion(boolean full) {
1119         log.println(version(full ? "full" : "release"));
1120     }
1121 
1122     private String version(String key) {
1123         // key=version:  mm.nn.oo[-milestone]
1124         // key=full:     mm.mm.oo[-milestone]-build
1125         if (ResourceBundleHelper.versionRB == null) {
1126             return System.getProperty("java.version");
1127         }
1128         try {
1129             return ResourceBundleHelper.versionRB.getString(key);
1130         } catch (MissingResourceException e) {
1131             return getMessage("version.unknown", System.getProperty("java.version"));
1132         }
1133     }
1134 
1135     static String getMessage(String key, Object... args) {
1136         try {
1137             return MessageFormat.format(ResourceBundleHelper.bundle.getString(key), args);
1138         } catch (MissingResourceException e) {
1139             throw new InternalError("Missing message: " + key);
1140         }
1141     }
1142 
1143     private static class Options {
1144         boolean help;
1145         boolean version;
1146         boolean fullVersion;
1147         boolean showProfile;
1148         boolean showModule = true;
1149         boolean showSummary;
1150         boolean apiOnly;
1151         boolean showLabel;
1152         boolean findJDKInternals;
1153         boolean nowarning = false;
1154         Analyzer.Type verbose;
1155         // default filter references from same package
1156         boolean filterSamePackage = true;
1157         boolean filterSameArchive = false;
1158         Pattern filterRegex;
1159         String classpath;
1160         int depth = 1;
1161         Set<String> requires = new HashSet<>();
1162         Set<String> packageNames = new HashSet<>();
1163         Pattern regex;             // apply to the dependences
1164         Pattern includePattern;
1165         Pattern includeSystemModulePattern;
1166         boolean inverse = false;
1167         boolean compileTimeView = false;
1168         String systemModulePath = System.getProperty("java.home");
1169         String upgradeModulePath;
1170         String modulePath;
1171         String rootModule;
1172         Set<String> addmods = new HashSet<>();
1173         Runtime.Version multiRelease;
1174 
1175         boolean hasSourcePath() {
1176             return !addmods.isEmpty() || includePattern != null ||
1177                         includeSystemModulePattern != null;
1178         }
1179 
1180         boolean hasFilter() {
1181             return numFilters() > 0;
1182         }
1183 
1184         int numFilters() {
1185             int count = 0;
1186             if (requires.size() > 0) count++;
1187             if (regex != null) count++;
1188             if (packageNames.size() > 0) count++;
1189             return count;
1190         }
1191     }
1192 
1193     private static class ResourceBundleHelper {
1194         static final ResourceBundle versionRB;
1195         static final ResourceBundle bundle;
1196         static final ResourceBundle jdkinternals;
1197 
1198         static {
1199             Locale locale = Locale.getDefault();
1200             try {
1201                 bundle = ResourceBundle.getBundle("com.sun.tools.jdeps.resources.jdeps", locale);
1202             } catch (MissingResourceException e) {
1203                 throw new InternalError("Cannot find jdeps resource bundle for locale " + locale);
1204             }
1205             try {
1206                 versionRB = ResourceBundle.getBundle("com.sun.tools.jdeps.resources.version");
1207             } catch (MissingResourceException e) {
1208                 throw new InternalError("version.resource.missing");
1209             }
1210             try {
1211                 jdkinternals = ResourceBundle.getBundle("com.sun.tools.jdeps.resources.jdkinternals");
1212             } catch (MissingResourceException e) {
1213                 throw new InternalError("Cannot find jdkinternals resource bundle");
1214             }
1215         }
1216     }
1217 
1218     /**
1219      * Returns the recommended replacement API for the given classname;
1220      * or return null if replacement API is not known.
1221      */
1222     private Optional<String> replacementFor(String cn) {
1223         String name = cn;
1224         String value = null;
1225         while (value == null && name != null) {
1226             try {
1227                 value = ResourceBundleHelper.jdkinternals.getString(name);
1228             } catch (MissingResourceException e) {
1229                 // go up one subpackage level
1230                 int i = name.lastIndexOf('.');
1231                 name = i > 0 ? name.substring(0, i) : null;
1232             }
1233         }
1234         return Optional.ofNullable(value);
1235     }
1236 }
--- EOF ---