< prev index next >

langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/main/Arguments.java

Print this page

        

@@ -61,10 +61,11 @@
 import com.sun.tools.javac.platform.PlatformDescription;
 import com.sun.tools.javac.platform.PlatformUtils;
 import com.sun.tools.javac.resources.CompilerProperties.Errors;
 import com.sun.tools.javac.resources.CompilerProperties.Warnings;
 import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.JCDiagnostic;
 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.Log.PrefixKind;
 import com.sun.tools.javac.util.Log.WriterKind;

@@ -141,11 +142,11 @@
             options.remove(name);
         }
 
         @Override
         public boolean handleFileManagerOption(Option option, String value) {
-            options.put(option.getText(), value);
+            options.put(option, value);
             deferredFileManagerOptions.put(option, value);
             return true;
         }
 
         @Override

@@ -162,10 +163,15 @@
         public void error(String key, Object... args) {
             Arguments.this.error(key, args);
         }
 
         @Override
+        public void error(JCDiagnostic.Error error) {
+            Arguments.this.error(error);
+        }
+
+        @Override
         public void addFile(Path p) {
             files.add(p);
         }
 
         @Override

@@ -191,16 +197,19 @@
         files = new LinkedHashSet<>();
         deferredFileManagerOptions = new LinkedHashMap<>();
         fileObjects = null;
         classNames = new LinkedHashSet<>();
         processArgs(List.from(args), Option.getJavaCompilerOptions(), cmdLineHelper, true, false);
