| /* |
| * 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 |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package jdk.internal.jshell.tool; |
| |
| import java.io.BufferedWriter; |
| import java.io.ByteArrayInputStream; |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.FileReader; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.PrintStream; |
| import java.io.Reader; |
| import java.io.StringReader; |
| import java.nio.charset.Charset; |
| import java.nio.file.AccessDeniedException; |
| import java.nio.file.FileSystems; |
| import java.nio.file.Files; |
| import java.nio.file.NoSuchFileException; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Scanner; |
| import java.util.Set; |
| import java.util.function.Consumer; |
| import java.util.function.Predicate; |
| import java.util.prefs.Preferences; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| import java.util.stream.Collectors; |
| import java.util.stream.Stream; |
| import java.util.stream.StreamSupport; |
| |
| import jdk.internal.jshell.debug.InternalDebugControl; |
| import jdk.internal.jshell.tool.IOContext.InputInterruptedException; |
| import jdk.jshell.Diag; |
| import jdk.jshell.EvalException; |
| import jdk.jshell.JShell; |
| import jdk.jshell.Snippet; |
| import jdk.jshell.DeclarationSnippet; |
| import jdk.jshell.TypeDeclSnippet; |
| import jdk.jshell.MethodSnippet; |
| import jdk.jshell.PersistentSnippet; |
| import jdk.jshell.VarSnippet; |
| import jdk.jshell.ExpressionSnippet; |
| import jdk.jshell.Snippet.Status; |
| import jdk.jshell.SourceCodeAnalysis; |
| import jdk.jshell.SourceCodeAnalysis.CompletionInfo; |
| import jdk.jshell.SourceCodeAnalysis.Suggestion; |
| import jdk.jshell.SnippetEvent; |
| import jdk.jshell.UnresolvedReferenceException; |
| import jdk.jshell.Snippet.SubKind; |
| import jdk.jshell.JShell.Subscription; |
| |
| import static java.nio.file.StandardOpenOption.CREATE; |
| import static java.nio.file.StandardOpenOption.TRUNCATE_EXISTING; |
| import static java.nio.file.StandardOpenOption.WRITE; |
| import java.util.MissingResourceException; |
| import java.util.ResourceBundle; |
| import static java.util.stream.Collectors.toList; |
| |
| /** |
| * 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_FILENAME = Pattern.compile( |
| "((?<cmd>(all|history))(\\z|\\p{javaWhitespace}+))?(?<filename>.*)"); |
| |
| final InputStream cmdin; |
| final PrintStream cmdout; |
| final PrintStream cmderr; |
| final PrintStream console; |
| final InputStream userin; |
| final PrintStream userout; |
| final PrintStream usererr; |
| |
| /** |
| * The constructor for the tool (used by tool launch via main and by test |
| * harnesses to capture ins and outs. |
| * @param cmdin command line input -- snippets and commands |
| * @param cmdout command line output, feedback including errors |
| * @param cmderr start-up errors and debugging info |
| * @param console console control interaction |
| * @param userin code execution input (not yet functional) |
| * @param userout code execution output -- System.out.printf("hi") |
| * @param usererr code execution error stream -- System.err.printf("Oops") |
| */ |
| public JShellTool(InputStream cmdin, PrintStream cmdout, PrintStream cmderr, |
| PrintStream console, |
| InputStream userin, PrintStream userout, PrintStream usererr) { |
| this.cmdin = cmdin; |
| this.cmdout = cmdout; |
| this.cmderr = cmderr; |
| this.console = console; |
| this.userin = userin; |
| this.userout = userout; |
| this.usererr = usererr; |
| } |
| |
| private IOContext input = null; |
| private boolean regenerateOnDeath = true; |
| private boolean live = false; |
| |
| SourceCodeAnalysis analysis; |
| JShell state = null; |
| Subscription shutdownSubscription = null; |
| |
| private boolean debug = false; |
| private boolean displayPrompt = true; |
| public boolean testPrompt = false; |
| 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"); |
| |
| static final String STARTUP_KEY = "STARTUP"; |
| |
| static final String DEFAULT_STARTUP = |
| "\n" + |
| "import java.util.*;\n" + |
| "import java.io.*;\n" + |
| "import java.math.*;\n" + |
| "import java.net.*;\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 |
| NameSpace mainNamespace; |
| NameSpace startNamespace; |
| NameSpace errorNamespace; |
| NameSpace currentNameSpace; |
| Map<Snippet,SnippetInfo> mapSnippet; |
| |
| void debug(String format, Object... args) { |
| if (debug) { |
| cmderr.printf(format + "\n", args); |
| } |
| } |
| |
| /** |
| * For more verbose feedback modes |
| * @param format printf format |
| * @param args printf args |
| */ |
| void fluff(String format, Object... args) { |
| if (feedback() != Feedback.Off && feedback() != Feedback.Concise) { |
| hard(format, args); |
| } |
| } |
| |
| /** |
| * For concise feedback mode only |
| * @param format printf format |
| * @param args printf args |
| */ |
| void concise(String format, Object... args) { |
| if (feedback() == Feedback.Concise) { |
| hard(format, args); |
| } |
| } |
| |
| /** |
| * For all feedback modes -- must show |
| * @param format printf format |
| * @param args printf args |
| */ |
| void hard(String format, Object... args) { |
| cmdout.printf("| " + format + "\n", args); |
| } |
| |
| /** |
| * Trim whitespace off end of string |
| * @param s |
| * @return |
| */ |
| static String trimEnd(String s) { |
| int last = s.length() - 1; |
| int i = last; |
| while (i >= 0 && Character.isWhitespace(s.charAt(i))) { |
| --i; |
| } |
| if (i != last) { |
| return s.substring(0, i + 1); |
| } else { |
| return s; |
| } |
| } |
| |
| /** |
| * Normal start entry point |
| * @param args |
| * @throws Exception |
| */ |
| public static void main(String[] args) throws Exception { |
| new JShellTool(System.in, System.out, System.err, System.out, |
| new ByteArrayInputStream(new byte[0]), System.out, System.err) |
| .start(args); |
| } |
| |
| public void start(String[] args) throws Exception { |
| List<String> loadList = processCommandArgs(args); |
| if (loadList == null) { |
| // Abort |
| return; |
| } |
| try (IOContext in = new ConsoleIOContext(this, cmdin, console)) { |
| start(in, loadList); |
| } |
| } |
| |
| private void start(IOContext in, List<String> loadList) { |
| resetState(); // Initialize |
| |
| for (String loadFile : loadList) { |
| cmdOpen(loadFile); |
| } |
| |
| if (regenerateOnDeath) { |
| fluff("Welcome to JShell -- Version %s", version()); |
| fluff("Type /help for help"); |
| } |
| |
| try { |
| while (regenerateOnDeath) { |
| if (!live) { |
| resetState(); |
| } |
| run(in); |
| } |
| } finally { |
| closeState(); |
| } |
| } |
| |
| /** |
| * Process the command line arguments. |
| * 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) { |
| cmderr.printf("Conflicting -classpath option.\n"); |
| return null; |
| } |
| if (ai.hasNext()) { |
| cmdlineClasspath = ai.next(); |
| } else { |
| cmderr.printf("Argument to -classpath missing.\n"); |
| return null; |
| } |
| break; |
| case "-help": |
| printUsage(); |
| return null; |
| case "-version": |
| cmdout.printf("jshell %s\n", version()); |
| return null; |
| case "-fullversion": |
| cmdout.printf("jshell %s\n", fullVersion()); |
| return null; |
| case "-startup": |
| if (cmdlineStartup != null) { |
| cmderr.printf("Conflicting -startup or -nostartup option.\n"); |
| return null; |
| } |
| if (ai.hasNext()) { |
| String filename = ai.next(); |
| try { |
| byte[] encoded = Files.readAllBytes(Paths.get(filename)); |
| cmdlineStartup = new String(encoded); |
| } catch (AccessDeniedException e) { |
| hard("File '%s' for start-up is not accessible.", filename); |
| } catch (NoSuchFileException e) { |
| hard("File '%s' for start-up is not found.", filename); |
| } catch (Exception e) { |
| hard("Exception while reading start-up file: %s", e); |
| } |
| } else { |
| cmderr.printf("Argument to -startup missing.\n"); |
| return null; |
| } |
| break; |
| case "-nostartup": |
| if (cmdlineStartup != null && !cmdlineStartup.isEmpty()) { |
| cmderr.printf("Conflicting -startup option.\n"); |
| return null; |
| } |
| cmdlineStartup = ""; |
| break; |
| default: |
| cmderr.printf("Unknown option: %s\n", arg); |
| printUsage(); |
| return null; |
| } |
| } else { |
| loadList.add(arg); |
| } |
| } |
| return loadList; |
| } |
| |
| private void printUsage() { |
| cmdout.printf("Usage: jshell <options> <load files>\n"); |
| cmdout.printf("where possible options include:\n"); |
| cmdout.printf(" -classpath <path> Specify where to find user class files\n"); |
| cmdout.printf(" -cp <path> Specify where to find user class files\n"); |
| cmdout.printf(" -startup <file> One run replacement for the start-up definitions\n"); |
| cmdout.printf(" -nostartup Do not run the start-up definitions\n"); |
| cmdout.printf(" -help Print a synopsis of standard options\n"); |
| cmdout.printf(" -version Version information\n"); |
| } |
| |
| private void resetState() { |
| closeState(); |
| |
| // Initialize tool id mapping |
| mainNamespace = new NameSpace("main", ""); |
| startNamespace = new NameSpace("start", "s"); |
| errorNamespace = new NameSpace("error", "e"); |
| mapSnippet = new LinkedHashMap<>(); |
| currentNameSpace = startNamespace; |
| |
| state = JShell.builder() |
| .in(userin) |
| .out(userout) |
| .err(usererr) |
| .tempVariableNameGenerator(()-> "$" + currentNameSpace.tidNext()) |
| .idGenerator((sn, i) -> (currentNameSpace == startNamespace || state.status(sn).isActive) |
| ? currentNameSpace.tid(sn) |
| : errorNamespace.tid(sn)) |
| .build(); |
| analysis = state.sourceCodeAnalysis(); |
| shutdownSubscription = state.onShutdown((JShell deadState) -> { |
| if (deadState == state) { |
| hard("State engine terminated. See /history"); |
| 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>")) { |
| start = DEFAULT_STARTUP; |
| PREFS.put(STARTUP_KEY, DEFAULT_STARTUP); |
| } |
| } else { |
| start = cmdlineStartup; |
| } |
| try (IOContext suin = new FileScannerIOContext(new StringReader(start))) { |
| run(suin); |
| } catch (Exception ex) { |
| hard("Unexpected exception reading start-up: %s\n", ex); |
| } |
| currentNameSpace = mainNamespace; |
| } |
| |
| private void closeState() { |
| live = false; |
| JShell oldState = state; |
| if (oldState != null) { |
| oldState.unsubscribe(shutdownSubscription); // No notification |
| oldState.close(); |
| } |
| } |
| |
| /** |
| * Main loop |
| * @param in the line input/editing context |
| */ |
| private void run(IOContext in) { |
| IOContext oldInput = input; |
| input = in; |
| try { |
| String incomplete = ""; |
| while (live) { |
| String prompt; |
| if (in.interactiveOutput() && displayPrompt) { |
| prompt = testPrompt |
| ? incomplete.isEmpty() |
| ? "\u0005" //ENQ |
| : "\u0006" //ACK |
| : incomplete.isEmpty() |
| ? feedback() == Feedback.Concise |
| ? "-> " |
| : "\n-> " |
| : ">> " |
| ; |
| } else { |
| prompt = ""; |
| } |
| String raw; |
| try { |
| raw = in.readLine(prompt, incomplete); |
| } catch (InputInterruptedException ex) { |
| //input interrupted - clearing current state |
| incomplete = ""; |
| continue; |
| } |
| if (raw == null) { |
| //EOF |
| if (in.interactiveOutput()) { |
| // End after user ctrl-D |
| regenerateOnDeath = false; |
| } |
| break; |
| } |
| String trimmed = trimEnd(raw); |
| if (!trimmed.isEmpty()) { |
| String line = incomplete + trimmed; |
| |
| // No commands in the middle of unprocessed source |
| if (incomplete.isEmpty() && line.startsWith("/") && !line.startsWith("//") && !line.startsWith("/*")) { |
| processCommand(line.trim()); |
| } else { |
| incomplete = processSourceCatchingReset(line); |
| } |
| } |
| } |
| } catch (IOException ex) { |
| hard("Unexpected exception: %s\n", ex); |
| } finally { |
| input = oldInput; |
| } |
| } |
| |
| private String processSourceCatchingReset(String src) { |
| try { |
| input.beforeUserCode(); |
| return processSource(src); |
| } catch (IllegalStateException ex) { |
| hard("Resetting..."); |
| live = false; // Make double sure |
| return ""; |
| } finally { |
| input.afterUserCode(); |
| } |
| } |
| |
| private void processCommand(String cmd) { |
| try { |
| //handle "/[number]" |
| cmdUseHistoryEntry(Integer.parseInt(cmd.substring(1))); |
| return ; |
| } catch (NumberFormatException ex) { |
| //ignore |
| } |
| String arg = ""; |
| int idx = cmd.indexOf(' '); |
| if (idx > 0) { |
| arg = cmd.substring(idx + 1).trim(); |
| cmd = cmd.substring(0, idx); |
| } |
| Command command = commands.get(cmd); |
| if (command == null || command.kind == CommandKind.HELP_ONLY) { |
| hard("No such command: %s", cmd); |
| fluff("Type /help for help."); |
| } else { |
| command.run.accept(arg); |
| } |
| } |
| |
| private static Path toPathResolvingUserHome(String pathString) { |
| if (pathString.replace(File.separatorChar, '/').startsWith("~/")) |
| return Paths.get(System.getProperty("user.home"), pathString.substring(2)); |
| else |
| return Paths.get(pathString); |
| } |
| |
| static final class Command { |
| public final String[] aliases; |
| public final String params; |
| public final String description; |
| public final Consumer<String> run; |
| public final CompletionProvider completions; |
| public final CommandKind kind; |
| |
| public Command(String command, String alias, String params, String description, Consumer<String> run, CompletionProvider completions) { |
| this(command, alias, params, description, run, completions, CommandKind.NORMAL); |
| } |
| |
| public Command(String command, String alias, String params, String description, Consumer<String> run, CompletionProvider completions, CommandKind kind) { |
| this.aliases = alias != null ? new String[] {command, alias} : new String[] {command}; |
| this.params = params; |
| this.description = description; |
| this.run = run; |
| this.completions = completions; |
| this.kind = kind; |
| } |
| |
| } |
| |
| interface CompletionProvider { |
| List<Suggestion> completionSuggestions(String input, int cursor, int[] anchor); |
| } |
| |
| enum CommandKind { |
| NORMAL, |
| HIDDEN, |
| HELP_ONLY; |
| } |
| |
| static final class FixedCompletionProvider implements CompletionProvider { |
| |
| private final String[] alternatives; |
| |
| public FixedCompletionProvider(String... alternatives) { |
| this.alternatives = alternatives; |
| } |
| |
| @Override |
| public List<Suggestion> completionSuggestions(String input, int cursor, int[] anchor) { |
| List<Suggestion> result = new ArrayList<>(); |
| |
| for (String alternative : alternatives) { |
| if (alternative.startsWith(input)) { |
| result.add(new Suggestion(alternative, false)); |
| } |
| } |
| |
| anchor[0] = 0; |
| |
| return result; |
| } |
| |
| } |
| |
| private static final CompletionProvider EMPTY_COMPLETION_PROVIDER = new FixedCompletionProvider(); |
| private static final CompletionProvider FILE_COMPLETION_PROVIDER = fileCompletions(p -> true); |
| private final Map<String, Command> commands = new LinkedHashMap<>(); |
| private void registerCommand(Command cmd) { |
| for (String str : cmd.aliases) { |
| commands.put(str, cmd); |
| } |
| } |
| private static CompletionProvider fileCompletions(Predicate<Path> accept) { |
| return (code, cursor, anchor) -> { |
| int lastSlash = code.lastIndexOf('/'); |
| String path = code.substring(0, lastSlash + 1); |
| String prefix = lastSlash != (-1) ? code.substring(lastSlash + 1) : code; |
| Path current = toPathResolvingUserHome(path); |
| List<Suggestion> result = new ArrayList<>(); |
| try (Stream<Path> dir = Files.list(current)) { |
| dir.filter(f -> accept.test(f) && f.getFileName().toString().startsWith(prefix)) |
| .map(f -> new Suggestion(f.getFileName() + (Files.isDirectory(f) ? "/" : ""), false)) |
| .forEach(result::add); |
| } catch (IOException ex) { |
| //ignore... |
| } |
| if (path.isEmpty()) { |
| StreamSupport.stream(FileSystems.getDefault().getRootDirectories().spliterator(), false) |
| .filter(root -> accept.test(root) && root.toString().startsWith(prefix)) |
| .map(root -> new Suggestion(root.toString(), false)) |
| .forEach(result::add); |
| } |
| anchor[0] = path.length(); |
| return result; |
| }; |
| } |
| |
| private static CompletionProvider classPathCompletion() { |
| return fileCompletions(p -> Files.isDirectory(p) || |
| p.getFileName().toString().endsWith(".zip") || |
| p.getFileName().toString().endsWith(".jar")); |
| } |
| |
| private CompletionProvider editCompletion() { |
| return (prefix, cursor, anchor) -> { |
| anchor[0] = 0; |
| return state.snippets() |
| .stream() |
| .flatMap(k -> (k instanceof DeclarationSnippet) |
| ? Stream.of(String.valueOf(k.id()), ((DeclarationSnippet) k).name()) |
| : Stream.of(String.valueOf(k.id()))) |
| .filter(k -> k.startsWith(prefix)) |
| .map(k -> new Suggestion(k, false)) |
| .collect(Collectors.toList()); |
| }; |
| } |
| |
| private static CompletionProvider saveCompletion() { |
| CompletionProvider keyCompletion = new FixedCompletionProvider("all ", "history "); |
| return (code, cursor, anchor) -> { |
| List<Suggestion> result = new ArrayList<>(); |
| int space = code.indexOf(' '); |
| if (space == (-1)) { |
| result.addAll(keyCompletion.completionSuggestions(code, cursor, anchor)); |
| } |
| result.addAll(FILE_COMPLETION_PROVIDER.completionSuggestions(code.substring(space + 1), cursor - space - 1, anchor)); |
| anchor[0] += space + 1; |
| return result; |
| }; |
| } |
| |
| // Table of commands -- with command forms, argument kinds, help message, implementation, ... |
| |
| { |
| registerCommand(new Command("/list", "/l", "[all]", "list the source you have typed", |
| arg -> cmdList(arg), |
| new FixedCompletionProvider("all"))); |
| registerCommand(new Command("/seteditor", null, "<executable>", "set the external editor command to use", |
| arg -> cmdSetEditor(arg), |
| EMPTY_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/edit", "/e", "<name or id>", "edit a source entry referenced by name or id", |
| arg -> cmdEdit(arg), |
| editCompletion())); |
| registerCommand(new Command("/drop", "/d", "<name or id>", "delete a source entry referenced by name or id", |
| arg -> cmdDrop(arg), |
| editCompletion())); |
| registerCommand(new Command("/save", "/s", "[all|history] <file>", "save the source you have typed", |
| arg -> cmdSave(arg), |
| saveCompletion())); |
| registerCommand(new Command("/open", "/o", "<file>", "open a file as source input", |
| arg -> cmdOpen(arg), |
| FILE_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/vars", "/v", null, "list the declared variables and their values", |
| arg -> cmdVars(), |
| EMPTY_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/methods", "/m", null, "list the declared methods and their signatures", |
| arg -> cmdMethods(), |
| EMPTY_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/classes", "/c", null, "list the declared classes", |
| arg -> cmdClasses(), |
| EMPTY_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/exit", "/x", null, "exit the REPL", |
| arg -> cmdExit(), |
| EMPTY_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/reset", "/r", null, "reset everything in the REPL", |
| arg -> cmdReset(), |
| EMPTY_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/feedback", "/f", "<level>", "feedback information: off, concise, normal, verbose, default, or ?", |
| arg -> cmdFeedback(arg), |
| new FixedCompletionProvider("off", "concise", "normal", "verbose", "default", "?"))); |
| registerCommand(new Command("/prompt", "/p", null, "toggle display of a prompt", |
| arg -> cmdPrompt(), |
| EMPTY_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/classpath", "/cp", "<path>", "add a path to the classpath", |
| arg -> cmdClasspath(arg), |
| classPathCompletion())); |
| registerCommand(new Command("/history", "/h", null, "history of what you have typed", |
| arg -> cmdHistory(), |
| EMPTY_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/setstart", null, "<file>", "read file and set as the new start-up definitions", |
| arg -> cmdSetStart(arg), |
| FILE_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/savestart", null, "<file>", "save the default start-up definitions to the file", |
| arg -> cmdSaveStart(arg), |
| FILE_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/debug", "/db", "", "toggle debugging of the REPL", |
| arg -> cmdDebug(arg), |
| EMPTY_COMPLETION_PROVIDER, |
| CommandKind.HIDDEN)); |
| registerCommand(new Command("/help", "/?", "", "this help message", |
| arg -> cmdHelp(), |
| EMPTY_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/!", null, "", "re-run last snippet", |
| arg -> cmdUseHistoryEntry(-1), |
| EMPTY_COMPLETION_PROVIDER)); |
| registerCommand(new Command("/<n>", null, "", "re-run n-th snippet", |
| arg -> { throw new IllegalStateException(); }, |
| EMPTY_COMPLETION_PROVIDER, |
| CommandKind.HELP_ONLY)); |
| registerCommand(new Command("/-<n>", null, "", "re-run n-th previous snippet", |
| arg -> { throw new IllegalStateException(); }, |
| EMPTY_COMPLETION_PROVIDER, |
| CommandKind.HELP_ONLY)); |
| } |
| |
| public List<Suggestion> commandCompletionSuggestions(String code, int cursor, int[] anchor) { |
| String prefix = code.substring(0, cursor); |
| int space = prefix.indexOf(' '); |
| Stream<Suggestion> result; |
| |
| if (space == (-1)) { |
| result = commands.values() |
| .stream() |
| .distinct() |
| .filter(cmd -> cmd.kind != CommandKind.HIDDEN && cmd.kind != CommandKind.HELP_ONLY) |
| .map(cmd -> cmd.aliases[0]) |
| .filter(key -> key.startsWith(prefix)) |
| .map(key -> new Suggestion(key + " ", false)); |
| anchor[0] = 0; |
| } else { |
| String arg = prefix.substring(space + 1); |
| String cmd = prefix.substring(0, space); |
| Command command = commands.get(cmd); |
| if (command != null) { |
| result = command.completions.completionSuggestions(arg, cursor - space, anchor).stream(); |
| anchor[0] += space + 1; |
| } else { |
| result = Stream.empty(); |
| } |
| } |
| |
| return result.sorted((s1, s2) -> s1.continuation.compareTo(s2.continuation)) |
| .collect(Collectors.toList()); |
| } |
| |
| public String commandDocumentation(String code, int cursor) { |
| code = code.substring(0, cursor); |
| int space = code.indexOf(' '); |
| |
| if (space != (-1)) { |
| String cmd = code.substring(0, space); |
| Command command = commands.get(cmd); |
| if (command != null) { |
| return command.description; |
| } |
| } |
| |
| return null; |
| } |
| |
| // --- Command implementations --- |
| |
| void cmdSetEditor(String arg) { |
| if (arg.isEmpty()) { |
| hard("/seteditor requires a path argument"); |
| } else { |
| editor = arg; |
| fluff("Editor set to: %s", arg); |
| } |
| } |
| |
| void cmdClasspath(String arg) { |
| if (arg.isEmpty()) { |
| hard("/classpath requires a path argument"); |
| } else { |
| state.addToClasspath(toPathResolvingUserHome(arg).toString()); |
| fluff("Path %s added to classpath", arg); |
| } |
| } |
| |
| void cmdDebug(String arg) { |
| if (arg.isEmpty()) { |
| debug = !debug; |
| InternalDebugControl.setDebugFlags(state, debug ? InternalDebugControl.DBG_GEN : 0); |
| fluff("Debugging %s", debug ? "on" : "off"); |
| } else { |
| int flags = 0; |
| for (char ch : arg.toCharArray()) { |
| switch (ch) { |
| case '0': |
| flags = 0; |
| debug = false; |
| fluff("Debugging off"); |
| break; |
| case 'r': |
| debug = true; |
| fluff("REPL tool debugging on"); |
| break; |
| case 'g': |
| flags |= InternalDebugControl.DBG_GEN; |
| fluff("General debugging on"); |
| break; |
| case 'f': |
| flags |= InternalDebugControl.DBG_FMGR; |
| fluff("File manager debugging on"); |
| break; |
| case 'c': |
| flags |= InternalDebugControl.DBG_COMPA; |
| fluff("Completion analysis debugging on"); |
| break; |
| case 'd': |
| flags |= InternalDebugControl.DBG_DEP; |
| fluff("Dependency debugging on"); |
| break; |
| case 'e': |
| flags |= InternalDebugControl.DBG_EVNT; |
| fluff("Event debugging on"); |
| break; |
| default: |
| hard("Unknown debugging option: %c", ch); |
| fluff("Use: 0 r g f c d"); |
| break; |
| } |
| } |
| InternalDebugControl.setDebugFlags(state, flags); |
| } |
| } |
| |
| private void cmdExit() { |
| regenerateOnDeath = false; |
| live = false; |
| fluff("Goodbye\n"); |
| } |
| |
| private void cmdFeedback(String arg) { |
| switch (arg) { |
| case "": |
| case "d": |
| case "default": |
| feedback = Feedback.Default; |
| break; |
| case "o": |
| case "off": |
| feedback = Feedback.Off; |
| break; |
| case "c": |
| case "concise": |
| feedback = Feedback.Concise; |
| break; |
| case "n": |
| case "normal": |
| feedback = Feedback.Normal; |
| break; |
| case "v": |
| case "verbose": |
| feedback = Feedback.Verbose; |
| break; |
| default: |
| hard("Follow /feedback with of the following:"); |
| hard(" off (errors and critical output only)"); |
| hard(" concise"); |
| 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; |
| } |
| fluff("Feedback mode: %s", feedback.name().toLowerCase()); |
| } |
| |
| void cmdHelp() { |
| int synopsisLen = 0; |
| Map<String, String> synopsis2Description = new LinkedHashMap<>(); |
| for (Command cmd : new LinkedHashSet<>(commands.values())) { |
| if (cmd.kind == CommandKind.HIDDEN) |
| continue; |
| StringBuilder synopsis = new StringBuilder(); |
| if (cmd.aliases.length > 1) { |
| synopsis.append(String.format("%-3s or ", cmd.aliases[1])); |
| } else { |
| synopsis.append(" "); |
| } |
| synopsis.append(cmd.aliases[0]); |
| if (cmd.params != null) |
| synopsis.append(" ").append(cmd.params); |
| synopsis2Description.put(synopsis.toString(), cmd.description); |
| synopsisLen = Math.max(synopsisLen, synopsis.length()); |
| } |
| cmdout.println("Type a Java language expression, statement, or declaration."); |
| cmdout.println("Or type one of the following commands:\n"); |
| for (Entry<String, String> e : synopsis2Description.entrySet()) { |
| cmdout.print(String.format("%-" + synopsisLen + "s", e.getKey())); |
| cmdout.print(" -- "); |
| cmdout.println(e.getValue()); |
| } |
| 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"); |
| } |
| |
| private void cmdHistory() { |
| cmdout.println(); |
| for (String s : input.currentSessionHistory()) { |
| // No number prefix, confusing with snippet ids |
| cmdout.printf("%s\n", s); |
| } |
| } |
| |
| /** |
| * Convert a user argument to a list of snippets referenced by that |
| * argument (or lack of argument). |
| * @param arg The user's argument to the command |
| * @return a list of referenced snippets |
| */ |
| private List<Snippet> argToSnippets(String arg) { |
| List<Snippet> snippets = new ArrayList<>(); |
| if (arg.isEmpty()) { |
| // Default is all user snippets |
| for (Snippet sn : state.snippets()) { |
| if (notInStartUp(sn)) { |
| snippets.add(sn); |
| } |
| } |
| } else { |
| // Look for all declarations with matching names |
| for (Snippet key : state.snippets()) { |
| switch (key.kind()) { |
| case METHOD: |
| case VAR: |
| case TYPE_DECL: |
| if (((DeclarationSnippet) key).name().equals(arg)) { |
| snippets.add(key); |
| } |
| break; |
| } |
| } |
| // If no declarations found, look for an id of this name |
| if (snippets.isEmpty()) { |
| for (Snippet sn : state.snippets()) { |
| if (sn.id().equals(arg)) { |
| snippets.add(sn); |
| break; |
| } |
| } |
| } |
| // If still no matches found, give an error |
| if (snippets.isEmpty()) { |
| hard("No definition or id named %s found. See /classes /methods /vars or /list", arg); |
| return null; |
| } |
| } |
| return snippets; |
| } |
| |
| private void 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; |
| } |
| List<Snippet> snippetSet = argToSnippets(arg); |
| if (snippetSet == null) { |
| return; |
| } |
| snippetSet = snippetSet.stream() |
| .filter(sn -> state.status(sn).isActive) |
| .collect(toList()); |
| snippetSet.removeIf(sn -> !(sn instanceof PersistentSnippet)); |
| if (snippetSet.isEmpty()) { |
| hard("The argument did not specify an import, variable, method, or class to drop."); |
| return; |
| } |
| if (snippetSet.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 : snippetSet) { |
| cmdout.printf("%4s : %s\n", sn.id(), sn.source().replace("\n", "\n ")); |
| } |
| return; |
| } |
| PersistentSnippet psn = (PersistentSnippet) snippetSet.iterator().next(); |
| state.drop(psn).forEach(this::handleEvent); |
| } |
| |
| private void cmdEdit(String arg) { |
| List<Snippet> snippetSet = argToSnippets(arg); |
| if (snippetSet == null) { |
| return; |
| } |
| Set<String> srcSet = new LinkedHashSet<>(); |
| for (Snippet key : snippetSet) { |
| String src = key.source(); |
| switch (key.subKind()) { |
| case VAR_VALUE_SUBKIND: |
| break; |
| case ASSIGNMENT_SUBKIND: |
| case OTHER_EXPRESSION_SUBKIND: |
| case TEMP_VAR_EXPRESSION_SUBKIND: |
| if (!src.endsWith(";")) { |
| src = src + ";"; |
| } |
| srcSet.add(src); |
| break; |
| default: |
| srcSet.add(src); |
| break; |
| } |
| } |
| StringBuilder sb = new StringBuilder(); |
| for (String s : srcSet) { |
| sb.append(s); |
| 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) { |
| EditPad.edit(errorHandler, src, saveHandler); |
| } else { |
| ExternalEditor.edit(editor, errorHandler, src, saveHandler, input); |
| } |
| } |
| //where |
| // receives editor requests to save |
| private class SaveHandler implements Consumer<String> { |
| |
| String src; |
| Set<String> currSrcs; |
| |
| SaveHandler(String src, Set<String> ss) { |
| this.src = src; |
| this.currSrcs = ss; |
| } |
| |
| @Override |
| public void accept(String s) { |
| if (!s.equals(src)) { // quick check first |
| src = s; |
| try { |
| Set<String> nextSrcs = new LinkedHashSet<>(); |
| boolean failed = false; |
| while (true) { |
| CompletionInfo an = analysis.analyzeCompletion(s); |
| if (!an.completeness.isComplete) { |
| break; |
| } |
| String tsrc = trimNewlines(an.source); |
| if (!failed && !currSrcs.contains(tsrc)) { |
| failed = processCompleteSource(tsrc); |
| } |
| nextSrcs.add(tsrc); |
| if (an.remaining.isEmpty()) { |
| break; |
| } |
| s = an.remaining; |
| } |
| currSrcs = nextSrcs; |
| } catch (IllegalStateException ex) { |
| hard("Resetting..."); |
| resetState(); |
| currSrcs = new LinkedHashSet<>(); // re-process everything |
| } |
| } |
| } |
| |
| private String trimNewlines(String s) { |
| int b = 0; |
| while (b < s.length() && s.charAt(b) == '\n') { |
| ++b; |
| } |
| int e = s.length() -1; |
| while (e >= 0 && s.charAt(e) == '\n') { |
| --e; |
| } |
| return s.substring(b, e + 1); |
| } |
| } |
| |
| private void cmdList(String arg) { |
| boolean all = false; |
| switch (arg) { |
| case "all": |
| all = true; |
| break; |
| case "history": |
| cmdHistory(); |
| return; |
| case "": |
| break; |
| default: |
| hard("Invalid /list argument: %s", arg); |
| return; |
| } |
| boolean hasOutput = false; |
| for (Snippet sn : state.snippets()) { |
| if (all || (notInStartUp(sn) && state.status(sn).isActive)) { |
| if (!hasOutput) { |
| cmdout.println(); |
| hasOutput = true; |
| } |
| cmdout.printf("%4s : %s\n", sn.id(), sn.source().replace("\n", "\n ")); |
| |
| } |
| } |
| } |
| |
| private void cmdOpen(String filename) { |
| if (filename.isEmpty()) { |
| hard("The /open command requires a filename argument."); |
| } else { |
| try { |
| run(new FileScannerIOContext(toPathResolvingUserHome(filename).toString())); |
| } catch (FileNotFoundException e) { |
| hard("File '%s' is not found: %s", filename, e.getMessage()); |
| } catch (Exception e) { |
| hard("Exception while reading file: %s", e); |
| } |
| } |
| } |
| |
| private void cmdPrompt() { |
| displayPrompt = !displayPrompt; |
| fluff("Prompt will %sdisplay. Use /prompt to toggle.", displayPrompt ? "" : "NOT "); |
| concise("Prompt: %s", displayPrompt ? "on" : "off"); |
| } |
| |
| private void cmdReset() { |
| live = false; |
| fluff("Resetting state."); |
| } |
| |
| private void cmdSave(String arg_filename) { |
| Matcher mat = HISTORY_ALL_FILENAME.matcher(arg_filename); |
| if (!mat.find()) { |
| hard("Malformed argument to the /save command: %s", arg_filename); |
| return; |
| } |
| boolean useHistory = false; |
| boolean saveAll = false; |
| String cmd = mat.group("cmd"); |
| if (cmd != null) switch (cmd) { |
| case "all": |
| saveAll = true; |
| break; |
| case "history": |
| useHistory = true; |
| break; |
| } |
| String filename = mat.group("filename"); |
| if (filename == null ||filename.isEmpty()) { |
| hard("The /save command requires a filename argument."); |
| return; |
| } |
| try (BufferedWriter writer = Files.newBufferedWriter(toPathResolvingUserHome(filename), |
| Charset.defaultCharset(), |
| CREATE, TRUNCATE_EXISTING, WRITE)) { |
| if (useHistory) { |
| for (String s : input.currentSessionHistory()) { |
| writer.write(s); |
| writer.write("\n"); |
| } |
| } else { |
| for (Snippet sn : state.snippets()) { |
| if (saveAll || notInStartUp(sn)) { |
| writer.write(sn.source()); |
| writer.write("\n"); |
| } |
| } |
| } |
| } catch (FileNotFoundException e) { |
| hard("File '%s' for save is not accessible: %s", filename, e.getMessage()); |
| } catch (Exception e) { |
| hard("Exception while saving: %s", e); |
| } |
| } |
| |
| private void 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); |
| } catch (NoSuchFileException e) { |
| hard("File '%s' for /setstart is not found.", filename); |
| } catch (Exception e) { |
| hard("Exception while reading start set file: %s", e); |
| } |
| } |
| } |
| |
| private void cmdSaveStart(String filename) { |
| if (filename.isEmpty()) { |
| hard("The /savestart command requires a filename argument."); |
| } else { |
| try { |
| Files.write(toPathResolvingUserHome(filename), DEFAULT_STARTUP.getBytes()); |
| } catch (AccessDeniedException e) { |
| hard("File '%s' for /savestart is not accessible.", filename); |
| } catch (NoSuchFileException e) { |
| hard("File '%s' for /savestart cannot be located.", filename); |
| } catch (Exception e) { |
| hard("Exception while saving default startup file: %s", e); |
| } |
| } |
| } |
| |
| private void 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); |
| } |
| } |
| |
| private void cmdMethods() { |
| for (MethodSnippet mk : state.methods()) { |
| hard(" %s %s", mk.name(), mk.signature()); |
| } |
| } |
| |
| private void cmdClasses() { |
| for (TypeDeclSnippet ck : state.types()) { |
| String kind; |
| switch (ck.subKind()) { |
| case INTERFACE_SUBKIND: |
| kind = "interface"; |
| break; |
| case CLASS_SUBKIND: |
| kind = "class"; |
| break; |
| case ENUM_SUBKIND: |
| kind = "enum"; |
| break; |
| case ANNOTATION_TYPE_SUBKIND: |
| kind = "@interface"; |
| break; |
| default: |
| assert false : "Wrong kind" + ck.subKind(); |
| kind = "class"; |
| break; |
| } |
| hard(" %s %s", kind, ck.name()); |
| } |
| } |
| |
| private void cmdUseHistoryEntry(int index) { |
| List<Snippet> keys = state.snippets(); |
| if (index < 0) |
| index += keys.size(); |
| else |
| index--; |
| if (index >= 0 && index < keys.size()) { |
| String source = keys.get(index).source(); |
| cmdout.printf("%s\n", source); |
| input.replaceLastHistoryEntry(source); |
| processSourceCatchingReset(source); |
| } else { |
| hard("Cannot find snippet %d", index + 1); |
| } |
| } |
| |
| /** |
| * Filter diagnostics for only errors (no warnings, ...) |
| * @param diagnostics input list |
| * @return filtered list |
| */ |
| List<Diag> errorsOnly(List<Diag> diagnostics) { |
| return diagnostics.stream() |
| .filter(d -> d.isError()) |
| .collect(toList()); |
| } |
| |
| void printDiagnostics(String source, List<Diag> diagnostics, boolean embed) { |
| String padding = embed? " " : ""; |
| for (Diag diag : diagnostics) { |
| //assert diag.getSource().equals(source); |
| |
| if (!embed) { |
| if (diag.isError()) { |
| hard("Error:"); |
| } else { |
| hard("Warning:"); |
| } |
| } |
| |
| for (String line : diag.getMessage(null).split("\\r?\\n")) { |
| if (!line.trim().startsWith("location:")) { |
| hard("%s%s", padding, line); |
| } |
| } |
| |
| int pstart = (int) diag.getStartPosition(); |
| int pend = (int) diag.getEndPosition(); |
| Matcher m = LINEBREAK.matcher(source); |
| int pstartl = 0; |
| int pendl = -2; |
| while (m.find(pstartl)) { |
| pendl = m.start(); |
| if (pendl >= pstart) { |
| break; |
| } else { |
| pstartl = m.end(); |
| } |
| } |
| if (pendl < pstart) { |
| pendl = source.length(); |
| } |
| fluff("%s%s", padding, source.substring(pstartl, pendl)); |
| |
| StringBuilder sb = new StringBuilder(); |
| int start = pstart - pstartl; |
| for (int i = 0; i < start; ++i) { |
| sb.append(' '); |
| } |
| sb.append('^'); |
| boolean multiline = pend > pendl; |
| int end = (multiline ? pendl : pend) - pstartl - 1; |
| if (end > start) { |
| for (int i = start + 1; i < end; ++i) { |
| sb.append('-'); |
| } |
| if (multiline) { |
| sb.append("-..."); |
| } else { |
| sb.append('^'); |
| } |
| } |
| fluff("%s%s", padding, sb.toString()); |
| |
| debug("printDiagnostics start-pos = %d ==> %d -- wrap = %s", diag.getStartPosition(), start, this); |
| debug("Code: %s", diag.getCode()); |
| debug("Pos: %d (%d - %d)", diag.getPosition(), |
| diag.getStartPosition(), diag.getEndPosition()); |
| } |
| } |
| |
| private String processSource(String srcInput) throws IllegalStateException { |
| while (true) { |
| CompletionInfo an = analysis.analyzeCompletion(srcInput); |
| if (!an.completeness.isComplete) { |
| return an.remaining; |
| } |
| boolean failed = processCompleteSource(an.source); |
| if (failed || an.remaining.isEmpty()) { |
| return ""; |
| } |
| srcInput = an.remaining; |
| } |
| } |
| //where |
| private boolean processCompleteSource(String source) throws IllegalStateException { |
| debug("Compiling: %s", source); |
| boolean failed = false; |
| List<SnippetEvent> events = state.eval(source); |
| for (SnippetEvent e : events) { |
| failed |= handleEvent(e); |
| } |
| return failed; |
| } |
| |
| private boolean handleEvent(SnippetEvent ste) { |
| Snippet sn = ste.snippet(); |
| if (sn == null) { |
| debug("Event with null key: %s", ste); |
| return false; |
| } |
| List<Diag> diagnostics = state.diagnostics(sn); |
| String source = sn.source(); |
| if (ste.causeSnippet() == null) { |
| // main event |
| printDiagnostics(source, diagnostics, false); |
| if (ste.status().isActive) { |
| if (ste.exception() != null) { |
| if (ste.exception() instanceof EvalException) { |
| printEvalException((EvalException) ste.exception()); |
| return true; |
| } else if (ste.exception() instanceof UnresolvedReferenceException) { |
| printUnresolved((UnresolvedReferenceException) ste.exception()); |
| } else { |
| hard("Unexpected execution exception: %s", ste.exception()); |
| return true; |
| } |
| } else { |
| displayDeclarationAndValue(ste, false, ste.value()); |
| } |
| } else if (ste.status() == Status.REJECTED) { |
| if (diagnostics.isEmpty()) { |
| hard("Failed."); |
| } |
| return true; |
| } |
| } else if (ste.status() == Status.REJECTED) { |
| //TODO -- I don't believe updates can cause failures any more |
| hard("Caused failure of dependent %s --", ((DeclarationSnippet) sn).name()); |
| printDiagnostics(source, diagnostics, true); |
| } else { |
| // Update |
| SubKind subkind = sn.subKind(); |
| if (sn instanceof DeclarationSnippet |
| && (feedback() == Feedback.Verbose |
| || ste.status() == Status.OVERWRITTEN |
| || subkind == SubKind.VAR_DECLARATION_SUBKIND |
| || subkind == SubKind.VAR_DECLARATION_WITH_INITIALIZER_SUBKIND)) { |
| // Under the conditions, display update information |
| displayDeclarationAndValue(ste, true, null); |
| List<Diag> other = errorsOnly(diagnostics); |
| if (other.size() > 0) { |
| printDiagnostics(source, other, true); |
| } |
| } |
| } |
| return false; |
| } |
| |
| @SuppressWarnings("fallthrough") |
| private void displayDeclarationAndValue(SnippetEvent ste, boolean update, String value) { |
| Snippet key = ste.snippet(); |
| String declared; |
| Status status = ste.status(); |
| switch (status) { |
| case VALID: |
| case RECOVERABLE_DEFINED: |
| case RECOVERABLE_NOT_DEFINED: |
| if (ste.previousStatus().isActive) { |
| declared = ste.isSignatureChange() |
| ? "Replaced" |
| : "Modified"; |
| } else { |
| declared = "Added"; |
| } |
| break; |
| case OVERWRITTEN: |
| declared = "Overwrote"; |
| break; |
| case DROPPED: |
| declared = "Dropped"; |
| break; |
| case REJECTED: |
| declared = "Rejected"; |
| break; |
| case NONEXISTENT: |
| default: |
| // Should not occur |
| declared = ste.previousStatus().toString() + "=>" + status.toString(); |
| } |
| if (update) { |
| declared = " Update " + declared.toLowerCase(); |
| } |
| String however; |
| if (key instanceof DeclarationSnippet && (status == Status.RECOVERABLE_DEFINED || status == Status.RECOVERABLE_NOT_DEFINED)) { |
| String cannotUntil = (status == Status.RECOVERABLE_NOT_DEFINED) |
| ? " cannot be referenced until" |
| : " cannot be invoked until"; |
| however = (update? " which" : ", however, it") + cannotUntil + unresolved((DeclarationSnippet) key); |
| } else { |
| however = ""; |
| } |
| switch (key.subKind()) { |
| case CLASS_SUBKIND: |
| fluff("%s class %s%s", declared, ((TypeDeclSnippet) key).name(), however); |
| break; |
| case INTERFACE_SUBKIND: |
| fluff("%s interface %s%s", declared, ((TypeDeclSnippet) key).name(), however); |
| break; |
| case ENUM_SUBKIND: |
| fluff("%s enum %s%s", declared, ((TypeDeclSnippet) key).name(), however); |
| break; |
| case ANNOTATION_TYPE_SUBKIND: |
| fluff("%s annotation interface %s%s", declared, ((TypeDeclSnippet) key).name(), however); |
| break; |
| case METHOD_SUBKIND: |
| fluff("%s method %s(%s)%s", declared, ((MethodSnippet) key).name(), |
| ((MethodSnippet) key).parameterTypes(), however); |
| break; |
| case VAR_DECLARATION_SUBKIND: |
| if (!update) { |
| VarSnippet vk = (VarSnippet) key; |
| if (status == Status.RECOVERABLE_NOT_DEFINED) { |
| fluff("%s variable %s%s", declared, vk.name(), however); |
| } else { |
| fluff("%s variable %s of type %s%s", declared, vk.name(), vk.typeName(), however); |
| } |
| break; |
| } |
| // Fall through |
| case VAR_DECLARATION_WITH_INITIALIZER_SUBKIND: { |
| VarSnippet vk = (VarSnippet) key; |
| if (status == Status.RECOVERABLE_NOT_DEFINED) { |
| if (!update) { |
| fluff("%s variable %s%s", declared, vk.name(), however); |
| break; |
| } |
| } else if (update) { |
| if (ste.isSignatureChange()) { |
| hard("%s variable %s, reset to null", declared, vk.name()); |
| } |
| } else { |
| fluff("%s variable %s of type %s with initial value %s", |
| declared, vk.name(), vk.typeName(), value); |
| concise("%s : %s", vk.name(), value); |
| } |
| break; |
| } |
| case TEMP_VAR_EXPRESSION_SUBKIND: { |
| VarSnippet vk = (VarSnippet) key; |
| if (update) { |
| hard("%s temporary variable %s, reset to null", declared, vk.name()); |
| } else { |
| fluff("Expression value is: %s", (value)); |
| fluff(" assigned to temporary variable %s of type %s", vk.name(), vk.typeName()); |
| concise("%s : %s", vk.name(), value); |
| } |
| break; |
| } |
| case OTHER_EXPRESSION_SUBKIND: |
| fluff("Expression value is: %s", (value)); |
| break; |
| case VAR_VALUE_SUBKIND: { |
| ExpressionSnippet ek = (ExpressionSnippet) key; |
| fluff("Variable %s of type %s has value %s", ek.name(), ek.typeName(), (value)); |
| concise("%s : %s", ek.name(), value); |
| break; |
| } |
| case ASSIGNMENT_SUBKIND: { |
| ExpressionSnippet ek = (ExpressionSnippet) key; |
| fluff("Variable %s has been assigned the value %s", ek.name(), (value)); |
| concise("%s : %s", ek.name(), value); |
| break; |
| } |
| } |
| } |
| //where |
| void printStackTrace(StackTraceElement[] stes) { |
| for (StackTraceElement ste : stes) { |
| StringBuilder sb = new StringBuilder(); |
| String cn = ste.getClassName(); |
| if (!cn.isEmpty()) { |
| int dot = cn.lastIndexOf('.'); |
| if (dot > 0) { |
| sb.append(cn.substring(dot + 1)); |
| } else { |
| sb.append(cn); |
| } |
| sb.append("."); |
| } |
| if (!ste.getMethodName().isEmpty()) { |
| sb.append(ste.getMethodName()); |
| sb.append(" "); |
| } |
| String fileName = ste.getFileName(); |
| int lineNumber = ste.getLineNumber(); |
| String loc = ste.isNativeMethod() |
| ? "Native Method" |
| : fileName == null |
| ? "Unknown Source" |
| : lineNumber >= 0 |
| ? fileName + ":" + lineNumber |
| : fileName; |
| hard(" at %s(%s)", sb, loc); |
| |
| } |
| } |
| //where |
| void printUnresolved(UnresolvedReferenceException ex) { |
| MethodSnippet corralled = ex.getMethodSnippet(); |
| List<Diag> otherErrors = errorsOnly(state.diagnostics(corralled)); |
| StringBuilder sb = new StringBuilder(); |
| if (otherErrors.size() > 0) { |
| if (state.unresolvedDependencies(corralled).size() > 0) { |
| sb.append(" and"); |
| } |
| if (otherErrors.size() == 1) { |
| sb.append(" this error is addressed --"); |
| } else { |
| sb.append(" these errors are addressed --"); |
| } |
| } else { |
| sb.append("."); |
| } |
| |
| hard("Attempted to call %s which cannot be invoked until%s", corralled.name(), |
| unresolved(corralled), sb.toString()); |
| if (otherErrors.size() > 0) { |
| printDiagnostics(corralled.source(), otherErrors, true); |
| } |
| } |
| //where |
| void printEvalException(EvalException ex) { |
| if (ex.getMessage() == null) { |
| hard("%s thrown", ex.getExceptionClassName()); |
| } else { |
| hard("%s thrown: %s", ex.getExceptionClassName(), ex.getMessage()); |
| } |
| printStackTrace(ex.getStackTrace()); |
| } |
| //where |
| String unresolved(DeclarationSnippet key) { |
| List<String> unr = state.unresolvedDependencies(key); |
| StringBuilder sb = new StringBuilder(); |
| int fromLast = unr.size(); |
| if (fromLast > 0) { |
| sb.append(" "); |
| } |
| for (String u : unr) { |
| --fromLast; |
| sb.append(u); |
| if (fromLast == 0) { |
| // No suffix |
| } else if (fromLast == 1) { |
| sb.append(", and "); |
| } else { |
| sb.append(", "); |
| } |
| } |
| switch (unr.size()) { |
| case 0: |
| break; |
| case 1: |
| sb.append(" is declared"); |
| break; |
| default: |
| sb.append(" are declared"); |
| break; |
| } |
| return sb.toString(); |
| } |
| |
| enum Feedback { |
| Default, |
| Off, |
| Concise, |
| Normal, |
| Verbose |
| } |
| |
| Feedback feedback() { |
| if (feedback == Feedback.Default) { |
| return input == null || input.interactiveOutput() ? Feedback.Normal : Feedback.Off; |
| } |
| return feedback; |
| } |
| |
| boolean notInStartUp(Snippet sn) { |
| return mapSnippet.get(sn).space != startNamespace; |
| } |
| |
| /** The current version number as a string. |
| */ |
| static String version() { |
| return version("release"); // mm.nn.oo[-milestone] |
| } |
| |
| /** The current full version number as a string. |
| */ |
| static String fullVersion() { |
| return version("full"); // mm.mm.oo[-milestone]-build |
| } |
| |
| private static final String versionRBName = "jdk.internal.jshell.tool.resources.version"; |
| private static ResourceBundle versionRB; |
| |
| private static String version(String key) { |
| if (versionRB == null) { |
| try { |
| versionRB = ResourceBundle.getBundle(versionRBName); |
| } catch (MissingResourceException e) { |
| return "(version info not available)"; |
| } |
| } |
| try { |
| return versionRB.getString(key); |
| } |
| catch (MissingResourceException e) { |
| return "(version info not available)"; |
| } |
| } |
| |
| class NameSpace { |
| final String spaceName; |
| final String prefix; |
| private int nextNum; |
| |
| NameSpace(String spaceName, String prefix) { |
| this.spaceName = spaceName; |
| this.prefix = prefix; |
| this.nextNum = 1; |
| } |
| |
| String tid(Snippet sn) { |
| String tid = prefix + nextNum++; |
| mapSnippet.put(sn, new SnippetInfo(sn, this, tid)); |
| return tid; |
| } |
| |
| String tidNext() { |
| return prefix + nextNum; |
| } |
| } |
| |
| static class SnippetInfo { |
| final Snippet snippet; |
| final NameSpace space; |
| final String tid; |
| |
| SnippetInfo(Snippet snippet, NameSpace space, String tid) { |
| this.snippet = snippet; |
| this.space = space; |
| this.tid = tid; |
| } |
| } |
| } |
| |
| class ScannerIOContext extends IOContext { |
| |
| private final Scanner scannerIn; |
| private final PrintStream pStream; |
| |
| 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() { |
| return true; |
| } |
| |
| @Override |
| public Iterable<String> currentSessionHistory() { |
| return Collections.emptyList(); |
| } |
| |
| @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; |
| } |
| } |
| |
