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

equal deleted inserted replaced

-:416dfba03d33
+:aacf94dab449
 /*
 * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 import static java.nio.file.StandardOpenOption.WRITE;
 import java.util.MissingResourceException;
 import java.util.Optional;
 import java.util.ResourceBundle;
 import java.util.Spliterators;
+import java.util.function.Function;
 import java.util.function.Supplier;
 import static java.util.stream.Collectors.toList;
+import static jdk.jshell.Snippet.SubKind.VAR_VALUE_SUBKIND;
 /**
 * Command line REPL tool for Java using the JShell API.
 * @author Robert Field
 */
 public class JShellTool {
 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";
 final InputStream cmdin;
 final PrintStream cmdout;
 final PrintStream cmderr;
 final PrintStream console;
 private Feedback feedback = Feedback.Default;
 private String cmdlineClasspath = null;
 private String cmdlineStartup = null;
 private String editor = null;
-static final Preferences PREFS = Preferences.userRoot().node("tool/REPL");
+// Commands and snippets which should be replayed
+private List<String> replayableHistory;
+private List<String> replayableHistoryPrevious;
+static final Preferences PREFS = Preferences.userRoot().node("tool/JShell");
 static final String STARTUP_KEY = "STARTUP";
+static final String REPLAY_RESTORE_KEY = "REPLAY_RESTORE";
 static final String DEFAULT_STARTUP =
 "\n" +
 "import java.util.*;\n" +
 "import java.io.*;\n" +
 "import java.util.concurrent.*;\n" +
 "import java.util.prefs.*;\n" +
 "import java.util.regex.*;\n" +
 "void printf(String format, Object... args) { System.out.printf(format, args); }\n";
-// Tool id (tid) mapping
+// Tool id (tid) mapping: the three name spaces
 NameSpace mainNamespace;
 NameSpace startNamespace;
 NameSpace errorNamespace;
+// Tool id (tid) mapping: the current name spaces
 NameSpace currentNameSpace;
 Map<Snippet,SnippetInfo> mapSnippet;
 void debug(String format, Object... args) {
 if (debug) {
 cmderr.printf(format + "\n", args);
 }
 }
 private void start(IOContext in, List<String> loadList) {
 resetState(); // Initialize
+// Read replay history from last jshell session into previous history
+String prevReplay = PREFS.get(REPLAY_RESTORE_KEY, null);
+if (prevReplay != null) {
+replayableHistoryPrevious = Arrays.asList(prevReplay.split(RECORD_SEPARATOR));
+}
 for (String loadFile : loadList) {
 cmdOpen(loadFile);
 }
 startNamespace = new NameSpace("start", "s");
 errorNamespace = new NameSpace("error", "e");
 mapSnippet = new LinkedHashMap<>();
 currentNameSpace = startNamespace;
+// Reset the replayable history, saving the old for restore
+replayableHistoryPrevious = replayableHistory;
+replayableHistory = new ArrayList<>();
 state = JShell.builder()
 .in(userin)
 .out(userout)
 .err(usererr)
 .tempVariableNameGenerator(()-> "$" + currentNameSpace.tidNext())
 : errorNamespace.tid(sn))
 .build();
 analysis = state.sourceCodeAnalysis();
 shutdownSubscription = state.onShutdown((JShell deadState) -> {
 if (deadState == state) {
-hard("State engine terminated.  See /history");
+hard("State engine terminated.");
+hard("Restore definitions with: /reload restore");
 live = false;
 }
 });
 live = true;
 if (cmdlineClasspath != null) {
 state.addToClasspath(cmdlineClasspath);
 }
 String start;
 if (cmdlineStartup == null) {
 start = PREFS.get(STARTUP_KEY, "<nada>");
 if (start.equals("<nada>")) {
 input = in;
 try {
 String incomplete = "";
 while (live) {
 String prompt;
-if (in.interactiveOutput() && displayPrompt) {
+if (displayPrompt) {
 prompt = testPrompt
 ? incomplete.isEmpty()
 ? "\u0005" //ENQ
 : "\u0006" //ACK
 : incomplete.isEmpty()
 } finally {
 input = oldInput;
 }
 }
+private void addToReplayHistory(String s) {
+if (currentNameSpace == mainNamespace) {
+replayableHistory.add(s);
+}
+}
 private String processSourceCatchingReset(String src) {
 try {
 input.beforeUserCode();
 return processSource(src);
 } catch (IllegalStateException ex) {
 if (!rerunHistoryEntryById(cmd.substring(1))) {
 hard("No such command or snippet id: %s", cmd);
 fluff("Type /help for help.");
 }
 } else if (candidates.length == 1) {
-candidates[0].run.accept(arg);
+Command command = candidates[0];
+// If comand was successful and is of a replayable kind, add it the replayable history
+if (command.run.apply(arg) && command.kind == CommandKind.REPLAY) {
+addToReplayHistory((command.command + " " + arg).trim());
+}
 } else {
 hard("Command: %s is ambiguous: %s", cmd, Arrays.stream(candidates).map(c -> c.command).collect(Collectors.joining(", ")));
 fluff("Type /help for help.");
 }
 }
 static final class Command {
 public final String command;
 public final String params;
 public final String description;
-public final Consumer<String> run;
+public final Function<String,Boolean> run;
 public final CompletionProvider completions;
 public final CommandKind kind;
-public Command(String command, String params, String description, Consumer<String> run, CompletionProvider completions) {
+public Command(String command, String params, String description, Function<String,Boolean> run, CompletionProvider completions) {
 this(command, params, description, run, completions, CommandKind.NORMAL);
 }
-public Command(String command, String params, String description, Consumer<String> run, CompletionProvider completions, CommandKind kind) {
+public Command(String command, String params, String description, Function<String,Boolean> run, CompletionProvider completions, CommandKind kind) {
 this.command = command;
 this.params = params;
 this.description = description;
 this.run = run;
 this.completions = completions;
 List<Suggestion> completionSuggestions(String input, int cursor, int[] anchor);
 }
 enum CommandKind {
 NORMAL,
+REPLAY,
 HIDDEN,
 HELP_ONLY;
 }
 static final class FixedCompletionProvider implements CompletionProvider {
 }
 private static final CompletionProvider EMPTY_COMPLETION_PROVIDER = new FixedCompletionProvider();
 private static final CompletionProvider KEYWORD_COMPLETION_PROVIDER = new FixedCompletionProvider("all ", "start ", "history ");
+private static final CompletionProvider RELOAD_OPTIONS_COMPLETION_PROVIDER = new FixedCompletionProvider("restore", "quiet");
 private static final CompletionProvider FILE_COMPLETION_PROVIDER = fileCompletions(p -> true);
 private final Map<String, Command> commands = new LinkedHashMap<>();
 private void registerCommand(Command cmd) {
 commands.put(cmd.command, cmd);
 }
 anchor[0] += space + 1;
 return result;
 };
 }
+private static CompletionProvider reloadCompletion() {
+return (code, cursor, anchor) -> {
+List<Suggestion> result = new ArrayList<>();
+int pastSpace = code.indexOf(' ') + 1; // zero if no space
+result.addAll(RELOAD_OPTIONS_COMPLETION_PROVIDER.completionSuggestions(code.substring(pastSpace), cursor - pastSpace, anchor));
+anchor[0] += pastSpace;
+return result;
+};
+}
 // Table of commands -- with command forms, argument kinds, help message, implementation, ...
 {
 registerCommand(new Command("/list", "[all|start|history|<name or id>]", "list the source you have typed",
 arg -> cmdList(arg),
 registerCommand(new Command("/edit", "<name or id>", "edit a source entry referenced by name or id",
 arg -> cmdEdit(arg),
 editCompletion()));
 registerCommand(new Command("/drop", "<name or id>", "delete a source entry referenced by name or id",
 arg -> cmdDrop(arg),
-editCompletion()));
+editCompletion(),
+CommandKind.REPLAY));
 registerCommand(new Command("/save", "[all|history|start] <file>", "save: <none> - current source;\n" +
 "      all - source including overwritten, failed, and start-up code;\n" +
 "      history - editing history;\n" +
 "      start - default start-up definitions",
 arg -> cmdSave(arg),
 arg -> cmdExit(),
 EMPTY_COMPLETION_PROVIDER));
 registerCommand(new Command("/reset", null, "reset everything in the REPL",
 arg -> cmdReset(),
 EMPTY_COMPLETION_PROVIDER));
+registerCommand(new Command("/reload", "[restore] [quiet]", "reset and replay relevant history -- current or previous (restore)",
+arg -> cmdReload(arg),
+reloadCompletion()));
 registerCommand(new Command("/feedback", "<level>", "feedback information: off, concise, normal, verbose, default, or ?",
 arg -> cmdFeedback(arg),
 new FixedCompletionProvider("off", "concise", "normal", "verbose", "default", "?")));
 registerCommand(new Command("/prompt", null, "toggle display of a prompt",
 arg -> cmdPrompt(),
 EMPTY_COMPLETION_PROVIDER));
 registerCommand(new Command("/classpath", "<path>", "add a path to the classpath",
 arg -> cmdClasspath(arg),
-classPathCompletion()));
+classPathCompletion(),
+CommandKind.REPLAY));
 registerCommand(new Command("/history", null, "history of what you have typed",
 arg -> cmdHistory(),
 EMPTY_COMPLETION_PROVIDER));
 registerCommand(new Command("/setstart", "<file>", "read file and set as the new start-up definitions",
 arg -> cmdSetStart(arg),
 return null;
 }
 // --- Command implementations ---
-void cmdSetEditor(String arg) {
+boolean cmdSetEditor(String arg) {
 if (arg.isEmpty()) {
 hard("/seteditor requires a path argument");
+return false;
 } else {
 editor = arg;
 fluff("Editor set to: %s", arg);
-}
+return true;
 }
+}
-void cmdClasspath(String arg) {
+boolean cmdClasspath(String arg) {
 if (arg.isEmpty()) {
 hard("/classpath requires a path argument");
+return false;
 } else {
 state.addToClasspath(toPathResolvingUserHome(arg).toString());
 fluff("Path %s added to classpath", arg);
-}
+return true;
 }
+}
-void cmdDebug(String arg) {
+boolean cmdDebug(String arg) {
 if (arg.isEmpty()) {
 debug = !debug;
 InternalDebugControl.setDebugFlags(state, debug ? InternalDebugControl.DBG_GEN : 0);
 fluff("Debugging %s", debug ? "on" : "off");
 } else {
 fluff("Event debugging on");
 break;
 default:
 hard("Unknown debugging option: %c", ch);
 fluff("Use: 0 r g f c d");
-break;
+return false;
 }
 }
 InternalDebugControl.setDebugFlags(state, flags);
 }
-}
+return true;
+}
-private void cmdExit() {
+private boolean cmdExit() {
 regenerateOnDeath = false;
 live = false;
+if (!replayableHistory.isEmpty()) {
+PREFS.put(REPLAY_RESTORE_KEY, replayableHistory.stream().reduce(
+(a, b) -> a + RECORD_SEPARATOR + b).get());
+}
 fluff("Goodbye\n");
-}
+return true;
+}
-private void cmdFeedback(String arg) {
+private boolean cmdFeedback(String arg) {
 switch (arg) {
 case "":
 case "d":
 case "default":
 feedback = Feedback.Default;
 hard("  normal");
 hard("  verbose");
 hard("  default");
 hard("You may also use just the first letter, for example: /f c");
 hard("In interactive mode 'default' is the same as 'normal', from a file it is the same as 'off'");
-return;
+return false;
 }
 fluff("Feedback mode: %s", feedback.name().toLowerCase());
-}
+return true;
+}
-void cmdHelp() {
+boolean cmdHelp() {
 int synopsisLen = 0;
 Map<String, String> synopsis2Description = new LinkedHashMap<>();
 for (Command cmd : new LinkedHashSet<>(commands.values())) {
 if (cmd.kind == CommandKind.HIDDEN)
 continue;
 }
 cmdout.println();
 cmdout.println("Supported shortcuts include:");
 cmdout.println("<tab>       -- show possible completions for the current text");
 cmdout.println("Shift-<tab> -- for current method or constructor invocation, show a synopsis of the method/constructor");
-}
+return true;
+}
-private void cmdHistory() {
+private boolean cmdHistory() {
 cmdout.println();
 for (String s : input.currentSessionHistory()) {
 // No number prefix, confusing with snippet ids
 cmdout.printf("%s\n", s);
 }
+return true;
 }
 /**
 * Avoid parameterized varargs possible heap pollution warning.
 */
 );
 return result;
 }
 }
-private void cmdDrop(String arg) {
+private boolean cmdDrop(String arg) {
 if (arg.isEmpty()) {
 hard("In the /drop argument, please specify an import, variable, method, or class to drop.");
 hard("Specify by id or name. Use /list to see ids. Use /reset to reset all state.");
-return;
+return false;
 }
 Stream<Snippet> stream = argToSnippets(arg, false);
 if (stream == null) {
 hard("No definition or id named %s found.  See /classes, /methods, /vars, or /list", arg);
-return;
+return false;
 }
 List<Snippet> snippets = stream
 .filter(sn -> state.status(sn).isActive && sn instanceof PersistentSnippet)
 .collect(toList());
 if (snippets.isEmpty()) {
 hard("The argument did not specify an active import, variable, method, or class to drop.");
-return;
+return false;
 }
 if (snippets.size() > 1) {
 hard("The argument references more than one import, variable, method, or class.");
 hard("Try again with one of the ids below:");
 for (Snippet sn : snippets) {
 cmdout.printf("%4s : %s\n", sn.id(), sn.source().replace("\n", "\n       "));
 }
-return;
+return false;
 }
 PersistentSnippet psn = (PersistentSnippet) snippets.get(0);
 state.drop(psn).forEach(this::handleEvent);
-}
+return true;
+}
-private void cmdEdit(String arg) {
+private boolean cmdEdit(String arg) {
 Stream<Snippet> stream = argToSnippets(arg, true);
 if (stream == null) {
 hard("No definition or id named %s found.  See /classes, /methods, /vars, or /list", arg);
-return;
+return false;
 }
 Set<String> srcSet = new LinkedHashSet<>();
 stream.forEachOrdered(sn -> {
 String src = sn.source();
 switch (sn.subKind()) {
 if (editor == null) {
 EditPad.edit(errorHandler, src, saveHandler);
 } else {
 ExternalEditor.edit(editor, errorHandler, src, saveHandler, input);
 }
+return true;
 }
 //where
 // receives editor requests to save
 private class SaveHandler implements Consumer<String> {
 }
 return s.substring(b, e + 1);
 }
 }
-private void cmdList(String arg) {
+private boolean cmdList(String arg) {
 if (arg.equals("history")) {
-cmdHistory();
+return cmdHistory();
-return;
 }
 Stream<Snippet> stream = argToSnippets(arg, true);
 if (stream == null) {
 // Check if there are any definitions at all
 if (argToSnippets("", false).iterator().hasNext()) {
 hard("No definition or id named %s found.  Try /list without arguments.", arg);
 } else {
 hard("No definition or id named %s found.  There are no active definitions.", arg);
 }
-return;
+return false;
 }
 // prevent double newline on empty list
 boolean[] hasOutput = new boolean[1];
 stream.forEachOrdered(sn -> {
 cmdout.println();
 hasOutput[0] = true;
 }
 cmdout.printf("%4s : %s\n", sn.id(), sn.source().replace("\n", "\n       "));
 });
-}
+return true;
+}
-private void cmdOpen(String filename) {
+private boolean cmdOpen(String filename) {
 if (filename.isEmpty()) {
 hard("The /open command requires a filename argument.");
+return false;
 } else {
 try {
 run(new FileScannerIOContext(toPathResolvingUserHome(filename).toString()));
 } catch (FileNotFoundException e) {
 hard("File '%s' is not found: %s", filename, e.getMessage());
+return false;
 } catch (Exception e) {
 hard("Exception while reading file: %s", e);
-}
+return false;
 }
 }
+return true;
-private void cmdPrompt() {
+}
+private boolean cmdPrompt() {
 displayPrompt = !displayPrompt;
 fluff("Prompt will %sdisplay. Use /prompt to toggle.", displayPrompt ? "" : "NOT ");
 concise("Prompt: %s", displayPrompt ? "on" : "off");
-}
+return true;
+}
-private void cmdReset() {
+private boolean cmdReset() {
 live = false;
 fluff("Resetting state.");
-}
+return true;
+}
-private void cmdSave(String arg_filename) {
+private boolean cmdReload(String arg) {
+Iterable<String> history = replayableHistory;
+boolean echo = true;
+if (arg.length() > 0) {
+if ("restore".startsWith(arg)) {
+if (replayableHistoryPrevious == null) {
+hard("No previous history to restore\n", arg);
+return false;
+}
+history = replayableHistoryPrevious;
+} else if ("quiet".startsWith(arg)) {
+echo = false;
+} else {
+hard("Invalid argument to reload command: %s\nUse 'restore', 'quiet', or no argument\n", arg);
+return false;
+}
+}
+fluff("Restarting and restoring %s.",
+history == replayableHistoryPrevious
+? "from previous state"
+: "state");
+resetState();
+run(new ReloadIOContext(history,
+echo? cmdout : null));
+return true;
+}
+private boolean cmdSave(String arg_filename) {
 Matcher mat = HISTORY_ALL_START_FILENAME.matcher(arg_filename);
 if (!mat.find()) {
 hard("Malformed argument to the /save command: %s", arg_filename);
-return;
+return false;
 }
 boolean useHistory = false;
 String saveAll = "";
 boolean saveStart = false;
 String cmd = mat.group("cmd");
 break;
 }
 String filename = mat.group("filename");
 if (filename == null ||filename.isEmpty()) {
 hard("The /save command requires a filename argument.");
-return;
+return false;
 }
 try (BufferedWriter writer = Files.newBufferedWriter(toPathResolvingUserHome(filename),
 Charset.defaultCharset(),
 CREATE, TRUNCATE_EXISTING, WRITE)) {
 if (useHistory) {
 }
 }
 }
 } catch (FileNotFoundException e) {
 hard("File '%s' for save is not accessible: %s", filename, e.getMessage());
+return false;
 } catch (Exception e) {
 hard("Exception while saving: %s", e);
-}
+return false;
 }
+return true;
-private void cmdSetStart(String filename) {
+}
+private boolean cmdSetStart(String filename) {
 if (filename.isEmpty()) {
 hard("The /setstart command requires a filename argument.");
 } else {
 try {
 byte[] encoded = Files.readAllBytes(toPathResolvingUserHome(filename));
 String init = new String(encoded);
 PREFS.put(STARTUP_KEY, init);
 } catch (AccessDeniedException e) {
 hard("File '%s' for /setstart is not accessible.", filename);
+return false;
 } catch (NoSuchFileException e) {
 hard("File '%s' for /setstart is not found.", filename);
+return false;
 } catch (Exception e) {
 hard("Exception while reading start set file: %s", e);
-}
+return false;
 }
 }
+return true;
-private void cmdVars() {
+}
+private boolean cmdVars() {
 for (VarSnippet vk : state.variables()) {
 String val = state.status(vk) == Status.VALID
 ? state.varValue(vk)
 : "(not-active)";
 hard("  %s %s = %s", vk.typeName(), vk.name(), val);
 }
-}
+return true;
+}
-private void cmdMethods() {
+private boolean cmdMethods() {
 for (MethodSnippet mk : state.methods()) {
 hard("  %s %s", mk.name(), mk.signature());
 }
-}
+return true;
+}
-private void cmdClasses() {
+private boolean cmdClasses() {
 for (TypeDeclSnippet ck : state.types()) {
 String kind;
 switch (ck.subKind()) {
 case INTERFACE_SUBKIND:
 kind = "interface";
 kind = "class";
 break;
 }
 hard("  %s %s", kind, ck.name());
 }
-}
+return true;
+}
-private void cmdImports() {
+private boolean cmdImports() {
 state.imports().forEach(ik -> {
 hard("  import %s%s", ik.isStatic() ? "static " : "", ik.fullname());
 });
-}
+return true;
+}
-private void cmdUseHistoryEntry(int index) {
+private boolean cmdUseHistoryEntry(int index) {
 List<Snippet> keys = state.snippets();
 if (index < 0)
 index += keys.size();
 else
 index--;
 if (index >= 0 && index < keys.size()) {
 rerunSnippet(keys.get(index));
 } else {
 hard("Cannot find snippet %d", index + 1);
-}
+return false;
+}
+return true;
 }
 private boolean rerunHistoryEntryById(String id) {
 Optional<Snippet> snippet = state.snippets().stream()
 .filter(s -> s.id().equals(id))
 }
 //where
 private boolean processCompleteSource(String source) throws IllegalStateException {
 debug("Compiling: %s", source);
 boolean failed = false;
+boolean isActive = false;
 List<SnippetEvent> events = state.eval(source);
 for (SnippetEvent e : events) {
+// Report the event, recording failure
 failed |= handleEvent(e);
-}
+// If any main snippet is active, this should be replayable
+// also ignore var value queries
+isActive |= e.causeSnippet() == null &&
+e.status().isActive &&
+e.snippet().subKind() != VAR_VALUE_SUBKIND;
+}
+// If this is an active snippet and it didn't cause the backend to die,
+// add it to the replayable history
+if (isActive && live) {
+addToReplayHistory(source);
+}
 return failed;
 }
 private boolean handleEvent(SnippetEvent ste) {
 Snippet sn = ste.snippet();
 this.tid = tid;
 }
 }
 }
