< prev index next >

src/jdk.javadoc/share/classes/jdk/javadoc/internal/tool/ToolOptions.java

Print this page

        

@@ -25,378 +25,587 @@
 
 package jdk.javadoc.internal.tool;
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.EnumMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-
 import javax.lang.model.element.ElementKind;
 
 import com.sun.tools.javac.main.Option;
 import com.sun.tools.javac.main.Option.InvalidValueException;
 import com.sun.tools.javac.main.Option.OptionKind;
 import com.sun.tools.javac.main.OptionHelper;
+import com.sun.tools.javac.util.Context;
 import com.sun.tools.javac.util.Options;
 
-import static com.sun.tools.javac.main.Option.OptionKind.*;
-import static jdk.javadoc.internal.tool.Main.Result.*;
+import static com.sun.tools.javac.main.Option.OptionKind.EXTENDED;
+import static com.sun.tools.javac.main.Option.OptionKind.HIDDEN;
+import static com.sun.tools.javac.main.Option.OptionKind.STANDARD;
+import static jdk.javadoc.internal.tool.Main.Result.OK;
 
 /**
- * javadoc tool options.
+ * Storage and support for javadoc tool options, as distinct from
+ * the options supported by any doclet that may be in use.
+ * The tool options includes those options which are delegated
+ * to javac and/or the file manager, such as options to set
+ * the source level, and path options to locate the files to be
+ * documented.
  *
  *  <p><b>This is NOT part of any supported API.
  *  If you write code that depends on this, you do so at your own risk.
  *  This code and its internal interfaces are subject to change or
  *  deletion without notice.</b>
  */
