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

equal deleted inserted replaced

-:3f9c491b05aa
+:cb3d04878117
 SourceCodeAnalysis analysis;
 JShell state = null;
 Subscription shutdownSubscription = null;
+static final EditorSetting BUILT_IN_EDITOR = new EditorSetting(null, false);
 private boolean debug = false;
 public boolean testPrompt = false;
 private String cmdlineClasspath = null;
 private String startup = null;
-private String[] editor = null;
+private EditorSetting editor = BUILT_IN_EDITOR;
-private boolean editorWait = false;
 // Commands and snippets which should be replayed
 private List<String> replayableHistory;
 private List<String> replayableHistoryPrevious;
 * Must show command output
 *
 * @param format printf format
 * @param args printf args
 */
-void hard(String format, Object... args) {
+@Override
+public void hard(String format, Object... args) {
 rawout(feedback.getPre() + format + feedback.getPost(), args);
 }
 /**
 * Error command output
 void error(String format, Object... args) {
 rawout(feedback.getErrorPre() + format + feedback.getErrorPost(), args);
 }
 /**
+* Should optional informative be displayed?
+* @return true if they should be displayed
+*/
+@Override
+public boolean showFluff() {
+return feedback.shouldDisplayCommandFluff() && interactive();
+}
+/**
 * Optional output
 *
 * @param format printf format
 * @param args printf args
 */
 @Override
 public void fluff(String format, Object... args) {
-if (feedback.shouldDisplayCommandFluff() && interactive()) {
+if (showFluff()) {
 hard(format, args);
 }
 }
 /**
 *
 * @param format printf format
 * @param args printf args
 */
 void fluffRaw(String format, Object... args) {
-if (feedback.shouldDisplayCommandFluff() && interactive()) {
+if (showFluff()) {
 rawout(format, args);
 }
 }
 /**
 * postfix
 *
 * @param key the resource key
 * @param args
 */
-void hardmsg(String key, Object... args) {
+@Override
+public void hardmsg(String key, Object... args) {
 cmdout.println(prefix(messageFormat(key, args)));
 }
 /**
 * Print error using resource bundle look-up, MessageFormat, and add prefix
 * @param key the resource key
 * @param args
 */
 @Override
 public void fluffmsg(String key, Object... args) {
-if (feedback.shouldDisplayCommandFluff() && interactive()) {
+if (showFluff()) {
 hardmsg(key, args);
 }
 }
 <T> void hardPairs(Stream<T> stream, Function<T, String> a, Function<T, String> b) {
 startup = DEFAULT_STARTUP;
 }
 }
 // Read retained editor setting (if any)
-String editorString = prefs.get(EDITOR_KEY, "");
+editor = EditorSetting.fromPrefs(prefs);
-if (editorString == null || editorString.isEmpty()) {
+if (editor == null) {
-editor = null;
+editor = BUILT_IN_EDITOR;
-} else {
-char waitMarker = editorString.charAt(0);
-if (waitMarker == '-' || waitMarker == '*') {
-editorWait = waitMarker == '-';
-editorString = editorString.substring(1);
-}
-editor = editorString.split(RECORD_SEPARATOR);
 }
 resetState(); // Initialize
 // Read replay history from last jshell session into previous history
 public void fluffmsg(String messageKey, Object... args) {
 //ignore
 }
 @Override
+public void hard(String format, Object... args) {
+//ignore
+}
+@Override
+public void hardmsg(String messageKey, Object... args) {
+//ignore
+}
+@Override
 public void errormsg(String messageKey, Object... args) {
 startmsg(messageKey, args);
+}
+@Override
+public boolean showFluff() {
+return false;
 }
 }
 private void resetState() {
 closeState();
 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
+// Restore user defined modes retained on previous run with /set mode -retain
 String encoded = prefs.get(MODE_KEY, null);
 if (encoded != null && !encoded.isEmpty()) {
 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 (!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
+// on a previous run with /set feedback -retain
-feedback.retainFeedback(initmh, new ArgTokenizer("/retain feedback", fb));
+setFeedback(initmh, new ArgTokenizer("previous retain feedback", "-retain " + fb));
 }
 }
 }
 //where
 SET_MODE_OPTIONS_COMPLETION_PROVIDER)),
 "prompt", feedback.modeCompletions(),
 "editor", fileCompletions(Files::isExecutable),
 "start", FILE_COMPLETION_PROVIDER),
 STARTSWITH_MATCHER)));