-class ScannerIOContext extends IOContext {
+abstract class NonInteractiveIOContext extends IOContext {
+@Override
+public boolean interactiveOutput() {
+return false;
+}
+@Override
+public Iterable<String> currentSessionHistory() {
+return Collections.emptyList();
+}
+@Override
+public boolean terminalEditorRunning() {
+return false;
+}
+@Override
+public void suspend() {
+}
+@Override
+public void resume() {
+}
+@Override
+public void beforeUserCode() {
+}
+@Override
+public void afterUserCode() {
+}
+@Override
+public void replaceLastHistoryEntry(String source) {
+}
+}
+class ScannerIOContext extends NonInteractiveIOContext {
 private final Scanner scannerIn;
-private final PrintStream pStream;
+ScannerIOContext(Scanner scannerIn) {
-public ScannerIOContext(Scanner scannerIn, PrintStream pStream) {
 this.scannerIn = scannerIn;
-this.pStream = pStream;
 }
 @Override
 public String readLine(String prompt, String prefix) {
-if (pStream != null && prompt != null) {
-pStream.print(prompt);
-}
 if (scannerIn.hasNextLine()) {
 return scannerIn.nextLine();
 } else {
 return null;
 }
 }
 @Override
-public boolean interactiveOutput() {
+public void close() {
-return true;
+scannerIn.close();
+}
+}
+class FileScannerIOContext extends ScannerIOContext {
+FileScannerIOContext(String fn) throws FileNotFoundException {
+this(new FileReader(fn));
+}
+FileScannerIOContext(Reader rdr) throws FileNotFoundException {
+super(new Scanner(rdr));
+}
+}
+class ReloadIOContext extends NonInteractiveIOContext {
+private final Iterator<String> it;
+private final PrintStream echoStream;
+ReloadIOContext(Iterable<String> history, PrintStream echoStream) {
+this.it = history.iterator();
+this.echoStream = echoStream;
 }
 @Override
-public Iterable<String> currentSessionHistory() {
+public String readLine(String prompt, String prefix) {
-return Collections.emptyList();
+String s = it.hasNext()
+? it.next()
+: null;
+if (echoStream != null && s != null) {
+String p = "-: ";
+String p2 = "\n   ";
+echoStream.printf("%s%s\n", p, s.replace("\n", p2));
+}
+return s;
 }
 @Override
 public void close() {
-scannerIn.close();
-}
-@Override
-public boolean terminalEditorRunning() {
-return false;
-}
-@Override
-public void suspend() {
-}
-@Override
-public void resume() {
-}
-@Override
-public void beforeUserCode() {
-}
-@Override
-public void afterUserCode() {
-}
-@Override
-public void replaceLastHistoryEntry(String source) {
 }
 }
-class FileScannerIOContext extends ScannerIOContext {
-public FileScannerIOContext(String fn) throws FileNotFoundException {
-this(new FileReader(fn));
-}
-public FileScannerIOContext(Reader rdr) throws FileNotFoundException {
-super(new Scanner(rdr), null);
-}
-@Override
-public boolean interactiveOutput() {
-return false;
-}
-}

changeset 34999	aacf94dab449
parent 34570	8a8f52a733dd
child 35000	952a7b4652f0