1 /*
   2  * Copyright (c) 2006, 2016, 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.javac.main;
  27 
  28 import java.io.FileWriter;
  29 import java.io.PrintWriter;
  30 import java.nio.file.Files;
  31 import java.nio.file.Path;
  32 import java.nio.file.Paths;
  33 import java.text.Collator;
  34 import java.util.Arrays;
  35 import java.util.Collections;
  36 import java.util.Comparator;
  37 import java.util.EnumSet;
  38 import java.util.Iterator;
  39 import java.util.LinkedHashMap;
  40 import java.util.Locale;
  41 import java.util.Map;
  42 import java.util.ServiceLoader;
  43 import java.util.Set;
  44 import java.util.TreeSet;
  45 import java.util.stream.Collectors;
  46 import java.util.stream.StreamSupport;
  47 
  48 import javax.lang.model.SourceVersion;
  49 
  50 import com.sun.tools.doclint.DocLint;
  51 import com.sun.tools.javac.code.Lint;
  52 import com.sun.tools.javac.code.Lint.LintCategory;
  53 import com.sun.tools.javac.code.Source;
  54 import com.sun.tools.javac.code.Type;
  55 import com.sun.tools.javac.jvm.Profile;
  56 import com.sun.tools.javac.jvm.Target;
  57 import com.sun.tools.javac.platform.PlatformProvider;
  58 import com.sun.tools.javac.processing.JavacProcessingEnvironment;
  59 import com.sun.tools.javac.resources.CompilerProperties.Errors;
  60 import com.sun.tools.javac.util.Assert;
  61 import com.sun.tools.javac.util.JDK9Wrappers;
  62 import com.sun.tools.javac.util.Log;
  63 import com.sun.tools.javac.util.Log.PrefixKind;
  64 import com.sun.tools.javac.util.Log.WriterKind;
  65 import com.sun.tools.javac.util.Options;
  66 import com.sun.tools.javac.util.StringUtils;
  67 
  68 import static com.sun.tools.javac.main.Option.ChoiceKind.*;
  69 import static com.sun.tools.javac.main.Option.OptionGroup.*;
  70 import static com.sun.tools.javac.main.Option.OptionKind.*;
  71 
  72 /**
  73  * Options for javac.
  74  * The specific Option to handle a command-line option can be found by calling
  75  * {@link #lookup}, which search some or all of the members of this enum in order,
  76  * looking for the first {@link #matches match}.
  77  * The action for an Option is performed {@link #handleOption}, which determines
  78  * whether an argument is needed and where to find it;
  79  * {@code handleOption} then calls {@link #process process} providing a suitable
  80  * {@link OptionHelper} to provide access the compiler state.
  81  *
  82  * <p><b>This is NOT part of any supported API.
  83  * If you write code that depends on this, you do so at your own
  84  * risk.  This code and its internal interfaces are subject to change
  85  * or deletion without notice.</b></p>
  86  */
  87 public enum Option {
  88     G("-g", "opt.g", STANDARD, BASIC),
  89 
  90     G_NONE("-g:none", "opt.g.none", STANDARD, BASIC) {
  91         @Override
  92         public boolean process(OptionHelper helper, String option) {
  93             helper.put("-g:", "none");
  94             return false;
  95         }
  96     },
  97 
  98     G_CUSTOM("-g:",  "opt.g.lines.vars.source",
  99             STANDARD, BASIC, ANYOF, "lines", "vars", "source"),
 100 
 101     XLINT("-Xlint", "opt.Xlint", EXTENDED, BASIC),
 102 
 103     XLINT_CUSTOM("-Xlint:", "opt.arg.Xlint", "opt.Xlint.custom", EXTENDED, BASIC, ANYOF, getXLintChoices()) {
 104         private final String LINT_KEY_FORMAT = LARGE_INDENT + "  %-" +
 105                 (DEFAULT_SYNOPSIS_WIDTH + SMALL_INDENT.length() - LARGE_INDENT.length() - 2) + "s %s";
 106         @Override
 107         protected void help(Log log) {
 108             super.help(log);
 109             log.printRawLines(WriterKind.STDOUT,
 110                               String.format(LINT_KEY_FORMAT,
 111                                             "all",
 112                                             log.localize(PrefixKind.JAVAC, "opt.Xlint.all")));
 113             for (LintCategory lc : LintCategory.values()) {
 114                 if (lc.hidden) continue;
 115                 log.printRawLines(WriterKind.STDOUT,
 116                                   String.format(LINT_KEY_FORMAT,
 117                                                 lc.option,
 118                                                 log.localize(PrefixKind.JAVAC,
 119                                                              "opt.Xlint.desc." + lc.option)));
 120             }
 121             log.printRawLines(WriterKind.STDOUT,
 122                               String.format(LINT_KEY_FORMAT,
 123                                             "none",
 124                                             log.localize(PrefixKind.JAVAC, "opt.Xlint.none")));
 125         }
 126     },
 127 
 128     XDOCLINT("-Xdoclint", "opt.Xdoclint", EXTENDED, BASIC),
 129 
 130     XDOCLINT_CUSTOM("-Xdoclint:", "opt.Xdoclint.subopts", "opt.Xdoclint.custom", EXTENDED, BASIC) {
 131         @Override
 132         public boolean matches(String option) {
 133             return DocLint.isValidOption(
 134                     option.replace(XDOCLINT_CUSTOM.primaryName, DocLint.XMSGS_CUSTOM_PREFIX));
 135         }
 136 
 137         @Override
 138         public boolean process(OptionHelper helper, String option) {
 139             String prev = helper.get(XDOCLINT_CUSTOM);
 140             String next = (prev == null) ? option : (prev + " " + option);
 141             helper.put(XDOCLINT_CUSTOM.primaryName, next);
 142             return false;
 143         }
 144     },
 145 
 146     XDOCLINT_PACKAGE("-Xdoclint/package:", "opt.Xdoclint.package.args", "opt.Xdoclint.package.desc", EXTENDED, BASIC) {
 147         @Override
 148         public boolean matches(String option) {
 149             return DocLint.isValidOption(
 150                     option.replace(XDOCLINT_PACKAGE.primaryName, DocLint.XCHECK_PACKAGE));
 151         }
 152 
 153         @Override
 154         public boolean process(OptionHelper helper, String option) {
 155             String prev = helper.get(XDOCLINT_PACKAGE);
 156             String next = (prev == null) ? option : (prev + " " + option);
 157             helper.put(XDOCLINT_PACKAGE.primaryName, next);
 158             return false;
 159         }
 160     },
 161 
 162     // -nowarn is retained for command-line backward compatibility
 163     NOWARN("-nowarn", "opt.nowarn", STANDARD, BASIC) {
 164         @Override
 165         public boolean process(OptionHelper helper, String option) {
 166             helper.put("-Xlint:none", option);
 167             return false;
 168         }
 169     },
 170 
 171     VERBOSE("-verbose", "opt.verbose", STANDARD, BASIC),
 172 
 173     // -deprecation is retained for command-line backward compatibility
 174     DEPRECATION("-deprecation", "opt.deprecation", STANDARD, BASIC) {
 175         @Override
 176         public boolean process(OptionHelper helper, String option) {
 177             helper.put("-Xlint:deprecation", option);
 178             return false;
 179         }
 180     },
 181 
 182     CLASS_PATH("--class-path -classpath -cp", "opt.arg.path", "opt.classpath", STANDARD, FILEMANAGER),
 183 
 184     SOURCE_PATH("--source-path -sourcepath", "opt.arg.path", "opt.sourcepath", STANDARD, FILEMANAGER),
 185 
 186     MODULE_SOURCE_PATH("--module-source-path -modulesourcepath", "opt.arg.mspath", "opt.modulesourcepath", STANDARD, FILEMANAGER),
 187 
 188     MODULE_PATH("--module-path -p -modulepath -mp", "opt.arg.path", "opt.modulepath", STANDARD, FILEMANAGER),
 189 
 190     UPGRADE_MODULE_PATH("--upgrade-module-path -upgrademodulepath", "opt.arg.path", "opt.upgrademodulepath", STANDARD, FILEMANAGER),
 191 
 192     SYSTEM("--system -system", "opt.arg.jdk", "opt.system", STANDARD, FILEMANAGER),
 193 
 194     PATCH_MODULE("--patch-module -Xpatch:", "opt.arg.patch", "opt.patch", EXTENDED, FILEMANAGER) {
 195         // The deferred filemanager diagnostics mechanism assumes a single value per option,
 196         // but --patch-module can be used multiple times, once per module. Therefore we compose
 197         // a value for the option containing the last value specified for each module, and separate
 198         // the the module=path pairs by an invalid path character, NULL.
 199         // The standard file manager code knows to split apart the NULL-separated components.
 200         @Override
 201         public boolean process(OptionHelper helper, String option, String arg) {
 202             if (!arg.contains("=")) { // could be more strict regeex, e.g. "(?i)[a-z0-9_.]+=.*"
 203                 helper.error(Errors.LocnInvalidArgForXpatch(arg));
 204             }
 205 
 206             String previous = helper.get(this);
 207             if (previous == null) {
 208                 return super.process(helper, option, arg);
 209             }
 210 
 211             Map<String,String> map = new LinkedHashMap<>();
 212             for (String s : previous.split("\0")) {
 213                 int sep = s.indexOf('=');
 214                 map.put(s.substring(0, sep), s.substring(sep + 1));
 215             }
 216 
 217             int sep = arg.indexOf('=');
 218             map.put(arg.substring(0, sep), arg.substring(sep + 1));
 219 
 220             StringBuilder sb = new StringBuilder();
 221             map.forEach((m, p) -> {
 222                 if (sb.length() > 0)
 223                     sb.append('\0');
 224                 sb.append(m).append('=').append(p);
 225             });
 226             return super.process(helper, option, sb.toString());
 227         }
 228     },
 229 
 230     BOOT_CLASS_PATH("--boot-class-path -bootclasspath", "opt.arg.path", "opt.bootclasspath", STANDARD, FILEMANAGER) {
 231         @Override
 232         public boolean process(OptionHelper helper, String option, String arg) {
 233             helper.remove("-Xbootclasspath/p:");
 234             helper.remove("-Xbootclasspath/a:");
 235             return super.process(helper, option, arg);
 236         }
 237     },
 238 
 239     XBOOTCLASSPATH_PREPEND("-Xbootclasspath/p:", "opt.arg.path", "opt.Xbootclasspath.p", EXTENDED, FILEMANAGER),
 240 
 241     XBOOTCLASSPATH_APPEND("-Xbootclasspath/a:", "opt.arg.path", "opt.Xbootclasspath.a", EXTENDED, FILEMANAGER),
 242 
 243     XBOOTCLASSPATH("-Xbootclasspath:", "opt.arg.path", "opt.bootclasspath", EXTENDED, FILEMANAGER) {
 244         @Override
 245         public boolean process(OptionHelper helper, String option, String arg) {
 246             helper.remove("-Xbootclasspath/p:");
 247             helper.remove("-Xbootclasspath/a:");
 248             return super.process(helper, "-bootclasspath", arg);
 249         }
 250     },
 251 
 252     EXTDIRS("-extdirs", "opt.arg.dirs", "opt.extdirs", STANDARD, FILEMANAGER),
 253 
 254     DJAVA_EXT_DIRS("-Djava.ext.dirs=", "opt.arg.dirs", "opt.extdirs", EXTENDED, FILEMANAGER) {
 255         @Override
 256         public boolean process(OptionHelper helper, String option, String arg) {
 257             return EXTDIRS.process(helper, "-extdirs", arg);
 258         }
 259     },
 260 
 261     ENDORSEDDIRS("-endorseddirs", "opt.arg.dirs", "opt.endorseddirs", STANDARD, FILEMANAGER),
 262 
 263     DJAVA_ENDORSED_DIRS("-Djava.endorsed.dirs=", "opt.arg.dirs", "opt.endorseddirs", EXTENDED, FILEMANAGER) {
 264         @Override
 265         public boolean process(OptionHelper helper, String option, String arg) {
 266             return ENDORSEDDIRS.process(helper, "-endorseddirs", arg);
 267         }
 268     },
 269 
 270     PROC("-proc:", "opt.proc.none.only", STANDARD, BASIC,  ONEOF, "none", "only"),
 271 
 272     PROCESSOR("-processor", "opt.arg.class.list", "opt.processor", STANDARD, BASIC),
 273 
 274     PROCESSOR_PATH("--processor-path -processorpath", "opt.arg.path", "opt.processorpath", STANDARD, FILEMANAGER),
 275 
 276     PROCESSOR_MODULE_PATH("--processor-module-path -processormodulepath", "opt.arg.path", "opt.processormodulepath", STANDARD, FILEMANAGER),
 277 
 278     PARAMETERS("-parameters","opt.parameters", STANDARD, BASIC),
 279 
 280     D("-d", "opt.arg.directory", "opt.d", STANDARD, FILEMANAGER),
 281 
 282     S("-s", "opt.arg.directory", "opt.sourceDest", STANDARD, FILEMANAGER),
 283 
 284     H("-h", "opt.arg.directory", "opt.headerDest", STANDARD, FILEMANAGER),
 285 
 286     IMPLICIT("-implicit:", "opt.implicit", STANDARD, BASIC, ONEOF, "none", "class"),
 287 
 288     ENCODING("-encoding", "opt.arg.encoding", "opt.encoding", STANDARD, FILEMANAGER),
 289 
 290     SOURCE("-source", "opt.arg.release", "opt.source", STANDARD, BASIC) {
 291         @Override
 292         public boolean process(OptionHelper helper, String option, String operand) {
 293             Source source = Source.lookup(operand);
 294             if (source == null) {
 295                 helper.error("err.invalid.source", operand);
 296                 return true;
 297             }
 298             return super.process(helper, option, operand);
 299         }
 300     },
 301 
 302     TARGET("-target", "opt.arg.release", "opt.target", STANDARD, BASIC) {
 303         @Override
 304         public boolean process(OptionHelper helper, String option, String operand) {
 305             Target target = Target.lookup(operand);
 306             if (target == null) {
 307                 helper.error("err.invalid.target", operand);
 308                 return true;
 309             }
 310             return super.process(helper, option, operand);
 311         }
 312     },
 313 
 314     RELEASE("--release -release", "opt.arg.release", "opt.release", STANDARD, BASIC) {
 315         @Override
 316         protected void help(Log log) {
 317             Iterable<PlatformProvider> providers =
 318                     ServiceLoader.load(PlatformProvider.class, Arguments.class.getClassLoader());
 319             Set<String> platforms = StreamSupport.stream(providers.spliterator(), false)
 320                                                  .flatMap(provider -> StreamSupport.stream(provider.getSupportedPlatformNames()
 321                                                                                                    .spliterator(),
 322                                                                                            false))
 323                                                  .collect(Collectors.toCollection(TreeSet :: new));
 324 
 325             StringBuilder targets = new StringBuilder();
 326             String delim = "";
 327             for (String platform : platforms) {
 328                 targets.append(delim);
 329                 targets.append(platform);
 330                 delim = ", ";
 331             }
 332 
 333             super.help(log, log.localize(PrefixKind.JAVAC, descrKey, targets.toString()));
 334         }
 335     },
 336 
 337     PROFILE("-profile", "opt.arg.profile", "opt.profile", STANDARD, BASIC) {
 338         @Override
 339         public boolean process(OptionHelper helper, String option, String operand) {
 340             Profile profile = Profile.lookup(operand);
 341             if (profile == null) {
 342                 helper.error("err.invalid.profile", operand);
 343                 return true;
 344             }
 345             return super.process(helper, option, operand);
 346         }
 347     },
 348 
 349     VERSION("-version", "opt.version", STANDARD, INFO) {
 350         @Override
 351         public boolean process(OptionHelper helper, String option) {
 352             Log log = helper.getLog();
 353             String ownName = helper.getOwnName();
 354             log.printLines(WriterKind.STDOUT, PrefixKind.JAVAC, "version", ownName,  JavaCompiler.version());
 355             return super.process(helper, option);
 356         }
 357     },
 358 
 359     FULLVERSION("-fullversion", null, HIDDEN, INFO) {
 360         @Override
 361         public boolean process(OptionHelper helper, String option) {
 362             Log log = helper.getLog();
 363             String ownName = helper.getOwnName();
 364             log.printLines(WriterKind.STDOUT, PrefixKind.JAVAC, "fullVersion", ownName,  JavaCompiler.fullVersion());
 365             return super.process(helper, option);
 366         }
 367     },
 368 
 369     // Note: -h is already taken for "native header output directory".
 370     HELP("--help -help", "opt.help", STANDARD, INFO) {
 371         @Override
 372         public boolean process(OptionHelper helper, String option) {
 373             Log log = helper.getLog();
 374             String ownName = helper.getOwnName();
 375             log.printLines(WriterKind.STDOUT, PrefixKind.JAVAC, "msg.usage.header", ownName);
 376             showHelp(log, OptionKind.STANDARD);
 377             log.printNewline(WriterKind.STDOUT);
 378             return super.process(helper, option);
 379         }
 380     },
 381 
 382     A("-A", "opt.arg.key.equals.value", "opt.A", STANDARD, BASIC, ArgKind.ADJACENT) {
 383         @Override
 384         public boolean matches(String arg) {
 385             return arg.startsWith("-A");
 386         }
 387 
 388         @Override
 389         public boolean hasArg() {
 390             return false;
 391         }
 392         // Mapping for processor options created in
 393         // JavacProcessingEnvironment
 394         @Override
 395         public boolean process(OptionHelper helper, String option) {
 396             int argLength = option.length();
 397             if (argLength == 2) {
 398                 helper.error("err.empty.A.argument");
 399                 return true;
 400             }
 401             int sepIndex = option.indexOf('=');
 402             String key = option.substring(2, (sepIndex != -1 ? sepIndex : argLength) );
 403             if (!JavacProcessingEnvironment.isValidOptionName(key)) {
 404                 helper.error("err.invalid.A.key", option);
 405                 return true;
 406             }
 407             helper.put(option, option);
 408             return false;
 409         }
 410     },
 411 
 412     X("-X", "opt.X", STANDARD, INFO) {
 413         @Override
 414         public boolean process(OptionHelper helper, String option) {
 415             Log log = helper.getLog();
 416             showHelp(log, OptionKind.EXTENDED);
 417             log.printNewline(WriterKind.STDOUT);
 418             log.printLines(WriterKind.STDOUT, PrefixKind.JAVAC, "msg.usage.nonstandard.footer");
 419             return super.process(helper, option);
 420         }
 421     },
 422 
 423     // This option exists only for the purpose of documenting itself.
 424     // It's actually implemented by the launcher.
 425     J("-J", "opt.arg.flag", "opt.J", STANDARD, INFO, ArgKind.ADJACENT) {
 426         @Override
 427         public boolean process(OptionHelper helper, String option) {
 428             throw new AssertionError
 429                 ("the -J flag should be caught by the launcher.");
 430         }
 431     },
 432 
 433     MOREINFO("-moreinfo", null, HIDDEN, BASIC) {
 434         @Override
 435         public boolean process(OptionHelper helper, String option) {
 436             Type.moreInfo = true;
 437             return super.process(helper, option);
 438         }
 439     },
 440 
 441     // treat warnings as errors
 442     WERROR("-Werror", "opt.Werror", STANDARD, BASIC),
 443 
 444     // prompt after each error
 445     // new Option("-prompt",                                        "opt.prompt"),
 446     PROMPT("-prompt", null, HIDDEN, BASIC),
 447 
 448     // dump stack on error
 449     DOE("-doe", null, HIDDEN, BASIC),
 450 
 451     // output source after type erasure
 452     PRINTSOURCE("-printsource", null, HIDDEN, BASIC),
 453 
 454     // display warnings for generic unchecked operations
 455     WARNUNCHECKED("-warnunchecked", null, HIDDEN, BASIC) {
 456         @Override
 457         public boolean process(OptionHelper helper, String option) {
 458             helper.put("-Xlint:unchecked", option);
 459             return false;
 460         }
 461     },
 462 
 463     XMAXERRS("-Xmaxerrs", "opt.arg.number", "opt.maxerrs", EXTENDED, BASIC),
 464 
 465     XMAXWARNS("-Xmaxwarns", "opt.arg.number", "opt.maxwarns", EXTENDED, BASIC),
 466 
 467     XSTDOUT("-Xstdout", "opt.arg.file", "opt.Xstdout", EXTENDED, INFO) {
 468         @Override
 469         public boolean process(OptionHelper helper, String option, String arg) {
 470             try {
 471                 Log log = helper.getLog();
 472                 log.setWriters(new PrintWriter(new FileWriter(arg), true));
 473             } catch (java.io.IOException e) {
 474                 helper.error("err.error.writing.file", arg, e);
 475                 return true;
 476             }
 477             return super.process(helper, option, arg);
 478         }
 479     },
 480 
 481     XPRINT("-Xprint", "opt.print", EXTENDED, BASIC),
 482 
 483     XPRINTROUNDS("-XprintRounds", "opt.printRounds", EXTENDED, BASIC),
 484 
 485     XPRINTPROCESSORINFO("-XprintProcessorInfo", "opt.printProcessorInfo", EXTENDED, BASIC),
 486 
 487     XPREFER("-Xprefer:", "opt.prefer", EXTENDED, BASIC, ONEOF, "source", "newer"),
 488 
 489     XXUSERPATHSFIRST("-XXuserPathsFirst", "opt.userpathsfirst", HIDDEN, BASIC),
 490 
 491     // see enum PkgInfo
 492     XPKGINFO("-Xpkginfo:", "opt.pkginfo", EXTENDED, BASIC, ONEOF, "always", "legacy", "nonempty"),
 493 
 494     /* -O is a no-op, accepted for backward compatibility. */
 495     O("-O", null, HIDDEN, BASIC),
 496 
 497     /* -Xjcov produces tables to support the code coverage tool jcov. */
 498     XJCOV("-Xjcov", null, HIDDEN, BASIC),
 499 
 500     PLUGIN("-Xplugin:", "opt.arg.plugin", "opt.plugin", EXTENDED, BASIC) {
 501         @Override
 502         public boolean process(OptionHelper helper, String option) {
 503             String p = option.substring(option.indexOf(':') + 1).trim();
 504             String prev = helper.get(PLUGIN);
 505             helper.put(PLUGIN.primaryName, (prev == null) ? p : prev + '\0' + p);
 506             return false;
 507         }
 508     },
 509 
 510     XDIAGS("-Xdiags:", "opt.diags", EXTENDED, BASIC, ONEOF, "compact", "verbose"),
 511 
 512     XDEBUG("-Xdebug:", null, HIDDEN, BASIC) {
 513         @Override
 514         public boolean process(OptionHelper helper, String option) {
 515             String p = option.substring(option.indexOf(':') + 1).trim();
 516             String[] subOptions = p.split(";");
 517             for (String subOption : subOptions) {
 518                 subOption = "debug." + subOption.trim();
 519                 XD.process(helper, subOption, subOption);
 520             }
 521             return false;
 522         }
 523     },
 524 
 525     XSHOULDSTOP("-Xshouldstop:", null, HIDDEN, BASIC) {
 526         @Override
 527         public boolean process(OptionHelper helper, String option) {
 528             String p = option.substring(option.indexOf(':') + 1).trim();
 529             String[] subOptions = p.split(";");
 530             for (String subOption : subOptions) {
 531                 subOption = "shouldstop." + subOption.trim();
 532                 XD.process(helper, subOption, subOption);
 533             }
 534             return false;
 535         }
 536     },
 537 
 538     DIAGS("-diags:", null, HIDDEN, BASIC) {
 539         @Override
 540         public boolean process(OptionHelper helper, String option) {
 541             return HiddenGroup.DIAGS.process(helper, option);
 542         }
 543     },
 544 
 545     /* This is a back door to the compiler's option table.
 546      * -XDx=y sets the option x to the value y.
 547      * -XDx sets the option x to the value x.
 548      */
 549     XD("-XD", null, HIDDEN, BASIC) {
 550         @Override
 551         public boolean matches(String s) {
 552             return s.startsWith(primaryName);
 553         }
 554         @Override
 555         public boolean process(OptionHelper helper, String option) {
 556             return process(helper, option, option.substring(primaryName.length()));
 557         }
 558 
 559         @Override
 560         public boolean process(OptionHelper helper, String option, String arg) {
 561             int eq = arg.indexOf('=');
 562             String key = (eq < 0) ? arg : arg.substring(0, eq);
 563             String value = (eq < 0) ? arg : arg.substring(eq+1);
 564             helper.put(key, value);
 565             return false;
 566         }
 567     },
 568 
 569     ADD_EXPORTS("--add-exports -XaddExports:", "opt.arg.addExports", "opt.addExports", EXTENDED, BASIC) {
 570         @Override
 571         public boolean process(OptionHelper helper, String option, String arg) {
 572             String prev = helper.get(ADD_EXPORTS);
 573             helper.put(ADD_EXPORTS.primaryName, (prev == null) ? arg : prev + '\0' + arg);
 574             return false;
 575         }
 576     },
 577 
 578     ADD_READS("--add-reads -XaddReads:", "opt.arg.addReads", "opt.addReads", EXTENDED, BASIC) {
 579         @Override
 580         public boolean process(OptionHelper helper, String option, String arg) {
 581             String prev = helper.get(ADD_READS);
 582             helper.put(ADD_READS.primaryName, (prev == null) ? arg : prev + '\0' + arg);
 583             return false;
 584         }
 585     },
 586 
 587     XMODULE("-Xmodule:", "opt.arg.module", "opt.module", EXTENDED, BASIC) {
 588         @Override
 589         public boolean process(OptionHelper helper, String option, String arg) {
 590             String prev = helper.get(XMODULE);
 591             if (prev != null) {
 592                 helper.error("err.option.too.many", XMODULE.primaryName);
 593             }
 594             helper.put(XMODULE.primaryName, arg);
 595             return false;
 596         }
 597     },
 598 
 599     MODULE("--module -m", "opt.arg.m", "opt.m", STANDARD, BASIC),
 600 
 601     ADD_MODULES("--add-modules -addmods", "opt.arg.addmods", "opt.addmods", STANDARD, BASIC),
 602 
 603     LIMIT_MODULES("--limit-modules -limitmods", "opt.arg.limitmods", "opt.limitmods", STANDARD, BASIC),
 604 
 605     // This option exists only for the purpose of documenting itself.
 606     // It's actually implemented by the CommandLine class.
 607     AT("@", "opt.arg.file", "opt.AT", STANDARD, INFO, ArgKind.ADJACENT) {
 608         @Override
 609         public boolean process(OptionHelper helper, String option) {
 610             throw new AssertionError("the @ flag should be caught by CommandLine.");
 611         }
 612     },
 613 
 614     // Standalone positional argument: source file or type name.
 615     SOURCEFILE("sourcefile", null, HIDDEN, INFO) {
 616         @Override
 617         public boolean matches(String s) {
 618             if (s.endsWith(".java"))  // Java source file
 619                 return true;
 620             int sep = s.indexOf('/');
 621             if (sep != -1) {
 622                 return SourceVersion.isName(s.substring(0, sep))
 623                         && SourceVersion.isName(s.substring(sep + 1));
 624             } else {
 625                 return SourceVersion.isName(s);   // Legal type name
 626             }
 627         }
 628         @Override
 629         public boolean process(OptionHelper helper, String option) {
 630             if (option.endsWith(".java") ) {
 631                 Path p = Paths.get(option);
 632                 if (!Files.exists(p)) {
 633                     helper.error("err.file.not.found", p);
 634                     return true;
 635                 }
 636                 if (!Files.isRegularFile(p)) {
 637                     helper.error("err.file.not.file", p);
 638                     return true;
 639                 }
 640                 helper.addFile(p);
 641             } else {
 642                 helper.addClassName(option);
 643             }
 644             return false;
 645         }
 646     },
 647 
 648     MULTIRELEASE("--multi-release -multi-release", "opt.arg.multi-release", "opt.multi-release", HIDDEN, FILEMANAGER),
 649 
 650     INHERIT_RUNTIME_ENVIRONMENT("--inherit-runtime-environment", "opt.inherit_runtime_environment",
 651             EXTENDED, BASIC) {
 652         @Override
 653         public boolean process(OptionHelper helper, String option) {
 654             try {
 655                 Class.forName(JDK9Wrappers.VMHelper.VM_CLASSNAME);
 656                 String[] runtimeArgs = JDK9Wrappers.VMHelper.getRuntimeArguments();
 657                 for (String arg : runtimeArgs) {
 658                     // Handle any supported runtime options; ignore all others.
 659                     // The runtime arguments always use the single token form, e.g. "--name=value".
 660                     for (Option o : getSupportedRuntimeOptions()) {
 661                         if (o.matches(arg)) {
 662                             o.handleOption(helper, arg, Collections.emptyIterator());
 663                             break;
 664                         }
 665                     }
 666                 }
 667             } catch (ClassNotFoundException | SecurityException e) {
 668                 helper.error("err.cannot.access.runtime.env");
 669             }
 670             return false;
 671         }
 672 
 673         private Option[] getSupportedRuntimeOptions() {
 674             Option[] supportedRuntimeOptions = {
 675                 ADD_EXPORTS,
 676                 ADD_MODULES,
 677                 LIMIT_MODULES,
 678                 MODULE_PATH,
 679                 UPGRADE_MODULE_PATH,
 680                 PATCH_MODULE
 681             };
 682             return supportedRuntimeOptions;
 683         }
 684     };
 685 
 686     /**
 687      * The kind of argument, if any, accepted by this option. The kind is augmented
 688      * by characters in the name of the option.
 689      */
 690     public enum ArgKind {
 691         /** This option does not take any argument. */
 692         NONE,
 693 
 694 // Not currently supported
 695 //        /**
 696 //         * This option takes an optional argument, which may be provided directly after an '='
 697 //         * separator, or in the following argument position if that word does not itself appear
 698 //         * to be the name of an option.
 699 //         */
 700 //        OPTIONAL,
 701 
 702         /**
 703          * This option takes an argument.
 704          * If the name of option ends with ':' or '=', the argument must be provided directly
 705          * after that separator.
 706          * Otherwise, if may appear after an '=' or in the following argument position.
 707          */
 708         REQUIRED,
 709 
 710         /**
 711          * This option takes an argument immediately after the option name, with no separator
 712          * character.
 713          */
 714         ADJACENT
 715     }
 716 
 717     /**
 718      * The kind of an Option. This is used by the -help and -X options.
 719      */
 720     public enum OptionKind {
 721         /** A standard option, documented by -help. */
 722         STANDARD,
 723         /** An extended option, documented by -X. */
 724         EXTENDED,
 725         /** A hidden option, not documented. */
 726         HIDDEN,
 727     }
 728 
 729     /**
 730      * The group for an Option. This determines the situations in which the
 731      * option is applicable.
 732      */
 733     enum OptionGroup {
 734         /** A basic option, available for use on the command line or via the
 735          *  Compiler API. */
 736         BASIC,
 737         /** An option for javac's standard JavaFileManager. Other file managers
 738          *  may or may not support these options. */
 739         FILEMANAGER,
 740         /** A command-line option that requests information, such as -help. */
 741         INFO,
 742         /** A command-line "option" representing a file or class name. */
 743         OPERAND
 744     }
 745 
 746     /**
 747      * The kind of choice for "choice" options.
 748      */
 749     enum ChoiceKind {
 750         /** The expected value is exactly one of the set of choices. */
 751         ONEOF,
 752         /** The expected value is one of more of the set of choices. */
 753         ANYOF
 754     }
 755 
 756     enum HiddenGroup {
 757         DIAGS("diags");
 758 
 759         final String text;
 760 
 761         HiddenGroup(String text) {
 762             this.text = text;
 763         }
 764 
 765         public boolean process(OptionHelper helper, String option) {
 766             String p = option.substring(option.indexOf(':') + 1).trim();
 767             String[] subOptions = p.split(";");
 768             for (String subOption : subOptions) {
 769                 subOption = text + "." + subOption.trim();
 770                 XD.process(helper, subOption, subOption);
 771             }
 772             return false;
 773         }
 774     }
 775 
 776     /**
 777      * The "primary name" for this option.
 778      * This is the name that is used to put values in the {@link Options} table.
 779      */
 780     public final String primaryName;
 781 
 782     /**
 783      * The set of names (primary name and aliases) for this option.
 784      * Note that some names may end in a separator, to indicate that an argument must immediately
 785      * follow the separator (and cannot appear in the following argument position.
 786      */
 787     public final String[] names;
 788 
 789     /** Documentation key for arguments. */
 790     protected final String argsNameKey;
 791 
 792     /** Documentation key for description.
 793      */
 794     protected final String descrKey;
 795 
 796     /** The kind of this option. */
 797     private final OptionKind kind;
 798 
 799     /** The group for this option. */
 800     private final OptionGroup group;
 801 
 802     /** The kind of argument for this option. */
 803     private final ArgKind argKind;
 804 
 805     /** The kind of choices for this option, if any. */
 806     private final ChoiceKind choiceKind;
 807 
 808     /** The choices for this option, if any, and whether or not the choices are hidden. */
 809     private final Map<String,Boolean> choices;
 810 
 811     /**
 812      * Looks up the first option matching the given argument in the full set of options.
 813      * @param arg the argument to be matches
 814      * @return the first option that matches, or null if none.
 815      */
 816     public static Option lookup(String arg) {
 817         return lookup(arg, EnumSet.allOf(Option.class));
 818     }
 819 
 820     /**
 821      * Looks up the first option matching the given argument within a set of options.
 822      * @param arg the argument to be matches
 823      * @return the first option that matches, or null if none.
 824      */
 825     public static Option lookup(String arg, Set<Option> options) {
 826         for (Option option: options) {
 827             if (option.matches(arg))
 828                 return option;
 829         }
 830         return null;
 831     }
 832 
 833     /**
 834      * Writes the "command line help" for given kind of option to the log.
 835      * @param log the log
 836      * @param kind  the kind of options to select
 837      */
 838     private static void showHelp(Log log, OptionKind kind) {
 839         Comparator<Option> comp = new Comparator<Option>() {
 840             final Collator collator = Collator.getInstance(Locale.US);
 841             { collator.setStrength(Collator.PRIMARY); }
 842 
 843             @Override
 844             public int compare(Option o1, Option o2) {
 845                 return collator.compare(o1.primaryName, o2.primaryName);
 846             }
 847         };
 848 
 849         getJavaCompilerOptions()
 850                 .stream()
 851                 .filter(o -> o.kind == kind)
 852                 .sorted(comp)
 853                 .forEach(o -> {
 854                     o.help(log);
 855                 });
 856     }
 857 
 858     Option(String text, String descrKey,
 859             OptionKind kind, OptionGroup group) {
 860         this(text, null, descrKey, kind, group, null, null, ArgKind.NONE);
 861     }
 862 
 863     Option(String text, String argsNameKey, String descrKey,
 864             OptionKind kind, OptionGroup group) {
 865         this(text, argsNameKey, descrKey, kind, group, null, null, ArgKind.REQUIRED);
 866     }
 867 
 868     Option(String text, String argsNameKey, String descrKey,
 869             OptionKind kind, OptionGroup group, ArgKind ak) {
 870         this(text, argsNameKey, descrKey, kind, group, null, null, ak);
 871     }
 872 
 873     Option(String text, String argsNameKey, String descrKey, OptionKind kind, OptionGroup group,
 874             ChoiceKind choiceKind, Map<String,Boolean> choices) {
 875         this(text, argsNameKey, descrKey, kind, group, choiceKind, choices, ArgKind.REQUIRED);
 876     }
 877 
 878     Option(String text, String descrKey,
 879             OptionKind kind, OptionGroup group,
 880             ChoiceKind choiceKind, String... choices) {
 881         this(text, null, descrKey, kind, group, choiceKind,
 882                 createChoices(choices), ArgKind.REQUIRED);
 883     }
 884     // where
 885         private static Map<String,Boolean> createChoices(String... choices) {
 886             Map<String,Boolean> map = new LinkedHashMap<>();
 887             for (String c: choices)
 888                 map.put(c, false);
 889             return map;
 890         }
 891 
 892     private Option(String text, String argsNameKey, String descrKey,
 893             OptionKind kind, OptionGroup group,
 894             ChoiceKind choiceKind, Map<String,Boolean> choices,
 895             ArgKind argKind) {
 896         this.names = text.trim().split("\\s+");
 897         Assert.check(names.length >= 1);
 898         this.primaryName = names[0];
 899         this.argsNameKey = argsNameKey;
 900         this.descrKey = descrKey;
 901         this.kind = kind;
 902         this.group = group;
 903         this.choiceKind = choiceKind;
 904         this.choices = choices;
 905         this.argKind = argKind;
 906     }
 907 
 908     public String getPrimaryName() {
 909         return primaryName;
 910     }
 911 
 912     public OptionKind getKind() {
 913         return kind;
 914     }
 915 
 916     public ArgKind getArgKind() {
 917         return argKind;
 918     }
 919 
 920     public boolean hasArg() {
 921 //        return argsNameKey != null && !hasSuffix;
 922         return (argKind != ArgKind.NONE);
 923     }
 924 
 925     public boolean matches(String option) {
 926         for (String name: names) {
 927             if (matches(option, name))
 928                 return true;
 929         }
 930         return false;
 931     }
 932 
 933     private boolean matches(String option, String name) {
 934         if (name.startsWith("--")) {
 935             return option.equals(name)
 936                     || hasArg() && option.startsWith(name + "=");
 937         }
 938 
 939         boolean hasSuffix = (argKind == ArgKind.ADJACENT)
 940                 || name.endsWith(":") || name.endsWith("=");
 941 
 942         if (!hasSuffix)
 943             return option.equals(name);
 944 
 945         if (!option.startsWith(name))
 946             return false;
 947 
 948         if (choices != null) {
 949             String arg = option.substring(name.length());
 950             if (choiceKind == ChoiceKind.ONEOF)
 951                 return choices.keySet().contains(arg);
 952             else {
 953                 for (String a: arg.split(",+")) {
 954                     if (!choices.keySet().contains(a))
 955                         return false;
 956                 }
 957             }
 958         }
 959 
 960         return true;
 961     }
 962 
 963     /**
 964      * Handles an option.
 965      * If an argument for the option is required, depending on spec of the option, it will be found
 966      * as part of the current arg (following ':' or '=') or in the following argument.
 967      * This is the recommended way to handle an option directly, instead of calling the underlying
 968      * {@link #process process} methods.
 969      * @param helper a helper to provide access to the environment
 970      * @param arg the arg string that identified this option
 971      * @param rest the remaining strings to be analysed
 972      * @return true if the operation was successful, and false otherwise
 973      * @implNote The return value is the opposite of that used by {@link #process}.
 974      */
 975     public boolean handleOption(OptionHelper helper, String arg, Iterator<String> rest) {
 976         if (hasArg()) {
 977             String operand;
 978             int sep = findSeparator(arg);
 979             if (getArgKind() == Option.ArgKind.ADJACENT) {
 980                 operand = arg.substring(primaryName.length());
 981             } else if (sep > 0) {
 982                 operand = arg.substring(sep + 1);
 983             } else {
 984                 if (!rest.hasNext()) {
 985                     helper.error("err.req.arg", arg);
 986                     return false;
 987                 }
 988                 operand = rest.next();
 989             }
 990             return !process(helper, arg, operand);
 991         } else {
 992             return !process(helper, arg);
 993         }
 994     }
 995 
 996     /**
 997      * Processes an option that either does not need an argument,
 998      * or which contains an argument within it, following a separator.
 999      * @param helper a helper to provide access to the environment
1000      * @param option the option to be processed
1001      * @return true if an error occurred
1002      */
1003     public boolean process(OptionHelper helper, String option) {
1004         if (argKind == ArgKind.NONE) {
1005             return process(helper, primaryName, option);
1006         } else {
1007             int sep = findSeparator(option);
1008             return process(helper, primaryName, option.substring(sep + 1));
1009         }
1010     }
1011 
1012     /**
1013      * Processes an option by updating the environment via a helper object.
1014      * @param helper a helper to provide access to the environment
1015      * @param option the option to be processed
1016      * @param arg the value to associate with the option, or a default value
1017      *  to be used if the option does not otherwise take an argument.
1018      * @return true if an error occurred
1019      */
1020     public boolean process(OptionHelper helper, String option, String arg) {
1021         if (choices != null) {
1022             if (choiceKind == ChoiceKind.ONEOF) {
1023                 // some clients like to see just one of option+choice set
1024                 for (String s: choices.keySet())
1025                     helper.remove(primaryName + s);
1026                 String opt = primaryName + arg;
1027                 helper.put(opt, opt);
1028                 // some clients like to see option (without trailing ":")
1029                 // set to arg
1030                 String nm = primaryName.substring(0, primaryName.length() - 1);
1031                 helper.put(nm, arg);
1032             } else {
1033                 // set option+word for each word in arg
1034                 for (String a: arg.split(",+")) {
1035                     String opt = primaryName + a;
1036                     helper.put(opt, opt);
1037                 }
1038             }
1039         }
1040         helper.put(primaryName, arg);
1041         if (group == OptionGroup.FILEMANAGER)
1042             helper.handleFileManagerOption(this, arg);
1043         return false;
1044     }
1045 
1046     /**
1047      * Scans a word to find the first separator character, either colon or equals.
1048      * @param word the word to be scanned
1049      * @return the position of the first':' or '=' character in the word,
1050      *  or -1 if none found
1051      */
1052     private static int findSeparator(String word) {
1053         for (int i = 0; i < word.length(); i++) {
1054             switch (word.charAt(i)) {
1055                 case ':': case '=':
1056                     return i;
1057             }
1058         }
1059         return -1;
1060     }
1061 
1062     /** The indent for the option synopsis. */
1063     private static final String SMALL_INDENT = "  ";
1064     /** The automatic indent for the description. */
1065     private static final String LARGE_INDENT = "        ";
1066     /** The space allowed for the synopsis, if the description is to be shown on the same line. */
1067     private static final int DEFAULT_SYNOPSIS_WIDTH = 28;
1068     /** The nominal maximum line length, when seeing if text will fit on a line. */
1069     private static final int DEFAULT_MAX_LINE_LENGTH = 80;
1070     /** The format for a single-line help entry. */
1071     private static final String COMPACT_FORMAT = SMALL_INDENT + "%-" + DEFAULT_SYNOPSIS_WIDTH + "s %s";
1072 
1073     /**
1074      * Writes help text for this option to the log.
1075      * @param log the log
1076      */
1077     protected void help(Log log) {
1078         help(log, log.localize(PrefixKind.JAVAC, descrKey));
1079     }
1080 
1081     protected void help(Log log, String descr) {
1082         String synopses = Arrays.stream(names)
1083                 .map(s -> helpSynopsis(s, log))
1084                 .collect(Collectors.joining(", "));
1085 
1086         // If option synopses and description fit on a single line of reasonable length,
1087         // display using COMPACT_FORMAT
1088         if (synopses.length() < DEFAULT_SYNOPSIS_WIDTH
1089                 && !descr.contains("\n")
1090                 && (SMALL_INDENT.length() + DEFAULT_SYNOPSIS_WIDTH + 1 + descr.length() <= DEFAULT_MAX_LINE_LENGTH)) {
1091             log.printRawLines(WriterKind.STDOUT, String.format(COMPACT_FORMAT, synopses, descr));
1092             return;
1093         }
1094 
1095         // If option synopses fit on a single line of reasonable length, show that;
1096         // otherwise, show 1 per line
1097         if (synopses.length() <= DEFAULT_MAX_LINE_LENGTH) {
1098             log.printRawLines(WriterKind.STDOUT, SMALL_INDENT + synopses);
1099         } else {
1100             for (String name: names) {
1101                 log.printRawLines(WriterKind.STDOUT, SMALL_INDENT + helpSynopsis(name, log));
1102             }
1103         }
1104 
1105         // Finally, show the description
1106         log.printRawLines(WriterKind.STDOUT, LARGE_INDENT + descr.replace("\n", "\n" + LARGE_INDENT));
1107     }
1108 
1109     /**
1110      * Composes the initial synopsis of one of the forms for this option.
1111      * @param name the name of this form of the option
1112      * @param log the log used to localize the description of the arguments
1113      * @return  the synopsis
1114      */
1115     private String helpSynopsis(String name, Log log) {
1116         StringBuilder sb = new StringBuilder();
1117         sb.append(name);
1118         if (argsNameKey == null) {
1119             if (choices != null) {
1120                 String sep = "{";
1121                 for (Map.Entry<String,Boolean> e: choices.entrySet()) {
1122                     if (!e.getValue()) {
1123                         sb.append(sep);
1124                         sb.append(e.getKey());
1125                         sep = ",";
1126                     }
1127                 }
1128                 sb.append("}");
1129             }
1130         } else {
1131             if (!name.matches(".*[=:]$") && argKind != ArgKind.ADJACENT)
1132                 sb.append(" ");
1133             sb.append(log.localize(PrefixKind.JAVAC, argsNameKey));
1134         }
1135 
1136         return sb.toString();
1137     }
1138 
1139     // For -XpkgInfo:value
1140     public enum PkgInfo {
1141         /**
1142          * Always generate package-info.class for every package-info.java file.
1143          * The file may be empty if there annotations with a RetentionPolicy
1144          * of CLASS or RUNTIME.  This option may be useful in conjunction with
1145          * build systems (such as Ant) that expect javac to generate at least
1146          * one .class file for every .java file.
1147          */
1148         ALWAYS,
1149         /**
1150          * Generate a package-info.class file if package-info.java contains
1151          * annotations. The file may be empty if all the annotations have
1152          * a RetentionPolicy of SOURCE.
1153          * This value is just for backwards compatibility with earlier behavior.
1154          * Either of the other two values are to be preferred to using this one.
1155          */
1156         LEGACY,
1157         /**
1158          * Generate a package-info.class file if and only if there are annotations
1159          * in package-info.java to be written into it.
1160          */
1161         NONEMPTY;
1162 
1163         public static PkgInfo get(Options options) {
1164             String v = options.get(XPKGINFO);
1165             return (v == null
1166                     ? PkgInfo.LEGACY
1167                     : PkgInfo.valueOf(StringUtils.toUpperCase(v)));
1168         }
1169     }
1170 
1171     private static Map<String,Boolean> getXLintChoices() {
1172         Map<String,Boolean> choices = new LinkedHashMap<>();
1173         choices.put("all", false);
1174         for (Lint.LintCategory c : Lint.LintCategory.values())
1175             choices.put(c.option, c.hidden);
1176         for (Lint.LintCategory c : Lint.LintCategory.values())
1177             choices.put("-" + c.option, c.hidden);
1178         choices.put("none", false);
1179         return choices;
1180     }
1181 
1182     /**
1183      * Returns the set of options supported by the command line tool.
1184      * @return the set of options.
1185      */
1186     static Set<Option> getJavaCompilerOptions() {
1187         return EnumSet.allOf(Option.class);
1188     }
1189 
1190     /**
1191      * Returns the set of options supported by the built-in file manager.
1192      * @return the set of options.
1193      */
1194     public static Set<Option> getJavacFileManagerOptions() {
1195         return getOptions(FILEMANAGER);
1196     }
1197 
1198     /**
1199      * Returns the set of options supported by this implementation of
1200      * the JavaCompiler API, via {@link JavaCompiler#getTask}.
1201      * @return the set of options.
1202      */
1203     public static Set<Option> getJavacToolOptions() {
1204         return getOptions(BASIC);
1205     }
1206 
1207     private static Set<Option> getOptions(OptionGroup group) {
1208         return Arrays.stream(Option.values())
1209                 .filter(o -> o.group == group)
1210                 .collect(Collectors.toCollection(() -> EnumSet.noneOf(Option.class)));
1211     }
1212 
1213 }