-registerCommand(new Command("/retain",
-arg -> cmdRetain(arg),
-new ContinuousCompletionProvider(Map.of(
-"feedback", feedback.modeCompletions(),
-"mode", feedback.modeCompletions(),
-"editor", fileCompletions(Files::isExecutable),
-"start", FILE_COMPLETION_PROVIDER),
-STARTSWITH_MATCHER)));
 registerCommand(new Command("/?",
 "help.quest",
 arg -> cmdHelp(arg),
 EMPTY_COMPLETION_PROVIDER,
 CommandKind.NORMAL));
 // --- Command implementations ---
 private static final String[] SET_SUBCOMMANDS = new String[]{
 "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());
 String which = subCommand(cmd, at, SET_SUBCOMMANDS);
 if (which == null) {
 return false;
 }
 switch (which) {
+case "_retain": {
+errormsg("jshell.err.setting.to.retain.must.be.specified", at.whole());
+return false;
+}
+case "_blank": {
+// show top-level settings
+new SetEditor().set();
+showSetStart();
+setFeedback(this, at); // no args so shows feedback setting
+hardmsg("jshell.msg.set.show.mode.settings");
+return true;
+}
 case "format":
 return feedback.setFormat(this, at);
 case "truncation":
 return feedback.setTruncation(this, at);
 case "feedback":
-return feedback.setFeedback(this, at);
+return setFeedback(this, at);
 case "mode":
-return feedback.setMode(this, at);
+return feedback.setMode(this, at,
+retained -> prefs.put(MODE_KEY, retained));
 case "prompt":
 return feedback.setPrompt(this, at);
 case "editor":
-return setEditor(at, true);
+return new SetEditor(at).set();
 case "start":
-return setStart(cmd, at, true);
+return setStart(at);
 default:
 errormsg("jshell.err.arg", cmd, at.val());
 return false;
 }
 }
