jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/main/RecognizedOptions.java

-:508c01999047
+:b66d15dfd001
 * have any questions.
 */
 package com.sun.tools.javac.main;
+import com.sun.tools.javac.code.Lint;
 import com.sun.tools.javac.code.Source;
 import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.jvm.Target;
 import com.sun.tools.javac.main.JavacOption.HiddenOption;
 import com.sun.tools.javac.main.JavacOption.Option;
 import com.sun.tools.javac.main.JavacOption.XOption;
-import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.ListBuffer;
-import com.sun.tools.javac.util.Log;
 import com.sun.tools.javac.util.Options;
 import com.sun.tools.javac.processing.JavacProcessingEnvironment;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.EnumSet;
+import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.StringTokenizer;
 import javax.lang.model.SourceVersion;
 import static com.sun.tools.javac.main.OptionName.*;
 XBOOTCLASSPATH,
 EXTDIRS,
 DJAVA_EXT_DIRS,
 ENDORSEDDIRS,
 DJAVA_ENDORSED_DIRS,
-PROC_CUSTOM,
+PROC,
 PROCESSOR,
 PROCESSORPATH,
 D,
 S,
 IMPLICIT,
 XLINT,
 XLINT_CUSTOM,
 NOWARN,
 VERBOSE,
 DEPRECATION,