+        if (errors) {
+            log.printLines(PrefixKind.JAVAC, "msg.usage", ownName);
+        }
     }
 
     private final OptionHelper apiHelper = new GrumpyHelper(null) {
         @Override
         public String get(Option option) {
-            return options.get(option.getText());
+            return options.get(option);
         }
 
         @Override
         public void put(String name, String value) {
             options.put(name, value);

@@ -295,12 +304,12 @@
             return false;
 
         String platformString = options.get(Option.RELEASE);
 
         checkOptionAllowed(platformString == null,
-                option -> error("err.release.bootclasspath.conflict", option.getText()),
-                Option.BOOTCLASSPATH, Option.XBOOTCLASSPATH, Option.XBOOTCLASSPATH_APPEND,
+                option -> error("err.release.bootclasspath.conflict", option.getPrimaryName()),
+                Option.BOOT_CLASS_PATH, Option.XBOOTCLASSPATH, Option.XBOOTCLASSPATH_APPEND,
                 Option.XBOOTCLASSPATH_PREPEND,
                 Option.ENDORSEDDIRS, Option.DJAVA_ENDORSED_DIRS,
                 Option.EXTDIRS, Option.DJAVA_EXT_DIRS,
                 Option.SOURCE, Option.TARGET);
 

@@ -358,44 +367,34 @@
                 error("err.invalid.flag", arg);
                 return false;
             }
 
             Option option = null;
+
+            // first, check the provided set of javac options
             if (arg.startsWith("-")) {
-                for (Option o : allowableOpts) {
-                    if (o.matches(arg)) {
-                        option = o;
-                        break;
-                    }
-                }
+                option = Option.lookup(arg, allowableOpts);
             } else if (allowOperands && Option.SOURCEFILE.matches(arg)) {
                 option = Option.SOURCEFILE;
             }
 
-            if (option == null) {
-                if (fm != null && fm.handleOption(arg, argIter)) {
-                    continue;
-                }
-                error("err.invalid.flag", arg);
+            if (option != null) {
+                if (!option.handleOption(helper, arg, argIter)) {
                 return false;
             }
-
-            if (option.hasArg()) {
-                if (!argIter.hasNext()) {
-                    error("err.req.arg", arg);
-                    return false;
+                continue;
                 }
-                String operand = argIter.next();
-                if (option.process(helper, arg, operand)) {
-                    return false;
+
+            // check file manager option
+            if (fm != null && fm.handleOption(arg, argIter)) {
+                continue;
                 }
-            } else {
-                if (option.process(helper, arg)) {
+
+            // none of the above
+            error("err.invalid.flag", arg);
                     return false;
                 }
-            }
-        }
 
         return true;
     }
 
     /**

@@ -405,17 +404,17 @@
      * @throws IllegalStateException if a problem is found and errorMode is set to
      *      ILLEGAL_STATE
      */
     public boolean validate() {
         JavaFileManager fm = getFileManager();
-        if (options.isSet(Option.M)) {
+        if (options.isSet(Option.MODULE)) {
             if (!fm.hasLocation(StandardLocation.CLASS_OUTPUT)) {
                 log.error(Errors.OutputDirMustBeSpecifiedWithDashMOption);
             } else if (!fm.hasLocation(StandardLocation.MODULE_SOURCE_PATH)) {
                 log.error(Errors.ModulesourcepathMustBeSpecifiedWithDashMOption);
             } else {
-                java.util.List<String> modules = Arrays.asList(options.get(Option.M).split(","));
+                java.util.List<String> modules = Arrays.asList(options.get(Option.MODULE).split(","));
                 try {
                     for (String module : modules) {
                         Location sourceLoc = fm.getModuleLocation(StandardLocation.MODULE_SOURCE_PATH, module);
                         if (sourceLoc == null) {
                             log.error(Errors.ModuleNotFoundInModuleSourcePath(module));

@@ -447,21 +446,24 @@
             // But also note that none of these options are supported in API mode.
             if (options.isSet(Option.HELP)
                 || options.isSet(Option.X)
                 || options.isSet(Option.VERSION)
                 || options.isSet(Option.FULLVERSION)
-                || options.isSet(Option.M))
+                || options.isSet(Option.MODULE))
                 return true;
 
             if (emptyAllowed)
                 return true;
 
+            if (!errors) {
             if (JavaCompiler.explicitAnnotationProcessingRequested(options)) {
                 error("err.no.source.files.classes");
             } else {
                 error("err.no.source.files");
             }
+            }
+
             return false;
         }
 
         if (!checkDirectory(Option.D)) {
             return false;

@@ -540,16 +542,16 @@
                 error("warn.profile.target.conflict", profileString, target.name);
             }
 
             // This check is only effective in command line mode,
             // where the file manager options are added to options
-            if (options.get(Option.BOOTCLASSPATH) != null) {
+            if (options.get(Option.BOOT_CLASS_PATH) != null) {
                 error("err.profile.bootclasspath.conflict");
             }
         }
 
-        if (options.isSet(Option.SOURCEPATH) && options.isSet(Option.MODULESOURCEPATH)) {
+        if (options.isSet(Option.SOURCE_PATH) && options.isSet(Option.MODULE_SOURCE_PATH)) {
             error("err.sourcepath.modulesourcepath.conflict");
         }
 
         boolean lintOptions = options.isUnset(Option.XLINT_CUSTOM, "-" + LintCategory.OPTIONS.option);
 

@@ -576,21 +578,21 @@
             obsoleteOptionFound = true;
         }
 
         final Target t = target;
         checkOptionAllowed(t.compareTo(Target.JDK1_8) <= 0,
-                option -> error("err.option.not.allowed.with.target", option.getText(), t.name),
-                Option.BOOTCLASSPATH,
+                option -> error("err.option.not.allowed.with.target", option.getPrimaryName(), t.name),
+                Option.BOOT_CLASS_PATH,
                 Option.XBOOTCLASSPATH_PREPEND, Option.XBOOTCLASSPATH, Option.XBOOTCLASSPATH_APPEND,
                 Option.ENDORSEDDIRS, Option.DJAVA_ENDORSED_DIRS,
                 Option.EXTDIRS, Option.DJAVA_EXT_DIRS);
 
         checkOptionAllowed(t.compareTo(Target.JDK1_9) >= 0,
-                option -> error("err.option.not.allowed.with.target", option.getText(), t.name),
-                Option.MODULESOURCEPATH, Option.UPGRADEMODULEPATH,
-                Option.SYSTEM, Option.MODULEPATH, Option.ADDMODS, Option.LIMITMODS,
-                Option.XPATCH);
+                option -> error("err.option.not.allowed.with.target", option.getPrimaryName(), t.name),
+                Option.MODULE_SOURCE_PATH, Option.UPGRADE_MODULE_PATH,
+                Option.SYSTEM, Option.MODULE_PATH, Option.ADD_MODULES, Option.LIMIT_MODULES,
+                Option.PATCH_MODULE);
 
         if (fm.hasLocation(StandardLocation.MODULE_SOURCE_PATH)) {
             if (!options.isSet(Option.PROC, "only")
                     && !fm.hasLocation(StandardLocation.CLASS_OUTPUT)) {
                 log.error(Errors.NoOutputDir);

@@ -606,11 +608,11 @@
         }
 
         if (obsoleteOptionFound)
             log.warning(LintCategory.OPTIONS, "option.obsolete.suppression");
 
-        String addExports = options.get(Option.XADDEXPORTS);
+        String addExports = options.get(Option.ADD_EXPORTS);
         if (addExports != null) {
             // Each entry must be of the form module/package=target-list where target-list is a
             // comma-separated list of module or ALL-UNNAMED.
             // All module/package pairs must be unique.
             Pattern p = Pattern.compile("([^/]+)/([^=]+)=(.*)");

@@ -634,11 +636,11 @@
                     // TODO: consider adding diag fragments for the entries
                 }
             });
         }
 
-        String addReads = options.get(Option.XADDREADS);
+        String addReads = options.get(Option.ADD_READS);
         if (addReads != null) {
             // Each entry must be of the form module=source-list where source-list is a
             // comma separated list of module or ALL-UNNAMED.
             // All target modules (i.e. on left of '=')  must be unique.
             Pattern p = Pattern.compile("([^=]+)=(.*)");

@@ -722,29 +724,28 @@
             doclintOpts.add(DocLint.XMSGS_OPTION);
         if (xdoclintCustom != null) {
             for (String s: xdoclintCustom.split("\\s+")) {
                 if (s.isEmpty())
                     continue;
-                doclintOpts.add(s.replace(Option.XDOCLINT_CUSTOM.text, DocLint.XMSGS_CUSTOM_PREFIX));
+                doclintOpts.add(DocLint.XMSGS_CUSTOM_PREFIX + s);
             }
         }
 
         if (doclintOpts.equals(Collections.singleton(DocLint.XMSGS_CUSTOM_PREFIX + "none")))
             return List.nil();
 
         String checkPackages = options.get(Option.XDOCLINT_PACKAGE);
 
         if (checkPackages != null) {
             for (String s : checkPackages.split("\\s+")) {
-                doclintOpts.add(s.replace(Option.XDOCLINT_PACKAGE.text, DocLint.XCHECK_PACKAGE));
+                doclintOpts.add(DocLint.XCHECK_PACKAGE + s);
             }
         }
 
         // standard doclet normally generates H1, H2,
         // so for now, allow user comments to assume that
         doclintOpts.add(DocLint.XIMPLICIT_HEADERS + "2");
-
         return List.from(doclintOpts.toArray(new String[doclintOpts.size()]));
     }
 
     private boolean checkDirectory(Option option) {
         String value = options.get(option);

@@ -769,10 +770,26 @@
                   .filter(options :: isSet)
                   .forEach(r :: report);
         }
     }
 
+    void error(JCDiagnostic.Error error) {
+        errors = true;
+        switch (errorMode) {
+            case ILLEGAL_ARGUMENT: {
+                String msg = log.localize(error);
+                throw new PropagatedException(new IllegalArgumentException(msg));
+            }
+            case ILLEGAL_STATE: {
+                String msg = log.localize(error);
+                throw new PropagatedException(new IllegalStateException(msg));
+            }
+            case LOG:
+                report(error);
+        }
+    }
+
     void error(String key, Object... args) {
         errors = true;
         switch (errorMode) {
             case ILLEGAL_ARGUMENT: {
                 String msg = log.localize(PrefixKind.JAVAC, key, args);

@@ -782,11 +799,10 @@
                 String msg = log.localize(PrefixKind.JAVAC, key, args);
                 throw new PropagatedException(new IllegalStateException(msg));
             }
             case LOG:
                 report(key, args);
-                log.printLines(PrefixKind.JAVAC, "msg.usage", ownName);
         }
     }
 
     void warning(String key, Object... args) {
         report(key, args);

@@ -795,10 +811,15 @@
     private void report(String key, Object... args) {
         // Would be good to have support for -XDrawDiagnostics here
         log.printRawLines(ownName + ": " + log.localize(PrefixKind.JAVAC, key, args));
     }
 
+    private void report(JCDiagnostic.Error error) {
+        // Would be good to have support for -XDrawDiagnostics here
+        log.printRawLines(ownName + ": " + log.localize(error));
+    }
+
     private JavaFileManager getFileManager() {
         if (fileManager == null)
             fileManager = context.get(JavaFileManager.class);
         return fileManager;
     }
< prev index next >