-final boolean cmdRetain(String arg) {
+boolean setFeedback(MessageHandler messageHandler, ArgTokenizer at) {
-String cmd = "/retain";
+return feedback.setFeedback(messageHandler, at,
-ArgTokenizer at = new ArgTokenizer(cmd, arg.trim());
+fb -> prefs.put(FEEDBACK_KEY, fb));
-String which = subCommand(cmd, at, RETAIN_SUBCOMMANDS);
+}
-if (which == null) {
-return false;
+// Find which, if any, sub-command matches.
-}
+// Return null on error
-switch (which) {
-case "feedback": {
-String fb = feedback.retainFeedback(this, at);
-if (fb != null) {
-// If a feedback mode has been set now, or in the past, retain it
-prefs.put(FEEDBACK_KEY, fb);
-return true;
-}
-return false;
-}
-case "mode":
-String retained = feedback.retainMode(this, at);
-if (retained != null) {
-// Retain this mode and all previously retained modes
-prefs.put(MODE_KEY, retained);
-return true;
-}
-return false;
-case "editor":
-if (!setEditor(at, false)) {
-return false;
-}
-// retain editor setting
-prefs.put(EDITOR_KEY, (editor == null)
-? ""
-: (editorWait? "-" : "*") + String.join(RECORD_SEPARATOR, editor));
-return true;
-case "start": {
-if (!setStart(cmd, at, false)) {
-return false;
-}
-// retain startup setting
-prefs.put(STARTUP_KEY, startup);
-return true;
-}
-default:
-errormsg("jshell.err.arg", cmd, at.val());
-return false;
-}
-}
-// Print the help doc for the specified sub-command
-boolean printSubCommandHelp(String cmd, ArgTokenizer at, String helpPrefix, String[] subs) {
-String which = subCommand(cmd, at, subs);
-if (which == null) {
-return false;
-}
-hardrb(helpPrefix + which);
-return true;
-}
-// Find which, if any, sub-command matches
 String subCommand(String cmd, ArgTokenizer at, String[] subs) {
-String[] matches = at.next(subs);
+at.allowedOptions("-retain");
-if (matches == null) {
+String sub = at.next();
+if (sub == null) {
 // No sub-command was given
-errormsg("jshell.err.sub.arg", cmd);
+return at.hasOption("-retain")
-return null;
+? "_retain"
-}
+: "_blank";
+}
+String[] matches = Arrays.stream(subs)
+.filter(s -> s.startsWith(sub))
+.toArray(size -> new String[size]);
 if (matches.length == 0) {
 // There are no matching sub-commands
-errormsg("jshell.err.arg", cmd, at.val());
+errormsg("jshell.err.arg", cmd, sub);
 fluffmsg("jshell.msg.use.one.of", Arrays.stream(subs)
 .collect(Collectors.joining(", "))
 );
 return null;
 }
 if (matches.length > 1) {
 // More than one sub-command matches the initial characters provided
-errormsg("jshell.err.sub.ambiguous", cmd, at.val());
+errormsg("jshell.err.sub.ambiguous", cmd, sub);
 fluffmsg("jshell.msg.use.one.of", Arrays.stream(matches)
 .collect(Collectors.joining(", "))
 );
 return null;
 }
 return matches[0];
 }