-public enum ToolOption {
+public class ToolOptions {
+    // The following are the names of options handled in the first pass of option decoding,
+    // in Start.preprocess.
+    static final String DOCLET = "-doclet";
+    static final String DOCLET_PATH = "-docletpath";
+    static final String DUMP_ON_ERROR = "--dump-on-error";
+    static final String J = "-J";
+    static final String LOCALE = "-locale";
+
+    /**
+     * Argument for command-line option {@code -breakiterator}.
+     */
+    private boolean breakIterator = false;
+
+    /**
+     * Argument for command-line option {@code -locale}.
+     */
+    private String docLocale = "";
+
+    /**
+     * Argument for command-line option {@code --dump-on-error}.
+     * Dump stack traces for debugging etc.
+     * Similar to javac {@code -doe}.
+     */
+    private boolean dumpOnError = false;
+
+    /**
+     * Argument for command-line option {@code -exclude}.
+     */
+    private List<String> excludes = new ArrayList<>();
+
+    /**
+     * Argument for command-line option {@code --expand-requires}.
+     */
+    private AccessKind expandRequires;
+
+    /**
+     * Argument for command-line option {@code --ignore-source-errors}.
+     */
+    private boolean ignoreSourceErrors;
+
+    /**
+     * Argument for command-line option {@code --module}.
+     */
+    private List<String> modules = new ArrayList<>();
+
+    /**
+     * Argument for command-line option {@code -Xwerror}.
+     * Set by -Xwerror.
+     */
+    private boolean rejectWarnings = false;
+
+    /**
+     * Argument for command-line option {@code --show-members}.
+     */
+    private AccessKind showMembersAccess;
+
+    /**
+     * Argument for command-line option {@code --show-types}.
+     */
+    private AccessKind showTypesAccess;
+
+    /**
+     * Argument for command-line option {@code --show-packages}.
+     */
+    private AccessKind showPackagesAccess;
+
+    /**
+     * Argument for command-line option {@code --show-module-contents}.
+     */
+    private AccessKind showModuleContents;
+
+    /**
+     * Argument for command-line option {@code -quiet}.
+     */
+    private boolean quiet;
+
+    /**
+     * Argument for command-line option {@code -subpackages}.
+     */
+    private List<String> subpackages = new ArrayList<>();
+
+    /**
+     * Argument for command-line option {@code -verbose}.
+     */
+    private boolean verbose;
+
+    /**
+     * Argument for command-line option {@code -xclasses}.
+     * If true, names on the command line that would normally be
+     * treated as package names are treated as class names instead.
+     */
+    private boolean xclasses = false;
+
+    /**
+     * Options to be given to the file manager, such as path options
+     * indicating where to find files to be documented.
+     */
+    private final Map<Option, String> fileManagerOpts;
+
+    /**
+     * Options to be given to the underlying compiler front-end,
+     * such as options to indicate the source level to be used.
+     */
+    private final Options compOpts;
+
+    /**
+     * The "helper" to be used when processing compiler options.
+     */
+    private final OptionHelper compilerOptionHelper;
+
+    /**
+     * The messager to be used to report diagnostics..
+     */
+    private final Messager messager;
+
+    /**
+     * The helper for help and version options
+     */
+    private final ShowHelper showHelper;
+
+    /**
+     * Creates an object to handle tool options.
+     *
+     * @param context the context used to find other tool-related components
+     * @param messager the messager to be used to report diagnostics
+     */
+    ToolOptions(Context context, Messager messager, ShowHelper showHelper) {
+        this.messager = messager;
+        this.showHelper = showHelper;
+        compOpts = Options.instance(context);
+        fileManagerOpts = new LinkedHashMap<>();
+        compilerOptionHelper = getOptionHelper();
+        setAccessDefault();
+    }
+
+    /**
+     * Creates a minimal object, just sufficient to check the names of the
+     * supported options.
+     */
+    private ToolOptions() {
+        compOpts = null;
+        compilerOptionHelper = null;
+        fileManagerOpts = null;
+        messager = null;
+        showHelper = null;
+    }
+
+    /**
+     * Returns the set of options supported by the tool, excluding any options
+     * that are managed by the doclet that may be in use.
+     *
+     * @return the set of options
+     */
+    public List<ToolOption> getSupportedOptions() {
+        return supportedOptions;
+    }
+
+    /**
+     * Determines if the given option is supported and if so, the
+     * number of arguments the option takes.
+     *
+     * @param option an option
+     * @return the number of arguments the given option takes or -1 if
+     * the option is not supported
+     * @see javax.tools.DocumentationTool#isSupportedOption(String)
+     */
+    public static int isSupportedOption(String option) {
+        ToolOptions t = new ToolOptions();
+        for (ToolOption o : t.supportedOptions) {
+            for (String name : o.names) {
+                if (name.equals(option))
+                    return o.hasArg ? 1 : 0;
+            }
+        }
+        return -1;
+    }
 
+    /**
+     * Returns the option to be used to process an argument such as may be found on
+     * the command line.
+     *
+     * @param arg the argument
+     * @return the option
+     */
+    ToolOption getOption(String arg) {
+        String name = arg;
+        if (arg.startsWith("--") && arg.contains("=")) {
+            name = arg.substring(0, arg.indexOf('='));
+        }
+        for (ToolOption o : supportedOptions) {
+            for (String n : o.names) {
+                if (name.equals(n)) {
+                    return o;
+                }
+            }
+        }
+        return null;
+    }
+
+    private List<ToolOption> supportedOptions = List.of(
     // ----- options for underlying compiler -----
 
-    BOOTCLASSPATH("-bootclasspath", STANDARD, true) {
+            new ToolOption("-bootclasspath", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.BOOT_CLASS_PATH.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.BOOT_CLASS_PATH, primaryName, arg);
         }
     },
 
-    CLASS_PATH("--class-path -classpath -cp", STANDARD, true) {
+            new ToolOption("--class-path -classpath -cp", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.CLASS_PATH.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.CLASS_PATH, primaryName, arg);
         }
     },
 
-    EXTDIRS("-extdirs", STANDARD, true) {
+            new ToolOption("-extdirs", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.EXTDIRS.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.EXTDIRS, primaryName, arg);
         }
     },
 
-    SOURCE_PATH("--source-path -sourcepath", STANDARD, true) {
+            new ToolOption("--source-path -sourcepath", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.SOURCE_PATH.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.SOURCE_PATH, primaryName, arg);
         }
     },
 
-    MODULE_SOURCE_PATH("--module-source-path", STANDARD, true) {
+            new ToolOption("--module-source-path", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.MODULE_SOURCE_PATH.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.MODULE_SOURCE_PATH, primaryName, arg);
         }
     },
 
-    UPGRADE_MODULE_PATH("--upgrade-module-path", STANDARD, true) {
+            new ToolOption("--upgrade-module-path", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.UPGRADE_MODULE_PATH.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.UPGRADE_MODULE_PATH, primaryName, arg);
         }
     },
 
