jdk-sandbox: comparison langtools/src/jdk.jshell/share/classes/jdk/internal/jshell/tool/JShellTool.java

equal deleted inserted replaced

-:8bdc63ff6961
+:71874886920f
 */
 public class JShellTool implements MessageHandler {
 private static final String LINE_SEP = System.getProperty("line.separator");
 private static final Pattern LINEBREAK = Pattern.compile("\\R");
-private static final Pattern HISTORY_ALL_START_FILENAME = Pattern.compile(
-"((?<cmd>(-all|-history|-start))(\\z|\\p{javaWhitespace}+))?(?<filename>.*)");
 private static final String RECORD_SEPARATOR = "\u241E";
 private static final String RB_NAME_PREFIX  = "jdk.internal.jshell.tool.resources";
 private static final String VERSION_RB_NAME = RB_NAME_PREFIX + ".version";
 private static final String L10N_RB_NAME    = RB_NAME_PREFIX + ".l10n";
 start(in, loadList);
 }
 }
 private void start(IOContext in, List<String> loadList) {
+// If startup hasn't been set by command line, set from retained/default
+if (startup == null) {
+startup = prefs.get(STARTUP_KEY, null);
+if (startup == null) {
+startup = DEFAULT_STARTUP;
+}
+}
 // Read retained editor setting (if any)
-String editorString = prefs.get(EDITOR_KEY, null);
+String editorString = prefs.get(EDITOR_KEY, "");
-if (editorString != null) {
+if (editorString == null || editorString.isEmpty()) {
+editor = null;
+} else {
 editor = editorString.split(RECORD_SEPARATOR);
 }
 resetState(); // Initialize
 if (cmdlineClasspath != null) {
 state.addToClasspath(cmdlineClasspath);
 }
-String start;
+startUpRun(startup);
-if (startup == null) {
-start = startup = prefs.get(STARTUP_KEY, null);
-if (start == null) {
-start = DEFAULT_STARTUP;
-}
-} else {
-start = startup;
-}
-startUpRun(start);
 currentNameSpace = mainNamespace;
 }
 //where -- one-time per run initialization of feedback modes
 private void initFeedback() {
 // No fluff, no prefix, for init failures
 MessageHandler initmh = new InitMessageHandler();
 // Execute the feedback initialization code in the resource file
 startUpRun(getResourceString("startup.feedback"));
 // These predefined modes are read-only
 feedback.markModesReadOnly();
 // Restore user defined modes retained on previous run with /retain mode
 String encoded = prefs.get(MODE_KEY, null);
-if (encoded != null) {
+if (encoded != null && !encoded.isEmpty()) {
-feedback.restoreEncodedModes(initmh, encoded);
+if (!feedback.restoreEncodedModes(initmh, encoded)) {
+// Catastrophic corruption -- remove the retained modes
+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);
 if (fb != null) {
 // Restore the feedback mode to use that was retained
 // on a previous run with /retain feedback
-feedback.setFeedback(initmh, new ArgTokenizer("/retain feedback ", fb));
+feedback.retainFeedback(initmh, new ArgTokenizer("/retain feedback", fb));
 }
 }
 }
 //where
 private void startUpRun(String start) {
 try (IOContext suin = new FileScannerIOContext(new StringReader(start))) {
 run(suin);
 } catch (Exception ex) {
 hardmsg("jshell.err.startup.unexpected.exception", ex);
+ex.printStackTrace(cmdout);
 }
 }
 private void closeState() {
 live = false;
 List<Snippet> allSnippets() {
 return state.snippets();
 }
-List<Snippet> dropableSnippets() {
+List<PersistentSnippet> dropableSnippets() {
 return state.snippets().stream()
-.filter(sn -> state.status(sn).isActive)
+.filter(sn -> state.status(sn).isActive && sn instanceof PersistentSnippet)
+.map(sn -> (PersistentSnippet) sn)
 .collect(toList());
 }
 List<VarSnippet> allVarSnippets() {
 return state.snippets().stream()
 }
 // --- Command implementations ---
 private static final String[] SET_SUBCOMMANDS = new String[]{
-"format", "truncation", "feedback", "newmode", "prompt", "editor", "start"};
+"format", "truncation", "feedback", "mode", "prompt", "editor", "start"};
 private static final String[] RETAIN_SUBCOMMANDS = new String[]{
 "feedback", "mode", "editor", "start"};
 final boolean cmdSet(String arg) {
 String cmd = "/set";
-ArgTokenizer at = new ArgTokenizer(cmd +" ", arg.trim());
+ArgTokenizer at = new ArgTokenizer(cmd, arg.trim());
 String which = subCommand(cmd, at, SET_SUBCOMMANDS);
 if (which == null) {
 return false;
 }
 switch (which) {
 return feedback.setFormat(this, at);
 case "truncation":
 return feedback.setTruncation(this, at);
 case "feedback":
 return feedback.setFeedback(this, at);
-case "newmode":
+case "mode":
-return feedback.setNewMode(this, at);
+return feedback.setMode(this, at);
 case "prompt":
 return feedback.setPrompt(this, at);
-case "editor": {
+case "editor":
-String prog = at.next();
+return setEditor(at, true);
-if (prog == null) {
+case "start":
-errormsg("jshell.err.set.editor.arg");
+return setStart(cmd, at, true);
-return false;
-} else {
-return setEditor(cmd, prog, at);
-}
-}
-case "start": {
-return setStart(cmd, at.next());
-}
 default:
 errormsg("jshell.err.arg", cmd, at.val());
 return false;
 }
 }
 final boolean cmdRetain(String arg) {
 String cmd = "/retain";
-ArgTokenizer at = new ArgTokenizer(cmd +" ", arg.trim());
+ArgTokenizer at = new ArgTokenizer(cmd, arg.trim());
 String which = subCommand(cmd, at, RETAIN_SUBCOMMANDS);
 if (which == null) {
 return false;
 }
 switch (which) {
 // Retain this mode and all previously retained modes
 prefs.put(MODE_KEY, retained);
 return true;
 }
 return false;
-case "editor": {
+case "editor":
-String prog = at.next();
+if (!setEditor(at, false)) {
-if (prog != null) {
+return false;
-// If the editor is specified, first run /set editor ...
+}
-if(!setEditor(cmd, prog, at)) {
+// retain editor setting
-return false;
+prefs.put(EDITOR_KEY, (editor == null)
-}
+? ""
-}
+: String.join(RECORD_SEPARATOR, editor));
-if (editor != null) {
+return true;
-// If an editor has been set now, or in the past, retain it
-prefs.put(EDITOR_KEY, String.join(RECORD_SEPARATOR, editor));
-return true;
-}
-return false;
-}
 case "start": {
-String fn = at.next();
+if (!setStart(cmd, at, false)) {
-if (fn != null) {
+return false;
-if (!setStart(cmd, fn)) {
+}
-return false;
+// retain startup setting
-}
+prefs.put(STARTUP_KEY, startup);
-}
+return true;
-if (startup != null) {
-prefs.put(STARTUP_KEY, startup);
-return true;
-}
-return false;
 }
 default:
 errormsg("jshell.err.arg", cmd, at.val());
 return false;
 }
 }
 return matches[0];
 }
 // The sub-command:  /set editor <editor-command-line>>
-boolean setEditor(String cmd, String prog, ArgTokenizer at) {
+boolean setEditor(ArgTokenizer at, boolean argsRequired) {
+at.allowedOptions("-default");
+String prog = at.next();
 List<String> ed = new ArrayList<>();
-ed.add(prog);
+while (at.val() != null) {
-String n;
+ed.add(at.val());
-while ((n = at.next()) != null) {
+at.nextToken();
-ed.add(n);
+}
-}
+if (!checkOptionsAndRemainingInput(at)) {
-editor = ed.toArray(new String[ed.size()]);
+return false;
-fluffmsg("jshell.msg.set.editor.set", prog);
+}
+boolean defaultOption = at.hasOption("-default");
+if (prog != null) {
+if (defaultOption) {
+errormsg("jshell.err.default.option.or.program", at.whole());
+return false;
+}
+editor = ed.toArray(new String[ed.size()]);
+fluffmsg("jshell.msg.set.editor.set", prog);
+} else if (defaultOption) {
+editor = null;
+} else if (argsRequired) {
+errormsg("jshell.err.set.editor.arg");
+return false;
+}
 return true;
 }
 // The sub-command:  /set start <start-file>
-boolean setStart(String cmd, String fn) {
+boolean setStart(String cmd, ArgTokenizer at, boolean argsRequired) {
-String init = readFile(fn, cmd + " start");
+at.allowedOptions("-default", "-none");
-if (init == null) {
+String fn = at.next();
+if (!checkOptionsAndRemainingInput(at)) {
 return false;
-} else {
+}
-startup = init;
+int argCount = at.optionCount() + ((fn != null) ? 1 : 0);
-//prefs.put(STARTUP_KEY, init);
+if (argCount > 1 || argsRequired && argCount == 0) {
-return true;
+errormsg("jshell.err.option.or.filename", at.whole());
-}
+return false;
+}
+if (fn != null) {
+String init = readFile(fn, cmd + " start");
+if (init == null) {
+return false;
+} else {
+startup = init;
+return true;
+}
+} else if (at.hasOption("-default")) {
+startup = DEFAULT_STARTUP;
+} else if (at.hasOption("-none")) {
+startup = "";
+}
+return true;
 }
 boolean cmdClasspath(String arg) {
 if (arg.isEmpty()) {
 errormsg("jshell.err.classpath.arg");
 fluffmsg("jshell.msg.goodbye");
 return true;
 }
 boolean cmdHelp(String arg) {
-ArgTokenizer at = new ArgTokenizer(arg);
+ArgTokenizer at = new ArgTokenizer("/help", arg);
 String subject = at.next();
 if (subject != null) {
 Command[] matches = commands.values().stream()
 .filter(c -> c.command.startsWith(subject))
 .toArray(size -> new Command[size]);
 return sn instanceof DeclarationSnippet
 && ((DeclarationSnippet) sn).name().equals(name);
 }
 /**
-* Convert a user argument to a Stream of snippets referenced by that argument
+* Convert user arguments to a Stream of snippets referenced by those
-* (or lack of argument).
+* arguments (or lack of arguments).
-*
-* @param snippets the base list of possible snippets
-* @param arg the user's argument to the command, maybe be the empty string
-* @param allowAll if true, allow the use of '-all' and '-start'
-* @return a Stream of referenced snippets or null if no matches to specific arg
-*/
-private <T extends Snippet> Stream<T> argToSnippets(List<T> snippets, String arg, boolean allowAll) {
-return argToSnippets(snippets, this::mainActive, arg, allowAll);
-}
-/**
-* Convert a user argument to a Stream of snippets referenced by that argument
-* (or lack of argument).
 *
 * @param snippets the base list of possible snippets
 * @param defFilter the filter to apply to the arguments if no argument
-* @param arg the user's argument to the command, maybe be the empty string
+* @param rawargs the user's argument to the command, maybe be the empty
-* @param allowAll if true, allow the use of '-all' and '-start'
+* string
-* @return a Stream of referenced snippets or null if no matches to specific arg
+* @return a Stream of referenced snippets or null if no matches are found
 */
-private <T extends Snippet> Stream<T> argToSnippets(List<T> snippets,
+private <T extends Snippet> Stream<T> argsOptionsToSnippets(List<T> snippets,
-Predicate<Snippet> defFilter, String arg, boolean allowAll) {
+Predicate<Snippet> defFilter, String rawargs, String cmd) {
-if (allowAll && arg.equals("-all")) {
+ArgTokenizer at = new ArgTokenizer(cmd, rawargs.trim());
+at.allowedOptions("-all", "-start");
+List<String> args = new ArrayList<>();
+String s;
+while ((s = at.next()) != null) {
+args.add(s);
+}
+if (!checkOptionsAndRemainingInput(at)) {
+return null;
+}
+if (at.optionCount() > 0 && args.size() > 0) {
+errormsg("jshell.err.may.not.specify.options.and.snippets", at.whole());
+return null;
+}
+if (at.optionCount() > 1) {
+errormsg("jshell.err.conflicting.options", at.whole());
+return null;
+}
+if (at.hasOption("-all")) {
 // all snippets including start-up, failed, and overwritten
 return snippets.stream();
-} else if (allowAll && arg.equals("-start")) {
+}
+if (at.hasOption("-start")) {
 // start-up snippets
 return snippets.stream()
 .filter(this::inStartUp);
-} else if (arg.isEmpty()) {
+}
+if (args.isEmpty()) {
 // Default is all active user snippets
 return snippets.stream()
 .filter(defFilter);
-} else {
+}
-Stream<T> result =
+return argsToSnippets(snippets, args);
-nonEmptyStream(
+}
-() -> snippets.stream(),
-// look for active user declarations matching the name
+/**
-sn -> isActive(sn) && matchingDeclaration(sn, arg),
+* Convert user arguments to a Stream of snippets referenced by those
-// else, look for any declarations matching the name
+* arguments.
-sn -> matchingDeclaration(sn, arg),
-// else, look for an id of this name
-sn -> sn.id().equals(arg)
-);
-return result;
-}
-}
-/**
-* Convert a user argument to a Stream of snippets referenced by that
-* argument, printing an informative message if no matches. Allow '-all' and
-* '-start'.
 *
 * @param snippets the base list of possible snippets
-* @param defFilter the filter to apply to the arguments if no argument
+* @param args the user's argument to the command, maybe be the empty list
-* @param arg the user's argument to the command, maybe be the empty string
-* @param cmd the name of the command (for use in a help message
 * @return a Stream of referenced snippets or null if no matches to specific
 * arg
 */
-private <T extends Snippet> Stream<T> argToSnippetsWithMessage(List<T> snippets,
+private <T extends Snippet> Stream<T> argsToSnippets(List<T> snippets,
-Predicate<Snippet> defFilter, String arg, String cmd) {
+List<String> args) {
-Stream<T> stream = argToSnippets(snippets, defFilter, arg, true);
+Stream<T> result = null;
-if (stream == null) {
+for (String arg : args) {
-errormsg("jshell.err.def.or.id.not.found", arg);
+// Find the best match
-// Check if there are any definitions at all
+Stream<T> st = layeredSnippetSearch(snippets, arg);
-if (argToSnippets(snippets, "", false).iterator().hasNext()) {
+if (st == null) {
-fluffmsg("jshell.msg.try.command.without.args", cmd);
+Stream<Snippet> est = layeredSnippetSearch(state.snippets(), arg);
+if (est == null) {
+errormsg("jshell.err.no.such.snippets", arg);
+} else {
+errormsg("jshell.err.the.snippet.cannot.be.used.with.this.command",
+arg, est.findFirst().get().source());
+}
+return null;
+}
+if (result == null) {
+result = st;
 } else {
-hardmsg("jshell.msg.no.active");
+result = Stream.concat(result, st);
 }
 }
-return stream;
+return result;
 }
-private boolean cmdDrop(String arg) {
+private <T extends Snippet> Stream<T> layeredSnippetSearch(List<T> snippets, String arg) {
-if (arg.isEmpty()) {
+return nonEmptyStream(
+// the stream supplier
+() -> snippets.stream(),
+// look for active user declarations matching the name
+sn -> isActive(sn) && matchingDeclaration(sn, arg),
+// else, look for any declarations matching the name
+sn -> matchingDeclaration(sn, arg),
+// else, look for an id of this name
+sn -> sn.id().equals(arg)
+);
+}
+private boolean cmdDrop(String rawargs) {
+ArgTokenizer at = new ArgTokenizer("/drop", rawargs.trim());
+at.allowedOptions();
+List<String> args = new ArrayList<>();
+String s;
+while ((s = at.next()) != null) {
+args.add(s);
+}
+if (!checkOptionsAndRemainingInput(at)) {
+return false;
+}
+if (args.isEmpty()) {
 errormsg("jshell.err.drop.arg");
 return false;
 }
-Stream<Snippet> stream = argToSnippets(dropableSnippets(), arg, false);
+Stream<PersistentSnippet> stream = argsToSnippets(dropableSnippets(), args);
 if (stream == null) {
-errormsg("jshell.err.def.or.id.not.found", arg);
+// Snippet not found. Error already printed
 fluffmsg("jshell.msg.see.classes.etc");
 return false;
 }
-List<Snippet> snippets = stream
+List<PersistentSnippet> snippets = stream.collect(toList());
-.filter(sn -> state.status(sn).isActive && sn instanceof PersistentSnippet)
+if (snippets.size() > args.size()) {
-.collect(toList());
+// One of the args references more thean one snippet
-if (snippets.isEmpty()) {
-errormsg("jshell.err.drop.not.active");
-return false;
-}
-if (snippets.size() > 1) {
 errormsg("jshell.err.drop.ambiguous");
 fluffmsg("jshell.msg.use.one.of", snippets.stream()
-.map(sn -> String.format("\n%4s : %s", sn.id(), sn.source().replace("\n", "\n       ")))
+.map(sn -> String.format("\n/drop %-5s :   %s", sn.id(), sn.source().replace("\n", "\n       ")))
 .collect(Collectors.joining(", "))
 );
 return false;
 }
-PersistentSnippet psn = (PersistentSnippet) snippets.get(0);
+snippets.stream()
-state.drop(psn).forEach(this::handleEvent);
+.forEach(sn -> state.drop(sn).forEach(this::handleEvent));
 return true;
 }
 private boolean cmdEdit(String arg) {
-Stream<Snippet> stream = argToSnippetsWithMessage(state.snippets(),
+Stream<Snippet> stream = argsOptionsToSnippets(state.snippets(),
 this::mainActive, arg, "/edit");
 if (stream == null) {
 return false;
 }
 Set<String> srcSet = new LinkedHashSet<>();
 return s.substring(b, e + 1);
 }
 }
 private boolean cmdList(String arg) {
-if (arg.equals("-history")) {
+if (arg.length() >= 2 && "-history".startsWith(arg)) {
 return cmdHistory();
 }
-Stream<Snippet> stream = argToSnippetsWithMessage(state.snippets(),
+Stream<Snippet> stream = argsOptionsToSnippets(state.snippets(),
 this::mainActive, arg, "/list");
 if (stream == null) {
 return false;
 }
 live = false;
 fluffmsg("jshell.msg.resetting.state");
 return true;
 }
-private boolean cmdReload(String arg) {
+private boolean cmdReload(String rawargs) {
-Iterable<String> history = replayableHistory;
+ArgTokenizer at = new ArgTokenizer("/reload", rawargs.trim());
-boolean echo = true;
+at.allowedOptions("-restore", "-quiet");
-if (arg.length() > 0) {
+if (!checkOptionsAndRemainingInput(at)) {
-if ("-restore".startsWith(arg)) {
+return false;
-if (replayableHistoryPrevious == null) {
+}
-errormsg("jshell.err.reload.no.previous");
+Iterable<String> history;
-return false;
+if (at.hasOption("-restore")) {
-}
+if (replayableHistoryPrevious == null) {
-history = replayableHistoryPrevious;
+errormsg("jshell.err.reload.no.previous");
-} else if ("-quiet".startsWith(arg)) {
-echo = false;
-} else {
-errormsg("jshell.err.arg", "/reload", arg);
 return false;
 }
-}
+history = replayableHistoryPrevious;
-fluffmsg(history == replayableHistoryPrevious
+fluffmsg("jshell.err.reload.restarting.previous.state");
-? "jshell.err.reload.restarting.previous.state"
+} else {
-: "jshell.err.reload.restarting.state");
+history = replayableHistory;
+fluffmsg("jshell.err.reload.restarting.state");
+}
+boolean echo = !at.hasOption("-quiet");
 resetState();
 run(new ReloadIOContext(history,
-echo? cmdout : null));
+echo ? cmdout : null));
 return true;
 }
-private boolean cmdSave(String arg_filename) {
+private boolean cmdSave(String rawargs) {
-Matcher mat = HISTORY_ALL_START_FILENAME.matcher(arg_filename);
+ArgTokenizer at = new ArgTokenizer("/save", rawargs.trim());
-if (!mat.find()) {
+at.allowedOptions("-all", "-start", "-history");
-errormsg("jshell.err.arg", arg_filename);
+String filename = at.next();
+if (filename == null) {
+errormsg("jshell.err.file.filename", "/save");
 return false;
 }
-boolean useHistory = false;
+if (!checkOptionsAndRemainingInput(at)) {
-String saveAll = "";
+return false;
-boolean saveStart = false;
+}
-String cmd = mat.group("cmd");
+if (at.optionCount() > 1) {
-if (cmd != null) switch (cmd) {
+errormsg("jshell.err.conflicting.options", at.whole());
-case "-all":
-saveAll = "-all";
-break;
-case "-history":
-useHistory = true;
-break;
-case "-start":
-saveStart = true;
-break;
-}
-String filename = mat.group("filename");
-if (filename == null ||filename.isEmpty()) {
-errormsg("jshell.err.file.filename", "/save");
 return false;
 }
 try (BufferedWriter writer = Files.newBufferedWriter(toPathResolvingUserHome(filename),
 Charset.defaultCharset(),
 CREATE, TRUNCATE_EXISTING, WRITE)) {
-if (useHistory) {
+if (at.hasOption("-history")) {
 for (String s : input.currentSessionHistory()) {
 writer.write(s);
 writer.write("\n");
 }
-} else if (saveStart) {
+} else if (at.hasOption("-start")) {
-writer.append(DEFAULT_STARTUP);
+writer.append(startup);
 } else {
-Stream<Snippet> stream = argToSnippets(state.snippets(), saveAll, true);
+List<Snippet> sns = at.hasOption("-all")
-if (stream != null) {
+? state.snippets()
-for (Snippet sn : stream.collect(toList())) {
+: state.snippets().stream().filter(this::mainActive).collect(toList());
-writer.write(sn.source());
+for (Snippet sn : sns) {
-writer.write("\n");
+writer.write(sn.source());
-}
+writer.write("\n");
 }
 }
 } catch (FileNotFoundException e) {
 errormsg("jshell.err.file.not.found", "/save", filename, e.getMessage());
 return false;
 }
 return true;
 }
 private boolean cmdVars(String arg) {
-Stream<VarSnippet> stream = argToSnippetsWithMessage(allVarSnippets(),
+Stream<VarSnippet> stream = argsOptionsToSnippets(allVarSnippets(),
 this::isActive, arg, "/vars");
 if (stream == null) {
 return false;
 }
 stream.forEachOrdered(vk ->
 });
 return true;
 }
 private boolean cmdMethods(String arg) {
-Stream<MethodSnippet> stream = argToSnippetsWithMessage(allMethodSnippets(),
+Stream<MethodSnippet> stream = argsOptionsToSnippets(allMethodSnippets(),
 this::isActive, arg, "/methods");
 if (stream == null) {
 return false;
 }
 stream.forEachOrdered(mk
 );
 return true;
 }
 private boolean cmdTypes(String arg) {
-Stream<TypeDeclSnippet> stream = argToSnippetsWithMessage(allTypeSnippets(),
+Stream<TypeDeclSnippet> stream = argsOptionsToSnippets(allTypeSnippets(),
 this::isActive, arg, "/types");
 if (stream == null) {
 return false;
 }
 stream.forEachOrdered(ck
 if (index >= 0 && index < keys.size()) {
 rerunSnippet(keys.get(index));
 } else {
 errormsg("jshell.err.out.of.range");
 return false;
+}
+return true;
+}
+boolean checkOptionsAndRemainingInput(ArgTokenizer at) {
+String junk = at.remainder();
+if (!junk.isEmpty()) {
+errormsg("jshell.err.unexpected.at.end", junk, at.whole());
+return false;
+} else {
+String bad = at.badOptions();
+if (!bad.isEmpty()) {
+errormsg("jshell.err.unknown.option", bad, at.whole());
+return false;
+}
 }
 return true;
 }
 private boolean rerunHistoryEntryById(String id) {

changeset 38539	71874886920f
parent 38535	4a25025e0b0d
child 38613	2a8e50869b08