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

equal deleted inserted replaced

-:8bdc63ff6961
+:71874886920f
 private static final String TRUNCATION_FIELD = "<truncation>";
 // For encoding to Properties String
 private static final String RECORD_SEPARATOR = "\u241E";
-// Current mode
+// Current mode -- initial value is placeholder during start-up
-private Mode mode = new Mode("", false); // initial value placeholder during start-up
+private Mode mode = new Mode("");
+// Retained current mode -- for checks
+private Mode retainedCurrentMode = null;
 // Mapping of mode name to mode
 private final Map<String, Mode> modeMap = new HashMap<>();
 // Mapping of mode names to encoded retained mode
 public boolean setTruncation(MessageHandler messageHandler, ArgTokenizer at) {
 return new Setter(messageHandler, at).setTruncation();
 }
-public boolean setNewMode(MessageHandler messageHandler, ArgTokenizer at) {
+public boolean setMode(MessageHandler messageHandler, ArgTokenizer at) {
-return new Setter(messageHandler, at).setNewMode();
+return new Setter(messageHandler, at).setMode();
 }
 public boolean setPrompt(MessageHandler messageHandler, ArgTokenizer at) {
 return new Setter(messageHandler, at).setPrompt();
 }
 public String retainMode(MessageHandler messageHandler, ArgTokenizer at) {
 return new Setter(messageHandler, at).retainMode();
 }
 public boolean restoreEncodedModes(MessageHandler messageHandler, String encoded) {
-return new Setter(messageHandler, new ArgTokenizer("")).restoreEncodedModes(encoded);
+return new Setter(messageHandler, new ArgTokenizer("<init>", "")).restoreEncodedModes(encoded);
 }
 public void markModesReadOnly() {
 modeMap.values().stream()
 .forEach(m -> m.readOnly = true);
 // Name of mode
 final String name;
 // Display command verification/information
-final boolean commandFluff;
+boolean commandFluff;
 // Event cases: class, method, expression, ...
 final Map<String, List<Setting>> cases;
 boolean readOnly = false;
 * Set up an empty mode.
 *
 * @param name
 * @param commandFluff True if should display command fluff messages
 */
-Mode(String name, boolean commandFluff) {
+Mode(String name) {
 this.name = name;
-this.commandFluff = commandFluff;
+this.cases = new HashMap<>();
-cases = new HashMap<>();
 add("name",       new Setting(ALWAYS, "%1$s"));
 add("type",       new Setting(ALWAYS, "%2$s"));
 add("value",      new Setting(ALWAYS, "%3$s"));
 add("unresolved", new Setting(ALWAYS, "%4$s"));
 add("errors",     new Setting(ALWAYS, "%5$s"));
 /**
 * Set up a copied mode.
 *
 * @param name
-* @param commandFluff True if should display command fluff messages
 * @param m Mode to copy, or null for no fresh
 */
-Mode(String name, boolean commandFluff, Mode m) {
+Mode(String name, Mode m) {
 this.name = name;
-this.commandFluff = commandFluff;
+this.commandFluff = m.commandFluff;
-cases = new HashMap<>();
+this.prompt = m.prompt;
+this.continuationPrompt = m.continuationPrompt;
+this.cases = new HashMap<>();
 m.cases.entrySet().stream()
 .forEach(fes -> fes.getValue()
 .forEach(ing -> add(fes.getKey(), ing)));
-this.prompt = m.prompt;
-this.continuationPrompt = m.continuationPrompt;
 }
 /**
 * Set up a mode reconstituted from a preferences string.
 *
 Setting ing = new Setting(Long.parseLong(bits), format);
 settings.add(ing);
 }
 cases.put(field, settings);
 }
+}
+/**
+* Set if this mode displays informative/confirmational messages on
+* commands.
+*
+* @param fluff the value to set
+*/
+void setCommandFluff(boolean fluff) {
+commandFluff = fluff;
 }
 /**
 * Encodes the mode into a String so it can be saved in Preferences.
 *
 fluffmsg("jshell.msg.see", "/help /set prompt");
 }
 return valid;
 }
-// For /set newmode <new-mode> [-command|-quiet [<old-mode>]]
+/**
-boolean setNewMode() {
+* Set mode. Create, changed, or delete a feedback mode. For @{code /set
-String umode = at.next();
+* mode <mode> [<old-mode>] [-command|-quiet|-delete]}.
-if (umode == null || !at.isIdentifier()) {
+*
-errorat("jshell.err.feedback.expected.new.feedback.mode");
+* @return true if successful
-valid = false;
+*/
-}
+boolean setMode() {
-if (modeMap.containsKey(umode)) {
+at.allowedOptions("-command", "-quiet", "-delete");
-errorat("jshell.err.feedback.expected.mode.name", umode);
+String umode = nextModeIdentifier();
-valid = false;
-}
-String[] fluffOpt = at.next("-command", "-quiet");
-boolean fluff = fluffOpt == null || fluffOpt.length != 1 || "-command".equals(fluffOpt[0]);
-if (fluffOpt != null && fluffOpt.length != 1) {
-errorat("jshell.err.feedback.command.quiet");
-valid = false;
-}
 Mode om = null;
 String omode = at.next();
-if (omode != null) {
+if (valid && omode != null) {
 om = toMode(omode);
 }
+checkOptionsAndRemainingInput();
+boolean commandOption = at.hasOption("-command");
+boolean quietOption = at.hasOption("-quiet");
+boolean deleteOption = at.hasOption("-delete");
+// Only one (or zero) of the options can be used
+if (valid && at.optionCount() > 1) {
+errorat("jshell.err.conflicting.options");
+valid = false;
+}
 if (valid) {
-Mode nm = (om != null)
+Mode m = modeMap.get(umode);
-? new Mode(umode, fluff, om)
+if (m != null && m.readOnly) {
-: new Mode(umode, fluff);
+// Cannot make changes to a the built-in modes
-modeMap.put(umode, nm);
+errorat("jshell.err.not.valid.with.predefined.mode", m.name);
-fluffmsg("jshell.msg.feedback.new.mode", nm.name);
+valid = false;
-} else {
+} else if (deleteOption) {
-fluffmsg("jshell.msg.see", "/help /set newmode");
+if (m == null) {
+// Cannot delete a mode that does not exist
+errorat("jshell.err.mode.unknown", umode);
+valid = false;
+} else if (mode.name.equals(m.name)) {
+// Cannot delete the current mode out from under us
+errorat("jshell.err.cannot.delete.current.mode", umode);
+valid = false;
+} else {
+// Remove the mode
+modeMap.remove(umode);
+}
+} else {
+if (om != null || m == null) {
+// We are copying and existing mode and/or creating a
+// brand-new mode -- in either case create from scratch
+m = (om != null)
+? new Mode(umode, om)
+: new Mode(umode);
+modeMap.put(umode, m);
+fluffmsg("jshell.msg.feedback.new.mode", m.name);
+// Set the current mode by name, in case we just smashed
+// the current mode
+if (umode.equals(mode.name)) {
+mode = modeMap.get(mode.name);
+}
+}
+if (commandOption || quietOption || om == null) {
+// set command fluff, if explicit, or wholly new
+m.setCommandFluff(!quietOption);
+}
+}
+}
+if (!valid) {
+fluffmsg("jshell.msg.see", "/help /set mode");
 }
 return valid;
 }
 // For /set feedback <mode>
 Mode m = nextMode();
 if (valid && m.readOnly) {
 errorat("jshell.err.not.valid.with.predefined.mode", m.name);
 valid = false;
 }
-String field = at.next();
+String field = valid
-if (field == null || !at.isIdentifier()) {
+? toIdentifier(at.next(), "jshell.err.missing.field", "jshell.err.field.name")
-errorat("jshell.err.feedback.expected.field");
+: null;
-valid = false;
-}
 String format = valid ? nextFormat() : null;
 return installFormat(m, field, format, "/help /set format");
 }
 // For /set truncation <mode> <length> <selector>...
 }
 String retainFeedback() {
 String umode = at.next();
 if (umode != null) {
-Mode m = toMode(umode);
+toModeIdentifier(umode);
+Mode m = valid ? toMode(umode) : null;
 if (valid && !m.readOnly && !retainedMap.containsKey(m.name)) {
 errorat("jshell.err.retained.feedback.mode.must.be.retained.or.predefined");
 valid = false;
 }
 if (valid) {
 mode = m;
+retainedCurrentMode = m;
 fluffmsg("jshell.msg.feedback.mode", mode.name);
 } else {
 fluffmsg("jshell.msg.see", "/help /retain feedback");
 return null;
 }
 }
 return mode.name;
 }
+/**
+* Retain (or delete from retention) a previously set mode.
+*
+* @return all retained modes encoded into a String
+*/
 String retainMode() {
-Mode m = nextMode();
+at.allowedOptions("-delete");
-if (valid && m.readOnly) {
+String umode = nextModeIdentifier();
-errorat("jshell.err.not.valid.with.predefined.mode", m.name);
+// -delete is the only valid option, fail for anything else
+checkOptionsAndRemainingInput();
+boolean deleteOption = at.hasOption("-delete");
+// Lookup the mode
+Mode m;
+if (!valid) {
+m = null;
+// Skip this stuff, we have failed already
+} else if (deleteOption) {
+// If delete, allow for deleting, from retention, a mode that
+// has been locally deleted but is retained.
+// Also require the full name.
+m = modeMap.get(umode);
+if (m == null && !retainedMap.containsKey(umode)) {
+errorat("jshell.err.mode.unknown", umode);
+valid = false;
+}
+} else {
+// For retain do normal lookup and checking
+m = toMode(umode);
+}
+// Built-in modes cannot be retained or deleted
+if (valid && m != null && m.readOnly) {
+errorat("jshell.err.not.valid.with.predefined.mode", umode);
 valid = false;
 }
 if (valid) {
-retainedMap.put(m.name, m.encode());
+if (deleteOption) {
+if (mode.name.equals(umode)) {
+// Cannot delete the current mode out from under us
+errorat("jshell.err.cannot.delete.current.mode", umode);
+valid = false;
+} else if (retainedCurrentMode != null && retainedCurrentMode.name.equals(umode)) {
+// Cannot delete the retained mode or re-start has error
+errorat("jshell.err.cannot.delete.retained.mode", umode);
+valid = false;
+} else {
+// Delete the mode
+modeMap.remove(umode);
+retainedMap.remove(umode);
+}
+} else {
+// Retain the current encoding
+retainedMap.put(m.name, m.encode());
+}
+}
+if (valid) {
+// Join all the retained encodings
 return String.join(RECORD_SEPARATOR, retainedMap.values());
 } else {
 fluffmsg("jshell.msg.see", "/help /retain mode");
 return null;
 }
 }
 boolean restoreEncodedModes(String allEncoded) {
-// Iterate over each record in each encoded mode
+try {
-String[] ms = allEncoded.split(RECORD_SEPARATOR);
+// Iterate over each record in each encoded mode
-Iterator<String> itr = Arrays.asList(ms).iterator();
+String[] ms = allEncoded.split(RECORD_SEPARATOR);
-while (itr.hasNext()) {
+Iterator<String> itr = Arrays.asList(ms).iterator();
-// Reconstruct the encoded mode
+while (itr.hasNext()) {
-Mode m = new Mode(itr);
+// Reconstruct the encoded mode
-modeMap.put(m.name, m);
+Mode m = new Mode(itr);
-// Continue to retain it a new retains occur
+modeMap.put(m.name, m);
-retainedMap.put(m.name, m.encode());
+// Continue to retain it a new retains occur
-}
+retainedMap.put(m.name, m.encode());
-return true;
+}
+return true;
+} catch (Throwable exc) {
+// Catastrophic corruption -- clear map
+errorat("jshell.err.retained.mode.failure", exc);
+retainedMap.clear();
+return false;
+}
 }
 // install the format of a field under parsed selectors
 boolean installFormat(Mode m, String field, String format, String help) {
 String slRaw;
 fluffmsg("jshell.msg.see", help);
 }
 return valid;
 }
+void checkOptionsAndRemainingInput() {
+if (!valid) {
+return;
+}
+String junk = at.remainder();
+if (!junk.isEmpty()) {
+errorat("jshell.err.unexpected.at.end", junk);
+valid = false;
+} else {
+String bad = at.badOptions();
+if (!bad.isEmpty()) {
+errorat("jshell.err.unknown.option", bad);
+valid = false;
+}
+}
+}
+/**
+* Check that the specified string is an identifier (Java identifier).
+* If null display the missing error. If it is not an identifier,
+* display the error.
+*
+* @param id the string to check, MUST be the most recently retrieved
+* token from 'at'.
+* @param missing the resource error to display if null
+* @param err the resource error to display if not an identifier
+* @return the identifier string, or null if null or not an identifier
+*/
+String toIdentifier(String id, String missing, String err) {
+if (id == null) {
+errorat(missing);
+valid = false;
+return null;
+}
+if (at.isQuoted() ||
+!id.codePoints().allMatch(cp -> Character.isJavaIdentifierPart(cp))) {
+errorat(err, id);
+valid = false;
+return null;
+}
+return id;
+}
+String toModeIdentifier(String id) {
+return toIdentifier(id, "jshell.err.missing.mode", "jshell.err.mode.name");
+}
+String nextModeIdentifier() {
+return toModeIdentifier(at.next());
+}
 Mode nextMode() {
-String umode = at.next();
+String umode = nextModeIdentifier();
 return toMode(umode);
 }
 Mode toMode(String umode) {
-if (umode == null || !at.isIdentifier()) {
+if (!valid) {
-errorat("jshell.err.feedback.expected.mode");
+return null;
+}
+if (umode == null) {
+errorat("jshell.err.missing.mode");
 valid = false;
 return null;
 }
 Mode m = modeMap.get(umode);
 if (m != null) {

changeset 38539	71874886920f
parent 38531	c449daa25b45
child 40600	3874367e6e6f