src/jdk.jshell/share/classes/jdk/internal/jshell/tool/JShellTool.java

@@ -92,16 +92,20 @@
 import java.util.Optional;
 import java.util.ResourceBundle;
 import java.util.Spliterators;
 import java.util.function.Function;
 import java.util.function.Supplier;
+import jdk.internal.joptsimple.*;
 import jdk.internal.jshell.tool.Feedback.FormatAction;
 import jdk.internal.jshell.tool.Feedback.FormatCase;
 import jdk.internal.jshell.tool.Feedback.FormatErrors;
 import jdk.internal.jshell.tool.Feedback.FormatResolve;
 import jdk.internal.jshell.tool.Feedback.FormatUnresolved;
 import jdk.internal.jshell.tool.Feedback.FormatWhen;
+import static java.util.Arrays.asList;
+import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toList;
 import static jdk.jshell.Snippet.SubKind.VAR_VALUE_SUBKIND;
 import static java.util.stream.Collectors.toMap;
 import static jdk.internal.jshell.debug.InternalDebugControl.DBG_COMPA;
 import static jdk.internal.jshell.debug.InternalDebugControl.DBG_DEP;

@@ -513,86 +517,98 @@
      * Set options.
      * @param args the command line arguments
      * @return the list of files to be loaded
      */
     private List<String> processCommandArgs(String[] args) {
-        List<String> loadList = new ArrayList<>();
-        Iterator<String> ai = Arrays.asList(args).iterator();
-        while (ai.hasNext()) {
-            String arg = ai.next();
-            if (arg.startsWith("-")) {
-                switch (arg) {
-                    case "-classpath":
-                    case "-cp":
-                        if (cmdlineClasspath != null) {
-                            startmsg("jshell.err.opt.classpath.conflict");
-                            return null;
-                        }
-                        if (ai.hasNext()) {
-                            cmdlineClasspath = ai.next();
+        OptionParser parser = new OptionParser();
+        OptionSpec<String> cp = parser.accepts("class-path").withRequiredArg();
+        OptionSpec<String> st = parser.accepts("startup").withRequiredArg();
+        parser.acceptsAll(asList("n", "no-startup"));
+        OptionSpec<String> fb = parser.accepts("feedback").withRequiredArg();
+        parser.accepts("q");
+        parser.accepts("s");
+        parser.accepts("v");
+        OptionSpec<String> r = parser.accepts("R").withRequiredArg();
+        parser.acceptsAll(asList("h", "help"));
+        parser.accepts("version");
+        parser.accepts("full-version");
+        NonOptionArgumentSpec<String> loadFileSpec = parser.nonOptions();
+
+        OptionSet options;
+        try {
+            options = parser.parse(args);
+        } catch (OptionException ex) {
+            if (ex.options().isEmpty()) {
+                startmsg("jshell.err.opt.invalid", stream(args).collect(joining(", ")));
                         } else {
-                            startmsg("jshell.err.opt.classpath.arg");
+                boolean isKnown = parser.recognizedOptions().containsKey(ex.options().iterator().next());
+                startmsg(isKnown
+                        ? "jshell.err.opt.arg"
+                        : "jshell.err.opt.unknown",
+                        ex.options()
+                        .stream()
+                        .collect(joining(", ")));
+            }
                             return null;
                         }
-                        break;
-                    case "-help":
+
+        if (options.has("help")) {
                         printUsage();
                         return null;
-                    case "-version":
+        }
+        if (options.has("version")) {
                         cmdout.printf("jshell %s\n", version());
                         return null;
-                    case "-fullversion":
+        }
+        if (options.has("full-version")) {
                         cmdout.printf("jshell %s\n", fullVersion());
                         return null;
-                    case "-feedback":
-                        if (ai.hasNext()) {
-                            commandLineFeedbackMode = ai.next();
-                        } else {
-                            startmsg("jshell.err.opt.feedback.arg");
+        }
+        if (options.has(cp)) {
+            List<String> cps = options.valuesOf(cp);
+            if (cps.size() > 1) {
+                startmsg("jshell.err.opt.one", "--class-path");
                             return null;
                         }
-                        break;
-                    case "-q":
-                        commandLineFeedbackMode = "concise";
-                        break;
-                    case "-qq":
-                        commandLineFeedbackMode = "silent";
-                        break;
-                    case "-v":
-                        commandLineFeedbackMode = "verbose";
-                        break;
-                    case "-startup":
-                        if (startup != null) {
+            cmdlineClasspath = cps.get(0);
+        }
+        if (options.has(st)) {
+            List<String> sts = options.valuesOf(st);
+            if (sts.size() != 1 || options.has("no-startup")) {
                             startmsg("jshell.err.opt.startup.one");
                             return null;
                         }
-                        startup = readFile(ai.hasNext()? ai.next() : null, "-startup");
+            startup = readFile(sts.get(0), "--startup");
                         if (startup == null) {
                             return null;
                         }
-                        break;
-                    case "-nostartup":
-                        if (startup != null) {
-                            startmsg("jshell.err.opt.startup.one");
-                            return null;
                         }
+        if (options.has("no-startup")) {
                         startup = "";
-                        break;
-                    default:
-                        if (arg.startsWith("-R")) {
-                            remoteVMOptions.add(arg.substring(2));
-                            break;
                         }
-                        startmsg("jshell.err.opt.unknown", arg);
-                        printUsage();
+        if (options.has(fb)) {
+            List<String> fbs = options.valuesOf(fb);
+            if (fbs.size() != 1) {
+                startmsg("jshell.err.opt.one", "--feedback");
                         return null;
                 }
-            } else {
-                loadList.add(arg);
+            commandLineFeedbackMode = fbs.get(0);
             }
+        if (options.has("q")) {
+            commandLineFeedbackMode = "concise";
         }
-        return loadList;
+        if (options.has("s")) {
+            commandLineFeedbackMode = "silent";
+        }
+        if (options.has("v")) {
+            commandLineFeedbackMode = "verbose";
+        }
+        if (options.has(r)) {
+            remoteVMOptions = options.valuesOf(r);
+        }
+
+        return options.valuesOf(loadFileSpec);
     }
 
     private void printUsage() {
         cmdout.print(getResourceString("help.usage"));
     }

@@ -684,11 +700,11 @@
                 prefs.remove(MODE_KEY);
             }
         }
         if (commandLineFeedbackMode != null) {
             // The feedback mode to use was specified on the command line, use it
-            if (!feedback.setFeedback(initmh, new ArgTokenizer("-feedback", commandLineFeedbackMode))) {
+            if (!feedback.setFeedback(initmh, new ArgTokenizer("--feedback", commandLineFeedbackMode))) {
                 regenerateOnDeath = false;
             }
             commandLineFeedbackMode = null;
         } else {
             String fb = prefs.get(FEEDBACK_KEY, null);