-PROC_CUSTOM,
+PROC,
 PROCESSOR,
 IMPLICIT,
 SOURCE,
 TARGET,
 // VERSION,
 options.append(option);
 return options.toArray(new Option[options.length()]);
 }
 /**
-* @param out the writer to use for diagnostic output
+* Get all the recognized options.
+* @param helper an {@code OptionHelper} to help when processing options
+* @return an array of options
 */
 public static Option[] getAll(final OptionHelper helper) {
-return new Option[]{
+return new Option[] {
 new Option(G,                                           "opt.g"),
 new Option(G_NONE,                                      "opt.g.none") {
+@Override
 public boolean process(Options options, String option) {
 options.put("-g:", "none");
 return false;
 }
 },
-new Option(G_CUSTOM,                                    "opt.g.lines.vars.source") {
+new Option(G_CUSTOM,                                    "opt.g.lines.vars.source",
-public boolean matches(String s) {
+Option.ChoiceKind.ANYOF, "lines", "vars", "source"),
-return s.startsWith("-g:");
-}
-public boolean process(Options options, String option) {
-String suboptions = option.substring(3);
-options.put("-g:", suboptions);
-// enter all the -g suboptions as "-g:suboption"
-for (StringTokenizer t = new StringTokenizer(suboptions, ","); t.hasMoreTokens(); ) {
-String tok = t.nextToken();
-String opt = "-g:" + tok;
-options.put(opt, opt);
-}
-return false;
-}
-},
 new XOption(XLINT,                                      "opt.Xlint"),
-new XOption(XLINT_CUSTOM,                               "opt.Xlint.suboptlist") {
+new XOption(XLINT_CUSTOM,                               "opt.Xlint.suboptlist",
-public boolean matches(String s) {
+Option.ChoiceKind.ANYOF, getXLintChoices()),
-return s.startsWith("-Xlint:");
-}
-public boolean process(Options options, String option) {
-String suboptions = option.substring(7);
-options.put("-Xlint:", suboptions);
-// enter all the -Xlint suboptions as "-Xlint:suboption"
-for (StringTokenizer t = new StringTokenizer(suboptions, ","); t.hasMoreTokens(); ) {
-String tok = t.nextToken();
-String opt = "-Xlint:" + tok;
-options.put(opt, opt);
-}
-return false;
-}
-},
 // -nowarn is retained for command-line backward compatibility
 new Option(NOWARN,                                      "opt.nowarn") {
-public boolean process(Options options, String option) {
+@Override
-options.put("-Xlint:none", option);
+public boolean process(Options options, String option) {
-return false;
+options.put("-Xlint:none", option);
-}
+return false;
-},
+}
+},
 new Option(VERBOSE,                                     "opt.verbose"),
 // -deprecation is retained for command-line backward compatibility
 new Option(DEPRECATION,                                 "opt.deprecation") {
-public boolean process(Options options, String option) {
+@Override
-options.put("-Xlint:deprecation", option);
+public boolean process(Options options, String option) {
-return false;
+options.put("-Xlint:deprecation", option);
-}
+return false;
-},
+}
+},
 new Option(CLASSPATH,              "opt.arg.path",      "opt.classpath"),
 new Option(CP,                     "opt.arg.path",      "opt.classpath") {
+@Override
 public boolean process(Options options, String option, String arg) {
 return super.process(options, "-classpath", arg);
 }
 },
 new Option(SOURCEPATH,             "opt.arg.path",      "opt.sourcepath"),
 new Option(BOOTCLASSPATH,          "opt.arg.path",      "opt.bootclasspath") {
+@Override
 public boolean process(Options options, String option, String arg) {
 options.remove("-Xbootclasspath/p:");
 options.remove("-Xbootclasspath/a:");
 return super.process(options, option, arg);
 }
 },
 new XOption(XBOOTCLASSPATH_PREPEND,"opt.arg.path", "opt.Xbootclasspath.p"),
 new XOption(XBOOTCLASSPATH_APPEND, "opt.arg.path", "opt.Xbootclasspath.a"),
 new XOption(XBOOTCLASSPATH,        "opt.arg.path", "opt.bootclasspath") {
+@Override
 public boolean process(Options options, String option, String arg) {
 options.remove("-Xbootclasspath/p:");
 options.remove("-Xbootclasspath/a:");
 return super.process(options, "-bootclasspath", arg);
 }
 },
 new Option(EXTDIRS,                "opt.arg.dirs",      "opt.extdirs"),
 new XOption(DJAVA_EXT_DIRS,        "opt.arg.dirs",      "opt.extdirs") {
+@Override
 public boolean process(Options options, String option, String arg) {
 return super.process(options, "-extdirs", arg);
 }
 },
 new Option(ENDORSEDDIRS,            "opt.arg.dirs",     "opt.endorseddirs"),
 new XOption(DJAVA_ENDORSED_DIRS,    "opt.arg.dirs",     "opt.endorseddirs") {
+@Override
 public boolean process(Options options, String option, String arg) {
 return super.process(options, "-endorseddirs", arg);
 }
 },
-new Option(PROC_CUSTOM,                                 "opt.proc.none.only") {
+new Option(PROC,                                 "opt.proc.none.only",
-public boolean matches(String s) {
+Option.ChoiceKind.ONEOF, "none", "only"),
-return s.equals("-proc:none") || s.equals("-proc:only");
-}
-public boolean process(Options options, String option) {
-if (option.equals("-proc:none")) {
-options.remove("-proc:only");
-} else {
-options.remove("-proc:none");
-}
-options.put(option, option);
-return false;
-}
-},
 new Option(PROCESSOR,           "opt.arg.class.list",   "opt.processor"),
 new Option(PROCESSORPATH,       "opt.arg.path",         "opt.processorpath"),
 new Option(D,                   "opt.arg.directory",    "opt.d"),
 new Option(S,                   "opt.arg.directory",    "opt.sourceDest"),
-new Option(IMPLICIT,                                    "opt.implicit") {
+new Option(IMPLICIT,                                    "opt.implicit",
-public boolean matches(String s) {
+Option.ChoiceKind.ONEOF, "none", "class"),
-return s.equals("-implicit:none") || s.equals("-implicit:class");
-}
-public boolean process(Options options, String option, String operand) {
-int sep = option.indexOf(":");
-options.put(option.substring(0, sep), option.substring(sep+1));
-options.put(option,option);
-return false;
-}
-},
 new Option(ENCODING,            "opt.arg.encoding",     "opt.encoding"),
 new Option(SOURCE,              "opt.arg.release",      "opt.source") {
+@Override
 public boolean process(Options options, String option, String operand) {
 Source source = Source.lookup(operand);
 if (source == null) {
 helper.error("err.invalid.source", operand);
 return true;
 }
 return super.process(options, option, operand);
 }
 },
 new Option(TARGET,              "opt.arg.release",      "opt.target") {
+@Override
 public boolean process(Options options, String option, String operand) {
 Target target = Target.lookup(operand);
 if (target == null) {
 helper.error("err.invalid.target", operand);
 return true;
 }
 return super.process(options, option, operand);
 }
 },
 new Option(VERSION,                                     "opt.version") {
+@Override
 public boolean process(Options options, String option) {
 helper.printVersion();
 return super.process(options, option);
 }
 },
 new HiddenOption(FULLVERSION) {
+@Override
 public boolean process(Options options, String option) {
 helper.printFullVersion();
 return super.process(options, option);
 }
 },
 new Option(HELP,                                        "opt.help") {
+@Override
 public boolean process(Options options, String option) {
 helper.printHelp();
 return super.process(options, option);
 }
 },
 new Option(A,                "opt.arg.key.equals.value","opt.A") {
-String helpSynopsis() {
+@Override
-hasSuffix = true;
+String helpSynopsis() {
-return super.helpSynopsis();
+hasSuffix = true;
+return super.helpSynopsis();
+}
+@Override
+public boolean matches(String arg) {
+return arg.startsWith("-A");
+}
+@Override
+public boolean hasArg() {
+return false;
+}
+// Mapping for processor options created in
+// JavacProcessingEnvironment
+@Override
+public boolean process(Options options, String option) {
+int argLength = option.length();
+if (argLength == 2) {
+helper.error("err.empty.A.argument");
+return true;
 }
+int sepIndex = option.indexOf('=');
-public boolean matches(String arg) {
+String key = option.substring(2, (sepIndex != -1 ? sepIndex : argLength) );
-return arg.startsWith("-A");
+if (!JavacProcessingEnvironment.isValidOptionName(key)) {
+helper.error("err.invalid.A.key", option);
+return true;
 }
+return process(options, option, option);
-public boolean hasArg() {
+}
-return false;
-}
-// Mapping for processor options created in
-// JavacProcessingEnvironment
-public boolean process(Options options, String option) {
-int argLength = option.length();
-if (argLength == 2) {
-helper.error("err.empty.A.argument");
-return true;
-}
-int sepIndex = option.indexOf('=');
-String key = option.substring(2, (sepIndex != -1 ? sepIndex : argLength) );
-if (!JavacProcessingEnvironment.isValidOptionName(key)) {
-helper.error("err.invalid.A.key", option);
-return true;
-}
-return process(options, option, option);
-}
 },
 new Option(X,                                           "opt.X") {
+@Override
 public boolean process(Options options, String option) {
 helper.printXhelp();
 return super.process(options, option);
 }
 },
 // This option exists only for the purpose of documenting itself.
 // It's actually implemented by the launcher.
 new Option(J,                   "opt.arg.flag",         "opt.J") {
+@Override
 String helpSynopsis() {
 hasSuffix = true;
 return super.helpSynopsis();
 }
+@Override
 public boolean process(Options options, String option) {
 throw new AssertionError
 ("the -J flag should be caught by the launcher.");
 }
 },
 // stop after parsing and attributing.
 // new HiddenOption("-attrparseonly"),
 // new Option("-moreinfo",                                      "opt.moreinfo") {
 new HiddenOption(MOREINFO) {
+@Override
 public boolean process(Options options, String option) {
 Type.moreInfo = true;
 return super.process(options, option);
 }
 },
 // new Option("-scramble",                              "opt.scramble"),
 // new Option("-scrambleall",                           "opt.scrambleall"),
 // display warnings for generic unchecked operations
 new HiddenOption(WARNUNCHECKED) {
+@Override
 public boolean process(Options options, String option) {
 options.put("-Xlint:unchecked", option);
 return false;
 }
 },
 new XOption(XMAXERRS,           "opt.arg.number",       "opt.maxerrs"),
 new XOption(XMAXWARNS,          "opt.arg.number",       "opt.maxwarns"),
 new XOption(XSTDOUT,            "opt.arg.file",         "opt.Xstdout") {
+@Override
 public boolean process(Options options, String option, String arg) {
 try {
 helper.setOut(new PrintWriter(new FileWriter(arg), true));
 } catch (java.io.IOException e) {
 helper.error("err.error.writing.file", arg, e);
 new XOption(XPRINTROUNDS,                               "opt.printRounds"),
 new XOption(XPRINTPROCESSORINFO,                        "opt.printProcessorInfo"),
-new XOption(XPREFER,                                     "opt.prefer") {
+new XOption(XPREFER,                                    "opt.prefer",
-public boolean matches(String s) {
+Option.ChoiceKind.ONEOF, "source", "newer"),
-return s.equals("-Xprefer:source") || s.equals("-Xprefer:newer");
-}
-public boolean process(Options options, String option, String operand) {
-int sep = option.indexOf(":");
-options.put(option.substring(0, sep), option.substring(sep+1));
-options.put(option,option);
-return false;
-}
-},
 /* -O is a no-op, accepted for backward compatibility. */
 new HiddenOption(O),
 /* -Xjcov produces tables to support the code coverage tool jcov. */
 * -XDx=y sets the option x to the value y.
 * -XDx sets the option x to the value x.
 */
 new HiddenOption(XD) {
 String s;
+@Override
 public boolean matches(String s) {
 this.s = s;
 return s.startsWith(name.optionName);
 }
+@Override
 public boolean process(Options options, String option) {
 s = s.substring(name.optionName.length());
 int eq = s.indexOf('=');
 String key = (eq < 0) ? s : s.substring(0, eq);
 String value = (eq < 0) ? s : s.substring(eq+1);
 * In apt, the process method adds the candiate class file
 * name to a separate list.
 */
 new HiddenOption(SOURCEFILE) {
 String s;
+@Override
 public boolean matches(String s) {
 this.s = s;
 return s.endsWith(".java")  // Java source file
 || SourceVersion.isName(s);   // Legal type name
 }
+@Override
 public boolean process(Options options, String option) {
 if (s.endsWith(".java") ) {
 File f = new File(s);
 if (!f.exists()) {
 helper.error("err.file.not.found", f);
 }
 },
 };
 }
+private static Collection<String> getXLintChoices() {
+Collection<String> choices = new LinkedHashSet<String>();
+choices.add("all");
+for (Lint.LintCategory c : Lint.LintCategory.values())
+choices.add(c.option);
+for (Lint.LintCategory c : Lint.LintCategory.values())
+choices.add("-" + c.option);
+choices.add("none");
+return choices;
+}
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/main/RecognizedOptions.java

src/share/classes/com/sun/tools/javac/main/RecognizedOptions.java