-// The sub-command:  /set editor <editor-command-line>>
+static class EditorSetting {
-boolean setEditor(ArgTokenizer at, boolean argsRequired) {
-at.allowedOptions("-default", "-wait");
+static String BUILT_IN_REP = "-default";
-String prog = at.next();
+static char WAIT_PREFIX = '-';
-List<String> ed = new ArrayList<>();
+static char NORMAL_PREFIX = '*';
-while (at.val() != null) {
-ed.add(at.val());
+final String[] cmd;
-at.nextToken();
+final boolean wait;
-}
-if (!checkOptionsAndRemainingInput(at)) {
+EditorSetting(String[] cmd, boolean wait) {
-return false;
+this.wait = wait;
-}
+this.cmd = cmd;
-boolean defaultOption = at.hasOption("-default");
+}
-boolean waitOption = at.hasOption("-wait");
-if (prog != null) {
+// returns null if not stored in preferences
-if (defaultOption) {
+static EditorSetting fromPrefs(Preferences prefs) {
+// Read retained editor setting (if any)
+String editorString = prefs.get(EDITOR_KEY, "");
+if (editorString == null || editorString.isEmpty()) {
+return null;
+} else if (editorString.equals(BUILT_IN_REP)) {
+return BUILT_IN_EDITOR;
+} else {
+boolean wait = false;
+char waitMarker = editorString.charAt(0);
+if (waitMarker == WAIT_PREFIX || waitMarker == NORMAL_PREFIX) {
+wait = waitMarker == WAIT_PREFIX;
+editorString = editorString.substring(1);
+}
+String[] cmd = editorString.split(RECORD_SEPARATOR);
+return new EditorSetting(cmd, wait);
+}
+}
+void toPrefs(Preferences prefs) {
+prefs.put(EDITOR_KEY, (this == BUILT_IN_EDITOR)
+? BUILT_IN_REP
+: (wait ? WAIT_PREFIX : NORMAL_PREFIX) + String.join(RECORD_SEPARATOR, cmd));
+}
+@Override
+public boolean equals(Object o) {
+if (o instanceof EditorSetting) {
+EditorSetting ed = (EditorSetting) o;
+return Arrays.equals(cmd, ed.cmd) && wait == ed.wait;
+} else {
+return false;
+}
+}
+@Override
+public int hashCode() {
+int hash = 7;
+hash = 71 * hash + Arrays.deepHashCode(this.cmd);
+hash = 71 * hash + (this.wait ? 1 : 0);
+return hash;
+}
+}
+class SetEditor {
+private final ArgTokenizer at;
+private final String[] command;
+private final boolean hasCommand;
+private final boolean defaultOption;
+private final boolean waitOption;
+private final boolean retainOption;
+SetEditor(ArgTokenizer at) {
+at.allowedOptions("-default", "-wait", "-retain");
+String prog = at.next();
+List<String> ed = new ArrayList<>();
+while (at.val() != null) {
+ed.add(at.val());
+at.nextToken();  // so that options are not interpreted as jshell options
+}
+this.at = at;
+this.command = ed.toArray(new String[ed.size()]);
+this.hasCommand = command.length > 0;
+this.defaultOption = at.hasOption("-default");
+this.waitOption = at.hasOption("-wait");
+this.retainOption = at.hasOption("-retain");
+}
+SetEditor() {
+this(new ArgTokenizer("", ""));
+}
+boolean set() {
+if (!check()) {
+return false;
+}
+if (!hasCommand && !defaultOption && !retainOption) {
+// No settings or -retain, so this is a query
+EditorSetting retained = EditorSetting.fromPrefs(prefs);
+if (retained != null) {
+// retained editor is set
+hard("/set editor -retain %s", format(retained));
+}
+if (retained == null || !retained.equals(editor)) {
+// editor is not retained or retained is different from set
+hard("/set editor %s", format(editor));
+}
+return true;
+}
+install();
+if (retainOption) {
+editor.toPrefs(prefs);
+fluffmsg("jshell.msg.set.editor.retain", format(editor));
+}
+return true;
+}
+private boolean check() {
+if (!checkOptionsAndRemainingInput(at)) {
+return false;
+}
+if (hasCommand && defaultOption) {
 errormsg("jshell.err.default.option.or.program", at.whole());
 return false;
 }
-editor = ed.toArray(new String[ed.size()]);
+if (waitOption && !hasCommand) {
-editorWait = waitOption;
-fluffmsg("jshell.msg.set.editor.set", prog);
-} else if (defaultOption) {
-if (waitOption) {
 errormsg("jshell.err.wait.applies.to.external.editor", at.whole());
 return false;
 }
-editor = null;
+return true;
-} else if (argsRequired) {
+}
-errormsg("jshell.err.set.editor.arg");
-return false;
+private void install() {
-}
+if (hasCommand) {
-return true;
+editor = new EditorSetting(command, waitOption);
+} else if (defaultOption) {
+editor = BUILT_IN_EDITOR;
+} else {
+return;
+}
+fluffmsg("jshell.msg.set.editor.set", format(editor));
+}
+private String format(EditorSetting ed) {
+if (ed == BUILT_IN_EDITOR) {
+return "-default";
+} else {
+Stream<String> elems = Arrays.stream(ed.cmd);
+if (ed.wait) {
+elems = Stream.concat(Stream.of("-wait"), elems);
+}
+return elems.collect(joining(" "));
+}
+}
 }
 // The sub-command:  /set start <start-file>
-boolean setStart(String cmd, ArgTokenizer at, boolean argsRequired) {
+boolean setStart(ArgTokenizer at) {
-at.allowedOptions("-default", "-none");
+at.allowedOptions("-default", "-none", "-retain");
 String fn = at.next();
 if (!checkOptionsAndRemainingInput(at)) {
 return false;
 }
-int argCount = at.optionCount() + ((fn != null) ? 1 : 0);
+boolean defaultOption = at.hasOption("-default");
-if (argCount > 1 || argsRequired && argCount == 0) {
+boolean noneOption = at.hasOption("-none");
+boolean retainOption = at.hasOption("-retain");
+boolean hasFile = fn != null;
+int argCount = (defaultOption ? 1 : 0) + (noneOption ? 1 : 0) + (hasFile ? 1 : 0);
+if (argCount > 1) {
 errormsg("jshell.err.option.or.filename", at.whole());
 return false;
 }
-if (fn != null) {
+if (argCount == 0 && !retainOption) {
-String init = readFile(fn, cmd + " start");
+// no options or filename, show current setting
+showSetStart();
+return true;
+}
+if (hasFile) {
+String init = readFile(fn, "/set start");
 if (init == null) {
 return false;
-} else {
+}
 startup = init;
-return true;
+} else if (defaultOption) {
-}
-} else if (at.hasOption("-default")) {
 startup = DEFAULT_STARTUP;
-} else if (at.hasOption("-none")) {
+} else if (noneOption) {
 startup = "";
 }
+if (retainOption) {
+// retain startup setting
+prefs.put(STARTUP_KEY, startup);
+}
 return true;
+}
+void showSetStart() {
+String retained = prefs.get(STARTUP_KEY, null);
+if (retained != null) {
+showSetStart(true, retained);
+}
+if (retained == null || !startup.equals(retained)) {
+showSetStart(false, startup);
+}
+}
+void showSetStart(boolean isRetained, String start) {
+String cmd = "/set start" + (isRetained ? " -retain " : " ");
+String stset;
+if (start.equals(DEFAULT_STARTUP)) {
+stset = cmd + "-default";
+} else if (start.isEmpty()) {
+stset = cmd + "-none";
+} else {
+stset = prefix("startup.jsh:\n" + start + "\n" + cmd + "startup.jsh", "");
+}
+hard(stset);
 }
 boolean cmdClasspath(String arg) {
 if (arg.isEmpty()) {
 errormsg("jshell.err.classpath.arg");
 String subject = at.next();
 if (subject != null) {
 Command[] matches = commands.values().stream()
 .filter(c -> c.command.startsWith(subject))
 .toArray(size -> new Command[size]);
-at.mark();
+if (matches.length == 1) {
-String sub = at.next();
-if (sub != null && matches.length == 1) {
 String cmd = matches[0].command;
-switch (cmd) {
+if (cmd.equals("/set")) {
-case "/set":
+// Print the help doc for the specified sub-command
-at.rewind();
+String which = subCommand(cmd, at, SET_SUBCOMMANDS);
-return printSubCommandHelp(cmd, at, "help.set.", SET_SUBCOMMANDS);
+if (which == null) {
-case "/retain":
+return false;
-at.rewind();
+}
-return printSubCommandHelp(cmd, at, "help.retain.", RETAIN_SUBCOMMANDS);
+if (!which.equals("_blank")) {
+hardrb("help.set." + which);
+return true;
+}
 }
 }
 if (matches.length > 0) {
 for (Command c : matches) {
 hard("");
 sb.append('\n');
 }
 String src = sb.toString();
 Consumer<String> saveHandler = new SaveHandler(src, srcSet);
 Consumer<String> errorHandler = s -> hard("Edit Error: %s", s);
-if (editor == null) {
+if (editor == BUILT_IN_EDITOR) {
 try {
 EditPad.edit(errorHandler, src, saveHandler);
 } catch (RuntimeException ex) {
 errormsg("jshell.err.cant.launch.editor", ex);
 fluffmsg("jshell.msg.try.set.editor");
 return false;
 }
 } else {
-ExternalEditor.edit(editor, errorHandler, src, saveHandler, input,
+ExternalEditor.edit(editor.cmd, errorHandler, src, saveHandler, input,
-editorWait, this::hardrb);
+editor.wait, this::hardrb);
 }
 return true;
 }
 //where
 // receives editor requests to save

changeset 41635	cb3d04878117
parent 41514	a75c2b869d8d
child 41641	a628785b9dd9