-    SYSTEM("--system", STANDARD, true) {
+            new ToolOption("--system", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.SYSTEM.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.SYSTEM, primaryName, arg);
         }
     },
 
-    MODULE_PATH("--module-path -p", STANDARD, true) {
+            new ToolOption("--module-path -p", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.MODULE_PATH.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.MODULE_PATH, primaryName, arg);
         }
     },
 
-    ADD_MODULES("--add-modules", STANDARD, true) {
+            new ToolOption("--add-modules", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.ADD_MODULES.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.ADD_MODULES, primaryName, arg);
         }
     },
 
-    LIMIT_MODULES("--limit-modules", STANDARD, true) {
+            new ToolOption("--limit-modules", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.LIMIT_MODULES.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.LIMIT_MODULES, primaryName, arg);
         }
     },
 
-    MODULE("--module", STANDARD, true) {
+            new ToolOption("--module", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) {
-            helper.addToList(this, ",", arg);
+                public void process(String arg) {
+                    modules.addAll(List.of(arg.split(",")));
         }
     },
 
-    ENCODING("-encoding", STANDARD, true) {
+            new ToolOption("-encoding", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.ENCODING.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.ENCODING, primaryName, arg);
         }
     },
 
-    RELEASE("--release", STANDARD, true) {
+            new ToolOption("--release", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.RELEASE.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.RELEASE, primaryName, arg);
         }
     },
 
-    SOURCE("--source -source", STANDARD, true) {
+            new ToolOption("--source -source", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.SOURCE.process(helper.getOptionHelper(), primaryName, arg);
-            Option.TARGET.process(helper.getOptionHelper(), Option.TARGET.primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.SOURCE, primaryName, arg);
+                    processCompilerOption(Option.TARGET, Option.TARGET.primaryName, arg);
         }
     },
 
-    XMAXERRS("-Xmaxerrs", EXTENDED, true) {
+            new ToolOption("-Xmaxerrs", EXTENDED, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.XMAXERRS.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.XMAXERRS, primaryName, arg);
         }
     },
 
-    XMAXWARNS("-Xmaxwarns", EXTENDED, true) {
+            new ToolOption("-Xmaxwarns", EXTENDED, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.XMAXWARNS.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.XMAXWARNS, primaryName, arg);
         }
     },
 
-    ADD_READS("--add-reads", EXTENDED, true) {
+            new ToolOption("--add-reads", EXTENDED, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.ADD_READS.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.ADD_READS, primaryName, arg);
         }
     },
 
-    ADD_EXPORTS("--add-exports", EXTENDED, true) {
+            new ToolOption("--add-exports", EXTENDED, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.ADD_EXPORTS.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.ADD_EXPORTS, primaryName, arg);
         }
     },
 
-    PATCH_MODULE("--patch-module", EXTENDED, true) {
+            new ToolOption("--patch-module", EXTENDED, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.PATCH_MODULE.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.PATCH_MODULE, primaryName, arg);
         }
     },
 
-    ADD_OPENS("--add-opens", HIDDEN, true) {
+            new ToolOption("--add-opens", HIDDEN, true) {
         @Override
-        public void process(Helper helper, String arg) throws InvalidValueException {
-            Option.ADD_OPENS.process(helper.getOptionHelper(), primaryName, arg);
+                public void process(String arg) throws InvalidValueException {
+                    processCompilerOption(Option.ADD_OPENS, primaryName, arg);
         }
     },
 
-    ENABLE_PREVIEW("--enable-preview", STANDARD) {
+            new ToolOption("--enable-preview", STANDARD) {
         @Override
-        public void process(Helper helper) throws InvalidValueException {
-            Option.PREVIEW.process(helper.getOptionHelper(), primaryName);
+                public void process() throws InvalidValueException {
+                    processCompilerOption(Option.PREVIEW, primaryName);
         }
     },
 
     // ----- doclet options -----
 
-    DOCLET("-doclet", STANDARD, true), // handled in setDocletInvoker
+            new ToolOption(DOCLET, STANDARD, true), // handled in setDocletInvoker
 
-    DOCLETPATH("-docletpath", STANDARD, true), // handled in setDocletInvoker
+            new ToolOption(DOCLET_PATH, STANDARD, true), // handled in setDocletInvoker
 
     // ----- selection options -----
 
-    SUBPACKAGES("-subpackages", STANDARD, true) {
+            new ToolOption("-subpackages", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) {
-            helper.addToList(this, ":", arg);
+                public void process(String arg) {
+                    subpackages.addAll(List.of(arg.split(":")));
         }
     },
 
-    EXCLUDE("-exclude", STANDARD, true) {
+            new ToolOption("-exclude", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) {
-            helper.addToList(this, ":", arg);
+                public void process(String arg) {
+                    excludes.addAll(List.of(arg.split(":")));
         }
     },
 
     // ----- filtering options -----
 
-    PACKAGE("-package", STANDARD) {
+            new ToolOption("-package", STANDARD) {
         @Override
-        public void process(Helper helper) throws OptionException {
-            helper.setSimpleFilter("package");
+                public void process() throws OptionException {
+                    setSimpleFilter("package");
         }
     },
 
-    PRIVATE("-private", STANDARD) {
+            new ToolOption("-private", STANDARD) {
         @Override
-        public void process(Helper helper) throws OptionException {
-            helper.setSimpleFilter("private");
+                public void process() throws OptionException {
+                    setSimpleFilter("private");
         }
     },
 
-    PROTECTED("-protected", STANDARD) {
+            new ToolOption("-protected", STANDARD) {
         @Override
-        public void process(Helper helper) throws OptionException {
-            helper.setSimpleFilter("protected");
+                public void process() throws OptionException {
+                    setSimpleFilter("protected");
         }
     },
 
-    PUBLIC("-public", STANDARD) {
+            new ToolOption("-public", STANDARD) {
         @Override
-        public void process(Helper helper) throws OptionException {
-            helper.setSimpleFilter("public");
+                public void process() throws OptionException {
+                    setSimpleFilter("public");
         }
     },
 
-    SHOW_MEMBERS("--show-members", STANDARD, true) {
+            new ToolOption("--show-members", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws OptionException {
-            helper.setFilter(this, arg);
+                public void process(String arg) throws OptionException {
+                    setShowMembersAccess(arg);
         }
     },
 
-    SHOW_TYPES("--show-types", STANDARD, true) {
+            new ToolOption("--show-types", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws OptionException {
-            helper.setFilter(this, arg);
+                public void process(String arg) throws OptionException {
+                    setShowTypesAccess(arg);
         }
     },
 
-    SHOW_PACKAGES("--show-packages", STANDARD, true) {
+            new ToolOption("--show-packages", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws OptionException {
-            helper.setShowPackageAccess(SHOW_PACKAGES, arg);
+                public void process(String arg) throws OptionException {
+                    setShowPackageAccess(arg);
         }
     },
 
-    SHOW_MODULE_CONTENTS("--show-module-contents", STANDARD, true) {
+            new ToolOption("--show-module-contents", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws OptionException {
-            helper.setShowModuleContents(SHOW_MODULE_CONTENTS, arg);
+                public void process(String arg) throws OptionException {
+                    setShowModuleContents(arg);
         }
     },
 
-    EXPAND_REQUIRES("--expand-requires", STANDARD, true) {
+            new ToolOption("--expand-requires", STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) throws OptionException {
-            helper.setExpandRequires(EXPAND_REQUIRES, arg);
+                public void process(String arg) throws OptionException {
+                    setExpandRequires(arg);
         }
     },
 
     // ----- output control options -----
 
-    QUIET("-quiet", STANDARD) {
+            new ToolOption("-quiet", STANDARD) {
         @Override
-        public void process(Helper helper) {
-            helper.jdtoolOpts.put(QUIET, true);
+                public void process() {
+                    quiet = true;
         }
     },
 
-    VERBOSE("-verbose", STANDARD) {
+            new ToolOption("-verbose", STANDARD) {
         @Override
-        public void process(Helper helper) {
-            helper.compOpts.put("-verbose", "");
+                public void process() {
+                    setVerbose();
         }
     },
 
-    XWERROR("-Xwerror", HIDDEN) {
+            new ToolOption("-Xwerror", HIDDEN) {
         @Override
-        public void process(Helper helper) {
-            helper.rejectWarnings = true;
-
+                public void process() {
+                    rejectWarnings = true;
         }
     },
 
     // ----- other options -----
 
-    BREAKITERATOR("-breakiterator", STANDARD) {
+            new ToolOption("-breakiterator", STANDARD) {
         @Override
-        public void process(Helper helper) {
-            helper.breakiterator = true;
+                public void process() {
+                    breakIterator = true;
         }
     },
 
-    LOCALE("-locale", STANDARD, true) {
+            new ToolOption(LOCALE, STANDARD, true) {
         @Override
-        public void process(Helper helper, String arg) {
-            helper.docLocale = arg;
+                public void process(String arg) {
+                    docLocale = arg;
         }
     },
 
-    XCLASSES("-Xclasses", HIDDEN) {
+            new ToolOption("-Xclasses", HIDDEN) {
         @Override
-        public void process(Helper helper) {
-            helper.jdtoolOpts.put(XCLASSES, true);
+                public void process() {
+                    xclasses = true;
         }
     },
 
-    DUMPONERROR("--dump-on-error", HIDDEN) {
+            new ToolOption(DUMP_ON_ERROR, HIDDEN) {
         @Override
-        public void process(Helper helper) {
-            helper.dumpOnError = true;
+                public void process() {
+                    dumpOnError = true;
         }
     },
 
-    IGNORE_SOURCE_ERRORS("--ignore-source-errors", HIDDEN) {
+            new ToolOption("--ignore-source-errors", HIDDEN) {
         @Override
-        public void process(Helper helper) {
-            helper.jdtoolOpts.put(IGNORE_SOURCE_ERRORS, true);
+                public void process() {
+                    ignoreSourceErrors = true;
         }
     },
 
     // ----- help options -----
 
-    HELP("--help -help -? -h", STANDARD) {
+            new ToolOption("--help -help -? -h", STANDARD) {
         @Override
-        public void process(Helper helper) throws OptionException {
-            throw new OptionException(OK, helper::usage);
+                public void process() throws OptionException {
+                    throw new OptionException(OK, showHelper::usage);
         }
     },
 
-    HELP_EXTRA("--help-extra -X", STANDARD) {
+            new ToolOption("--help-extra -X", STANDARD) {
         @Override
-        public void process(Helper helper) throws OptionException {
-           throw new OptionException(OK, helper::Xusage);
+                public void process() throws OptionException {
+                    throw new OptionException(OK, showHelper::Xusage);
         }
     },
 
     // This option exists only for the purpose of documenting itself.
     // It's actually implemented by the launcher.
-    J("-J", STANDARD, true) {
+            new ToolOption(J, STANDARD, true) {
         @Override
-        public void process(Helper helper) {
+                public void process() {
             throw new AssertionError("the -J flag should be caught by the launcher.");
         }
     },
 
-    VERSION("--version", STANDARD) {
+            new ToolOption("--version", STANDARD) {
         @Override
-        public void process(Helper helper) throws OptionException {
-            throw new OptionException(OK, helper::version);
+                public void process() throws OptionException {
+                    throw new OptionException(OK, showHelper::version);
         }
     },
 
-    FULLVERSION("--full-version", HIDDEN) {
+            new ToolOption("--full-version", HIDDEN) {
         @Override
-        public void process(Helper helper) throws OptionException {
-            throw new OptionException(OK, helper::fullVersion);
+                public void process() throws OptionException {
+                    throw new OptionException(OK, showHelper::fullVersion);
         }
-    };
+            });
+
+    /**
+     * Base class for all supported tool options.
+     */
+    static class ToolOption {
 
-    public final String primaryName;
-    public final List<String> names;
-    public final OptionKind kind;
-    public final boolean hasArg;
-    public final boolean hasSuffix; // ex: foo:bar or -foo=bar
+        final String primaryName;
+        final List<String> names;
+        final OptionKind kind;
+        final boolean hasArg;
+        final boolean hasSuffix; // ex: foo:bar or -foo=bar
 
     ToolOption(String opt, OptionKind kind) {
         this(opt, kind, false);
     }
 

@@ -407,13 +616,13 @@
         this.hasArg = hasArg;
         char lastChar = names.charAt(names.length() - 1);
         this.hasSuffix = lastChar == ':' || lastChar == '=';
     }
 
-    void process(Helper helper, String arg) throws OptionException, Option.InvalidValueException { }
+        void process(String arg) throws OptionException, Option.InvalidValueException { }
 
-    void process(Helper helper) throws OptionException, Option.InvalidValueException { }
+        void process() throws OptionException, Option.InvalidValueException { }
 
     List<String> getNames() {
         return names;
     }
 

@@ -433,131 +642,298 @@
                 .replaceAll("^-*", "")              // remove leading '-'
                 .replaceAll("[^A-Za-z0-9]+$", "")   // remove trailing non-alphanumeric
                 .replaceAll("[^A-Za-z0-9]", ".")    // replace internal non-alphanumeric
                 + suffix;
     }
+    }
 
+    interface ShowHelper {
+        /**
+         * Show command-line help for the standard options, as requested by
+         * the {@code --help} option and its aliases.
+         */
+        void usage();
+
+        /**
+         * Show command-line help for the extended options, as requested by
+         * the {@code --help-extended} option and its aliases.
+         */
+        void Xusage();
+
+        /**
+         * Show the basic version information, as requested by the {@code --version} option.
+         */
+        void version();
 
-    static ToolOption get(String name) {
-        String oname = name;
-        if (name.startsWith("--") && name.contains("=")) {
-            oname = name.substring(0, name.indexOf('='));
+        /**
+         * Show the full version information, as requested by the {@code --full-version} option.
+         */
+        void fullVersion();
         }
-        for (ToolOption o : values()) {
-            for (String n : o.names) {
-                if (oname.equals(n)) {
-                    return o;
+
+    //<editor-fold desc="accessor methods">
+    /**
+     * Argument for command-line option {@code -breakiterator}.
+     */
+    boolean breakIterator() {
+        return breakIterator;
                 }
+
+    /**
+     * Argument for command-line option {@code -locale}.
+     */
+    String locale() {
+        return docLocale;
             }
+
+    /**
+     * Argument for command-line option {@code --dump-on-error}.
+     * Dump stack traces for debugging etc.
+     * Similar to javac {@code -doe}.
+     */
+    boolean dumpOnError() {
+        return dumpOnError;
         }
-        return null;
+
+    void setDumpOnError(boolean v) {
+        dumpOnError = true;
     }
 
-    abstract static class Helper {
+    /**
+     * Argument for command-line option {@code -exclude}.
+     */
+    List<String> excludes() {
+        return excludes;
+    }
 
-        // File manager options
-        final Map<Option, String> fileManagerOpts = new LinkedHashMap<>();
+    /**
+     * Argument for command-line option {@code --expand-requires}.
+     */
+    AccessKind expandRequires() {
+        return expandRequires;
+    }
 
-        /** javac options, set by various options. */
-        Options compOpts; // = Options.instance(context)
+    /**
+     * Argument for command-line option {@code --ignore-source-errors}.
+     */
+    boolean ignoreSourceErrors() {
+        return ignoreSourceErrors;
+    }
 
-        /** Javadoc tool options */
-        final Map<ToolOption, Object> jdtoolOpts = new EnumMap<>(ToolOption.class);
+    /**
+     * Argument for command-line option {@code --module}.
+     */
+    List<String> modules() {
+        return modules;
+    }
 
-        /** dump stack traces for debugging etc.*/
-        boolean dumpOnError = false;
+    /**
+     * Argument for command-line option {@code -Xwerror}.
+     * Set by -Xwerror.
+     */
+    boolean rejectWarnings() {
+        return rejectWarnings;
+    }
 
-        /** Set by -breakiterator. */
-        boolean breakiterator = false;
+    /**
+     * Argument for command-line option {@code --show-members}.
+     */
+    AccessKind showMembersAccess() {
+        return showMembersAccess;
+    }
 
-        /** Set by -Xwerror. */
-        boolean rejectWarnings = false;
+    /**
+     * Argument for command-line option {@code --show-types}.
+     */
+    AccessKind showTypesAccess() {
+        return showTypesAccess;
+    }
 
-        /** Set by -prompt. */
-        boolean promptOnError;
+    /**
+     * Argument for command-line option {@code --show-packages}.
+     */
+    AccessKind showPackagesAccess() {
+        return showPackagesAccess;
+    }
 
-        /** Set by -locale. */
-        String docLocale = "";
+    /**
+     * Argument for command-line option {@code --show-module-contents}.
+     */
+    AccessKind showModuleContents() {
+        return showModuleContents;
+    }
 
-        Helper() {
-            populateDefaultAccessMap();
+    /**
+     * Argument for command-line option {@code -quiet}.
+     */
+    boolean quiet() {
+        return quiet;
         }
 
-        abstract void usage();
-        abstract void Xusage();
+    /**
+     * Argument for command-line option {@code -subpackages}.
+     */
+    List<String> subpackages() {
+        return subpackages;
+    }
 
-        abstract void version();
-        abstract void fullVersion();
+    /**
+     * Argument for command-line option {@code -verbose}.
+     */
+    boolean verbose() {
+        return verbose;
+    }
 
-        abstract String getLocalizedMessage(String msg, Object... args);
+    /**
+     * Argument for command-line option {@code -xclasses}.
+     * If true, names on the command line that would normally be
+     * treated as package names are treated as class names instead.
+     */
+    boolean xclasses() {
+        return xclasses;
+    }
 
-        abstract OptionHelper getOptionHelper();
+    /**
+     * Returns the set of options to be used for the instance of the
+     * underlying compiler front-end.
+     *
+     * @return the options
+     */
+    Options compilerOptions() {
+        return compOpts;
+    }
 
-        @SuppressWarnings("unchecked")
-        void addToList(ToolOption opt, String delimiter, String str) {
-            List<String> list = (List<String>) jdtoolOpts.computeIfAbsent(opt, v -> new ArrayList<>());
-            list.addAll(Arrays.asList(str.split(delimiter)));
-            jdtoolOpts.put(opt, list);
+    /**
+     * Returns the set of options to be used for the file manager.
+     *
+     * @return the options
+     */
+    Map<Option, String> fileManagerOptions() {
+        return fileManagerOpts;
         }
+    //</editor-fold>
 
-        void setExpandRequires(ToolOption opt, String arg) throws OptionException {
+    /**
+     * Returns an {@code IllegalOptionValue} exception.
+     *
+     * @param arg the arghument to include in the detail message
+     * @return the exception
+     */
+    private IllegalOptionValue illegalOptionValue(String arg) {
+        return new IllegalOptionValue(showHelper::usage, messager.getText("main.illegal_option_value", arg));
+    }
+
+    /**
+     * Process a compiler option.
+     *
+     * @param option the option object to process the command-line option
+     * @param opt    the command-line option
+     * @throws Option.InvalidValueException if the command-line option is invalid
+     */
+    void processCompilerOption(Option option, String opt) throws Option.InvalidValueException {
+        option.process(compilerOptionHelper, opt);
+    }
+
+    /**
+     * Process a compiler option.
+     *
+     * @param option the option object to process the command-line option
+     * @param opt    the command-line option
+     * @param arg    the argument for the command-line option
+     * @throws Option.InvalidValueException if the command-line option is invalid
+     */
+    private void processCompilerOption(Option option, String opt, String arg) throws Option.InvalidValueException {
+        option.process(compilerOptionHelper, opt, arg);
+    }
+
+    /**
+     * Returns a "helper" to be used when processing compiler options.
+     * @return the helper
+     */
+    private OptionHelper getOptionHelper() {
+        return new OptionHelper.GrumpyHelper(messager) {
+            @Override
+            public String get(com.sun.tools.javac.main.Option option) {
+                return compOpts.get(option);
+            }
+
+            @Override
+            public void put(String name, String value) {
+                compOpts.put(name, value);
+            }
+
+            @Override
+            public void remove(String name) {
+                compOpts.remove(name);
+            }
+
+            @Override
+            public boolean handleFileManagerOption(com.sun.tools.javac.main.Option option, String value) {
+                fileManagerOpts.put(option, value);
+                return true;
+            }
+        };
+    }
+
+    private void setExpandRequires(String arg) throws OptionException {
             switch (arg) {
                 case "transitive":
-                    jdtoolOpts.put(opt, AccessKind.PUBLIC);
+                expandRequires = AccessKind.PUBLIC;
                     break;
                 case "all":
-                    jdtoolOpts.put(opt, AccessKind.PRIVATE);
+                expandRequires = AccessKind.PRIVATE;
                     break;
                 default:
-                    String text = getLocalizedMessage("main.illegal_option_value", arg);
-                    throw new IllegalOptionValue(this::usage, text);
+                throw illegalOptionValue(arg);
             }
         }
 
-        void setShowModuleContents(ToolOption opt, String arg) throws OptionException {
+    private void setShowModuleContents(String arg) throws OptionException {
             switch (arg) {
                 case "api":
-                    jdtoolOpts.put(opt, AccessKind.PUBLIC);
+                showModuleContents = AccessKind.PUBLIC;
                     break;
                 case "all":
-                    jdtoolOpts.put(opt, AccessKind.PRIVATE);
+                showModuleContents = AccessKind.PRIVATE;
                     break;
                 default:
-                    String text = getLocalizedMessage("main.illegal_option_value", arg);
-                    throw new IllegalOptionValue(this::usage, text);
+                throw illegalOptionValue(arg);
             }
         }
 
-        void setShowPackageAccess(ToolOption opt, String arg) throws OptionException {
+    private void setShowPackageAccess(String arg) throws OptionException {
             switch (arg) {
                 case "exported":
-                    jdtoolOpts.put(opt, AccessKind.PUBLIC);
+                showPackagesAccess = AccessKind.PUBLIC;
                     break;
                 case "all":
-                    jdtoolOpts.put(opt, AccessKind.PRIVATE);
+                showPackagesAccess = AccessKind.PRIVATE;
                     break;
                 default:
-                    String text = getLocalizedMessage("main.illegal_option_value", arg);
-                    throw new IllegalOptionValue(this::usage, text);
+                throw illegalOptionValue(arg);
             }
         }
 
+    private void setShowTypesAccess(String arg) throws OptionException {
+        showTypesAccess = getAccessValue(arg);
+    }
 
-        void setFilter(ToolOption opt, String arg) throws OptionException {
-            jdtoolOpts.put(opt, getAccessValue(arg));
+    private void setShowMembersAccess(String arg) throws OptionException {
+        showMembersAccess = getAccessValue(arg);
         }
 
-        void setSimpleFilter(String arg) throws OptionException {
-            handleSimpleOption(arg);
+    private void setSimpleFilter(String arg) throws OptionException {
+        setSimpleAccessOption(arg);
         }
 
-        void setFileManagerOpt(Option opt, String arg) {
-            fileManagerOpts.put(opt, arg);
+    private void setVerbose() {
+        compOpts.put("-verbose", "");
+        verbose = true;
         }
 
-        void handleSimpleOption(String arg) throws OptionException {
-            populateSimpleAccessMap(getAccessValue(arg));
+    private void setSimpleAccessOption(String arg) throws OptionException {
+        setAccess(getAccessValue(arg));
         }
 
         /*
          * This method handles both the simple options -package,
          * -private, so on, in addition to the new ones such as

@@ -576,43 +952,41 @@
                 case "package":
                     return AccessKind.PACKAGE;
                 case "private":
                     return AccessKind.PRIVATE;
                 default:
-                    String text = getLocalizedMessage("main.illegal_option_value", value);
-                    throw new IllegalOptionValue(this::usage, text);
+                throw illegalOptionValue(value);
             }
         }
 
         /*
-         * Sets the entire kind map to PROTECTED this is the default.
+     * Sets all access members to PROTECTED; this is the default.
          */
-        private void populateDefaultAccessMap() {
-            populateSimpleAccessMap(AccessKind.PROTECTED);
+    private void setAccessDefault() {
+        setAccess(AccessKind.PROTECTED);
         }
 
         /*
          * This sets access to all the allowed kinds in the
-         * access map.
+     * access members.
          */
-        void populateSimpleAccessMap(AccessKind accessValue) {
+    private void setAccess(AccessKind accessValue) {
             for (ElementKind kind : ElementsTable.ModifierFilter.ALLOWED_KINDS) {
                 switch (kind) {
                     case METHOD:
-                        jdtoolOpts.put(SHOW_MEMBERS, accessValue);
+                    showMembersAccess = accessValue;
                         break;
                     case CLASS:
-                        jdtoolOpts.put(SHOW_TYPES, accessValue);
+                    showTypesAccess = accessValue;
                         break;
                     case PACKAGE:
-                        jdtoolOpts.put(SHOW_PACKAGES, accessValue);
+                    showPackagesAccess = accessValue;
                         break;
                     case MODULE:
-                        jdtoolOpts.put(SHOW_MODULE_CONTENTS, accessValue);
+                    showModuleContents = accessValue;
                         break;
                     default:
                         throw new AssertionError("unknown element kind:" + kind);
                 }
             }
         }
-    }
 }
< prev index next >