/*
* Copyright (c) 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.jshell;
import jdk.jshell.spi.ExecutionControl;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.io.PrintStream;
import java.net.InetAddress;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.Objects;
import java.util.ResourceBundle;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Stream;
import jdk.internal.jshell.debug.InternalDebugControl;
import jdk.jshell.Snippet.Status;
import jdk.jshell.execution.JdiDefaultExecutionControl;
import jdk.jshell.spi.ExecutionControl.EngineTerminationException;
import jdk.jshell.spi.ExecutionControl.ExecutionControlException;
import jdk.jshell.spi.ExecutionEnv;
import static jdk.jshell.execution.Util.failOverExecutionControlGenerator;
import static jdk.jshell.Util.expunge;
/**
* The JShell evaluation state engine. This is the central class in the JShell
* API. A {@code JShell} instance holds the evolving compilation and
* execution state. The state is changed with the instance methods
* {@link jdk.jshell.JShell#eval(java.lang.String) eval(String)},
* {@link jdk.jshell.JShell#drop(jdk.jshell.Snippet) drop(Snippet)} and
* {@link jdk.jshell.JShell#addToClasspath(java.lang.String) addToClasspath(String)}.
* The majority of methods query the state.
* A {@code JShell} instance also allows registering for events with
* {@link jdk.jshell.JShell#onSnippetEvent(java.util.function.Consumer) onSnippetEvent(Consumer)}
* and {@link jdk.jshell.JShell#onShutdown(java.util.function.Consumer) onShutdown(Consumer)}, which
* are unregistered with
* {@link jdk.jshell.JShell#unsubscribe(jdk.jshell.JShell.Subscription) unsubscribe(Subscription)}.
* Access to the source analysis utilities is via
* {@link jdk.jshell.JShell#sourceCodeAnalysis()}.
* When complete the instance should be closed to free resources --
* {@link jdk.jshell.JShell#close()}.
* <p>
* An instance of {@code JShell} is created with
* {@code JShell.create()}.
* <p>
* This class is not thread safe, except as noted, all access should be through
* a single thread.
* @author Robert Field
*/
public class JShell implements AutoCloseable {
final SnippetMaps maps;
final KeyMap keyMap;
final OuterWrapMap outerMap;
final TaskFactory taskFactory;
final InputStream in;
final PrintStream out;
final PrintStream err;
final Supplier<String> tempVariableNameGenerator;
final BiFunction<Snippet, Integer, String> idGenerator;
final List<String> extraRemoteVMOptions;
final List<String> extraCompilerOptions;
private int nextKeyIndex = 1;
final Eval eval;
final ClassTracker classTracker;
private final Map<Subscription, Consumer<JShell>> shutdownListeners = new HashMap<>();
private final Map<Subscription, Consumer<SnippetEvent>> keyStatusListeners = new HashMap<>();
private boolean closed = false;
private final ExecutionControl executionControl;
private SourceCodeAnalysisImpl sourceCodeAnalysis = null;
private static final String L10N_RB_NAME = "jdk.jshell.resources.l10n";
private static ResourceBundle outputRB = null;
JShell(Builder b) throws IllegalStateException {
this.in = b.in;
this.out = b.out;
this.err = b.err;
this.tempVariableNameGenerator = b.tempVariableNameGenerator;
this.idGenerator = b.idGenerator;
this.extraRemoteVMOptions = b.extraRemoteVMOptions;
this.extraCompilerOptions = b.extraCompilerOptions;
ExecutionControl.Generator executionControlGenerator = b.executionControlGenerator==null
? failOverExecutionControlGenerator(
JdiDefaultExecutionControl.listen(InetAddress.getLoopbackAddress().getHostAddress()),
JdiDefaultExecutionControl.launch(),
JdiDefaultExecutionControl.listen(null)
)
: b.executionControlGenerator;
try {
executionControl = executionControlGenerator.generate(new ExecutionEnvImpl());
} catch (Throwable ex) {
throw new IllegalStateException("Launching JShell execution engine threw: " + ex.getMessage(), ex);
}
this.maps = new SnippetMaps(this);
this.keyMap = new KeyMap(this);
this.outerMap = new OuterWrapMap(this);
this.taskFactory = new TaskFactory(this);
this.eval = new Eval(this);
this.classTracker = new ClassTracker();
}
/**
* Builder for {@code JShell} instances.
* Create custom instances of {@code JShell} by using the setter
* methods on this class. After zero or more of these, use the
* {@link #build()} method to create a {@code JShell} instance.
* These can all be chained. For example, setting the remote output and
* error streams:
* <pre>
* {@code
* JShell myShell =
* JShell.builder()
* .out(myOutStream)
* .err(myErrStream)
* .build(); } </pre>
* If no special set-up is needed, just use
* {@code JShell.builder().build()} or the short-cut equivalent
* {@code JShell.create()}.
*/
public static class Builder {
InputStream in = new ByteArrayInputStream(new byte[0]);
PrintStream out = System.out;
PrintStream err = System.err;
Supplier<String> tempVariableNameGenerator = null;
BiFunction<Snippet, Integer, String> idGenerator = null;
List<String> extraRemoteVMOptions = new ArrayList<>();
List<String> extraCompilerOptions = new ArrayList<>();
ExecutionControl.Generator executionControlGenerator;
Builder() { }
/**
* Sets the input for the running evaluation (it's {@code System.in}). Note:
* applications that use {@code System.in} for snippet or other
* user input cannot use {@code System.in} as the input stream for
* the remote process.
* <p>
* The {@code read} method of the {@code InputStream} may throw the {@link InterruptedIOException}
* to signal the user canceled the input. The currently running snippet will be automatically
* {@link JShell#stop() stopped}.
* <p>
* The default, if this is not set, is to provide an empty input stream
* -- {@code new ByteArrayInputStream(new byte[0])}.
*
* @param in the {@code InputStream} to be channelled to
* {@code System.in} in the remote execution process
* @return the {@code Builder} instance (for use in chained
* initialization)
*/
public Builder in(InputStream in) {
this.in = in;
return this;
}
/**
* Sets the output for the running evaluation (it's {@code System.out}).
* The controlling process and
* the remote process can share {@code System.out}.
* <p>
* The default, if this is not set, is {@code System.out}.
*
* @param out the {@code PrintStream} to be channelled to
* {@code System.out} in the remote execution process
* @return the {@code Builder} instance (for use in chained
* initialization)
*/
public Builder out(PrintStream out) {
this.out = out;
return this;
}
/**
* Sets the error output for the running evaluation (it's
* {@code System.err}). The controlling process and the remote
* process can share {@code System.err}.
* <p>
* The default, if this is not set, is {@code System.err}.
*
* @param err the {@code PrintStream} to be channelled to
* {@code System.err} in the remote execution process
* @return the {@code Builder} instance (for use in chained
* initialization)
*/
public Builder err(PrintStream err) {
this.err = err;
return this;
}
/**
* Sets a generator of temp variable names for
* {@link jdk.jshell.VarSnippet} of
* {@link jdk.jshell.Snippet.SubKind#TEMP_VAR_EXPRESSION_SUBKIND}.
* <p>
* Do not use this method unless you have explicit need for it.
* <p>
* The generator will be used for newly created VarSnippet
* instances. The name of a variable is queried with
* {@link jdk.jshell.VarSnippet#name()}.
* <p>
* The callback is sent during the processing of the snippet, the
* JShell state is not stable. No calls whatsoever on the
* {@code JShell} instance may be made from the callback.
* <p>
* The generated name must be unique within active snippets.
* <p>
* The default behavior (if this is not set or {@code generator}
* is null) is to generate the name as a sequential number with a
* prefixing dollar sign ("$").
*
* @param generator the {@code Supplier} to generate the temporary
* variable name string or {@code null}
* @return the {@code Builder} instance (for use in chained
* initialization)
*/
public Builder tempVariableNameGenerator(Supplier<String> generator) {
this.tempVariableNameGenerator = generator;
return this;
}
/**
* Sets the generator of identifying names for Snippets.
* <p>
* Do not use this method unless you have explicit need for it.
* <p>
* The generator will be used for newly created Snippet instances. The
* identifying name (id) is accessed with
* {@link jdk.jshell.Snippet#id()} and can be seen in the
* {@code StackTraceElement.getFileName()} for a
* {@link jdk.jshell.EvalException} and
* {@link jdk.jshell.UnresolvedReferenceException}.
* <p>
* The inputs to the generator are the {@link jdk.jshell.Snippet} and an
* integer. The integer will be the same for two Snippets which would
* overwrite one-another, but otherwise is unique.
* <p>
* The callback is sent during the processing of the snippet and the
* Snippet and the state as a whole are not stable. No calls to change
* system state (including Snippet state) should be made. Queries of
* Snippet may be made except to {@link jdk.jshell.Snippet#id()}. No
* calls on the {@code JShell} instance may be made from the
* callback, except to
* {@link #status(jdk.jshell.Snippet) status(Snippet)}.
* <p>
* The default behavior (if this is not set or {@code generator}
* is null) is to generate the id as the integer converted to a string.
*
* @param generator the {@code BiFunction} to generate the id
* string or {@code null}
* @return the {@code Builder} instance (for use in chained
* initialization)
*/
public Builder idGenerator(BiFunction<Snippet, Integer, String> generator) {
this.idGenerator = generator;
return this;
}
/**
* Sets additional VM options for launching the VM.
*
* @param options The options for the remote VM
* @return the {@code Builder} instance (for use in chained
* initialization)
*/
public Builder remoteVMOptions(String... options) {
this.extraRemoteVMOptions.addAll(Arrays.asList(options));
return this;
}
/**
* Adds compiler options. These additional options will be used on
* parsing, analysis, and code generation calls to the compiler.
* Options which interfere with results are not supported and have
* undefined effects on JShell's operation.
*
* @param options the addition options for compiler invocations
* @return the {@code Builder} instance (for use in chained
* initialization)
*/
public Builder compilerOptions(String... options) {
this.extraCompilerOptions.addAll(Arrays.asList(options));
return this;
}
/**
* Sets the custom engine for execution. Snippet execution will be
* provided by the specified {@link ExecutionControl} instance.
*
* @param executionControlGenerator the execution engine generator
* @return the {@code Builder} instance (for use in chained
* initialization)
*/
public Builder executionEngine(ExecutionControl.Generator executionControlGenerator) {
this.executionControlGenerator = executionControlGenerator;
return this;
}
/**
* Builds a JShell state engine. This is the entry-point to all JShell
* functionality. This creates a remote process for execution. It is
* thus important to close the returned instance.
*
* @throws IllegalStateException if the {@code JShell} instance could not be created.
* @return the state engine
*/
public JShell build() throws IllegalStateException {
return new JShell(this);
}
}
// --- public API ---
/**
* Create a new JShell state engine.
* That is, create an instance of {@code JShell}.
* <p>
* Equivalent to {@link JShell#builder() JShell.builder()}{@link JShell.Builder#build() .build()}.
* @throws IllegalStateException if the {@code JShell} instance could not be created.
* @return an instance of {@code JShell}.
*/
public static JShell create() throws IllegalStateException {
return builder().build();
}
/**
* Factory method for {@code JShell.Builder} which, in-turn, is used
* for creating instances of {@code JShell}.
* Create a default instance of {@code JShell} with
* {@code JShell.builder().build()}. For more construction options
* see {@link jdk.jshell.JShell.Builder}.
* @return an instance of {@code Builder}.
* @see jdk.jshell.JShell.Builder
*/
public static Builder builder() {
return new Builder();
}
/**
* Access to source code analysis functionality.
* An instance of {@code JShell} will always return the same
* {@code SourceCodeAnalysis} instance from
* {@code sourceCodeAnalysis()}.
* @return an instance of {@link SourceCodeAnalysis SourceCodeAnalysis}
* which can be used for source analysis such as completion detection and
* completion suggestions.
*/
public SourceCodeAnalysis sourceCodeAnalysis() {
if (sourceCodeAnalysis == null) {
sourceCodeAnalysis = new SourceCodeAnalysisImpl(this);
}
return sourceCodeAnalysis;
}
/**
* Evaluate the input String, including definition and/or execution, if
* applicable. The input is checked for errors, unless the errors can be
* deferred (as is the case with some unresolvedDependencies references),
* errors will abort evaluation.
* <p>
* The input should be
* exactly one complete snippet of source code, that is, one expression,
* statement, variable declaration, method declaration, class declaration,
* or import.
* To break arbitrary input into individual complete snippets, use
* {@link SourceCodeAnalysis#analyzeCompletion(String)}.
* <p>
* For imports, the import is added. Classes, interfaces. methods,
* and variables are defined. The initializer of variables, statements,
* and expressions are executed.
* The modifiers public, protected, private, static, and final are not
* allowed on op-level declarations and are ignored with a warning.
* Synchronized, native, abstract, and default top-level methods are not
* allowed and are errors.
* If a previous definition of a declaration is overwritten then there will
* be an event showing its status changed to OVERWRITTEN, this will not
* occur for dropped, rejected, or already overwritten declarations.
* <p>
* If execution environment is out of process, as is the default case, then
* if the evaluated code
* causes the execution environment to terminate, this {@code JShell}
* instance will be closed but the calling process and VM remain valid.
* @param input The input String to evaluate
* @return the list of events directly or indirectly caused by this evaluation.
* @throws IllegalStateException if this {@code JShell} instance is closed.
* @see SourceCodeAnalysis#analyzeCompletion(String)
* @see JShell#onShutdown(java.util.function.Consumer)
*/
public List<SnippetEvent> eval(String input) throws IllegalStateException {
SourceCodeAnalysisImpl a = sourceCodeAnalysis;
if (a != null) {
a.suspendIndexing();
}
try {
checkIfAlive();
List<SnippetEvent> events = eval.eval(input);
events.forEach(this::notifyKeyStatusEvent);
return Collections.unmodifiableList(events);
} finally {
if (a != null) {
a.resumeIndexing();
}
}
}
/**
* Remove a declaration from the state. That is, if the snippet is an
* {@linkplain jdk.jshell.Snippet.Status#isActive() active}
* {@linkplain jdk.jshell.PersistentSnippet persistent} snippet, remove the
* snippet and update the JShell evaluation state accordingly.
* For all active snippets, change the {@linkplain #status status} to
* {@link jdk.jshell.Snippet.Status#DROPPED DROPPED}.
* @param snippet The snippet to remove
* @return The list of events from updating declarations dependent on the
* dropped snippet.
* @throws IllegalStateException if this {@code JShell} instance is closed.
* @throws IllegalArgumentException if the snippet is not associated with
* this {@code JShell} instance.
*/
public List<SnippetEvent> drop(Snippet snippet) throws IllegalStateException {
checkIfAlive();
checkValidSnippet(snippet);
List<SnippetEvent> events = eval.drop(snippet);
events.forEach(this::notifyKeyStatusEvent);
return Collections.unmodifiableList(events);
}
/**
* The specified path is added to the end of the classpath used in eval().
* Note that the unnamed package is not accessible from the package in which
* {@link JShell#eval(String)} code is placed.
* @param path the path to add to the classpath.
* @throws IllegalStateException if this {@code JShell} instance is closed.
*/
public void addToClasspath(String path) {
// Compiler
taskFactory.addToClasspath(path);
// Runtime
try {
executionControl().addToClasspath(path);
} catch (ExecutionControlException ex) {
debug(ex, "on addToClasspath(" + path + ")");
}
if (sourceCodeAnalysis != null) {
sourceCodeAnalysis.classpathChanged();
}
}
/**
* Attempt to stop currently running evaluation. When called while
* the {@link #eval(java.lang.String) } method is running and the
* user's code being executed, an attempt will be made to stop user's code.
* Note that typically this method needs to be called from a different thread
* than the one running the {@code eval} method.
* <p>
* If the {@link #eval(java.lang.String) } method is not running, does nothing.
* <p>
* The attempt to stop the user's code may fail in some case, which may include
* when the execution is blocked on an I/O operation, or when the user's code is
* catching the {@link ThreadDeath} exception.
*/
public void stop() {
if (executionControl != null) {
try {
executionControl.stop();
} catch (ExecutionControlException ex) {
debug(ex, "on stop()");
}
}
}
/**
* Close this state engine. Frees resources. Should be called when this
* state engine is no longer needed.
*/
@Override
public void close() {
if (!closed) {
closeDown();
try {
executionControl().close();
} catch (Throwable ex) {
// don't care about exceptions on close
}
if (sourceCodeAnalysis != null) {
sourceCodeAnalysis.close();
}
}
}
/**
* Return all snippets.
* @return the snippets for all current snippets in id order.
*/
public Stream<Snippet> snippets() {
return maps.snippetList().stream();
}
/**
* Returns the active variable snippets.
* This convenience method is equivalent to {@code snippets()} filtered for
* {@link jdk.jshell.Snippet.Status#isActive() status(snippet).isActive()}
* {@code && snippet.kind() == Kind.VARIABLE}
* and cast to {@code VarSnippet}.
* @return the active declared variables.
*/
public Stream<VarSnippet> variables() {
return snippets()
.filter(sn -> status(sn).isActive() && sn.kind() == Snippet.Kind.VAR)
.map(sn -> (VarSnippet) sn);
}
/**
* Returns the active method snippets.
* This convenience method is equivalent to {@code snippets()} filtered for
* {@link jdk.jshell.Snippet.Status#isActive() status(snippet).isActive()}
* {@code && snippet.kind() == Kind.METHOD}
* and cast to MethodSnippet.
* @return the active declared methods.
*/
public Stream<MethodSnippet> methods() {
return snippets()
.filter(sn -> status(sn).isActive() && sn.kind() == Snippet.Kind.METHOD)
.map(sn -> (MethodSnippet)sn);
}
/**
* Returns the active type declaration (class, interface, annotation type, and enum) snippets.
* This convenience method is equivalent to {@code snippets()} filtered for
* {@link jdk.jshell.Snippet.Status#isActive() status(snippet).isActive()}
* {@code && snippet.kind() == Kind.TYPE_DECL}
* and cast to TypeDeclSnippet.
* @return the active declared type declarations.
*/
public Stream<TypeDeclSnippet> types() {
return snippets()
.filter(sn -> status(sn).isActive() && sn.kind() == Snippet.Kind.TYPE_DECL)
.map(sn -> (TypeDeclSnippet) sn);
}
/**
* Returns the active import snippets.
* This convenience method is equivalent to {@code snippets()} filtered for
* {@link jdk.jshell.Snippet.Status#isActive() status(snippet).isActive()}
* {@code && snippet.kind() == Kind.IMPORT}
* and cast to ImportSnippet.
* @return the active declared import declarations.
*/
public Stream<ImportSnippet> imports() {
return snippets()
.filter(sn -> status(sn).isActive() && sn.kind() == Snippet.Kind.IMPORT)
.map(sn -> (ImportSnippet) sn);
}
/**
* Return the status of the snippet.
* This is updated either because of an explicit {@code eval()} call or
* an automatic update triggered by a dependency.
* @param snippet the {@code Snippet} to look up
* @return the status corresponding to this snippet
* @throws IllegalStateException if this {@code JShell} instance is closed.
* @throws IllegalArgumentException if the snippet is not associated with
* this {@code JShell} instance.
*/
public Status status(Snippet snippet) {
return checkValidSnippet(snippet).status();
}
/**
* Return the diagnostics of the most recent evaluation of the snippet.
* The evaluation can either because of an explicit {@code eval()} call or
* an automatic update triggered by a dependency.
* @param snippet the {@code Snippet} to look up
* @return the diagnostics corresponding to this snippet. This does not
* include unresolvedDependencies references reported in {@code unresolvedDependencies()}.
* @throws IllegalStateException if this {@code JShell} instance is closed.
* @throws IllegalArgumentException if the snippet is not associated with
* this {@code JShell} instance.
*/
public Stream<Diag> diagnostics(Snippet snippet) {
return checkValidSnippet(snippet).diagnostics().stream();
}
/**
* For {@link jdk.jshell.Snippet.Status#RECOVERABLE_DEFINED RECOVERABLE_DEFINED} or
* {@link jdk.jshell.Snippet.Status#RECOVERABLE_NOT_DEFINED RECOVERABLE_NOT_DEFINED}
* declarations, the names of current unresolved dependencies for
* the snippet.
* The returned value of this method, for a given method may change when an
* {@code eval()} or {@code drop()} of another snippet causes
* an update of a dependency.
* @param snippet the declaration {@code Snippet} to look up
* @return a stream of symbol names that are currently unresolvedDependencies.
* @throws IllegalStateException if this {@code JShell} instance is closed.
* @throws IllegalArgumentException if the snippet is not associated with
* this {@code JShell} instance.
*/
public Stream<String> unresolvedDependencies(DeclarationSnippet snippet) {
return checkValidSnippet(snippet).unresolved().stream();
}
/**
* Get the current value of a variable.
* @param snippet the variable Snippet whose value is queried.
* @return the current value of the variable referenced by snippet.
* @throws IllegalStateException if this {@code JShell} instance is closed.
* @throws IllegalArgumentException if the snippet is not associated with
* this {@code JShell} instance.
* @throws IllegalArgumentException if the variable's status is anything but
* {@link jdk.jshell.Snippet.Status#VALID}.
*/
public String varValue(VarSnippet snippet) throws IllegalStateException {
checkIfAlive();
checkValidSnippet(snippet);
if (snippet.status() != Status.VALID) {
throw new IllegalArgumentException(
messageFormat("jshell.exc.var.not.valid", snippet, snippet.status()));
}
String value;
try {
value = executionControl().varValue(snippet.classFullName(), snippet.name());
} catch (EngineTerminationException ex) {
throw new IllegalStateException(ex.getMessage());
} catch (ExecutionControlException ex) {
debug(ex, "In varValue()");
return "[" + ex.getMessage() + "]";
}
return expunge(value);
}
/**
* Register a callback to be called when the Status of a snippet changes.
* Each call adds a new subscription.
* @param listener Action to perform when the Status changes.
* @return A token which can be used to {@linkplain JShell#unsubscribe unsubscribe} this subscription.
* @throws IllegalStateException if this {@code JShell} instance is closed.
*/
public Subscription onSnippetEvent(Consumer<SnippetEvent> listener)
throws IllegalStateException {
return onX(keyStatusListeners, listener);
}
/**
* Register a callback to be called when this JShell instance terminates.
* This occurs either because the client process has ended (e.g. called System.exit(0))
* or the connection has been shutdown, as by close().
* Each call adds a new subscription.
* @param listener Action to perform when the state terminates.
* @return A token which can be used to {@linkplain JShell#unsubscribe unsubscribe} this subscription.
* @throws IllegalStateException if this JShell instance is closed
*/
public Subscription onShutdown(Consumer<JShell> listener)
throws IllegalStateException {
return onX(shutdownListeners, listener);
}
/**
* Cancel a callback subscription.
* @param token The token corresponding to the subscription to be unsubscribed.
*/
public void unsubscribe(Subscription token) {
synchronized (this) {
token.remover.accept(token);
}
}
/**
* Subscription is a token for referring to subscriptions so they can
* be {@linkplain JShell#unsubscribe unsubscribed}.
*/
public class Subscription {
Consumer<Subscription> remover;
Subscription(Consumer<Subscription> remover) {
this.remover = remover;
}
}
/**
* Provide the environment for a execution engine.
*/
class ExecutionEnvImpl implements ExecutionEnv {
@Override
public InputStream userIn() {
return in;
}
@Override
public PrintStream userOut() {
return out;
}
@Override
public PrintStream userErr() {
return err;
}
@Override
public List<String> extraRemoteVMOptions() {
return extraRemoteVMOptions;
}
@Override
public void closeDown() {
JShell.this.closeDown();
}
}
// --- private / package-private implementation support ---
ExecutionControl executionControl() {
return executionControl;
}
void debug(int flags, String format, Object... args) {
InternalDebugControl.debug(this, err, flags, format, args);
}
void debug(Exception ex, String where) {
InternalDebugControl.debug(this, err, ex, where);
}
/**
* Generate the next key index, indicating a unique snippet signature.
*
* @return the next key index
*/
int nextKeyIndex() {
return nextKeyIndex++;
}
private synchronized <T> Subscription onX(Map<Subscription, Consumer<T>> map, Consumer<T> listener)
throws IllegalStateException {
Objects.requireNonNull(listener);
checkIfAlive();
Subscription token = new Subscription(map::remove);
map.put(token, listener);
return token;
}
private synchronized void notifyKeyStatusEvent(SnippetEvent event) {
keyStatusListeners.values().forEach(l -> l.accept(event));
}
private synchronized void notifyShutdownEvent(JShell state) {
shutdownListeners.values().forEach(l -> l.accept(state));
}
void closeDown() {
if (!closed) {
// Send only once
closed = true;
try {
notifyShutdownEvent(this);
} catch (Throwable thr) {
// Don't care about dying exceptions
}
}
}
/**
* Check if this JShell has been closed
* @throws IllegalStateException if it is closed
*/
private void checkIfAlive() throws IllegalStateException {
if (closed) {
throw new IllegalStateException(messageFormat("jshell.exc.closed", this));
}
}
/**
* Check a Snippet parameter coming from the API user
* @param sn the Snippet to check
* @throws NullPointerException if Snippet parameter is null
* @throws IllegalArgumentException if Snippet is not from this JShell
* @return the input Snippet (for chained calls)
*/
private Snippet checkValidSnippet(Snippet sn) {
if (sn == null) {
throw new NullPointerException(messageFormat("jshell.exc.null"));
} else {
if (sn.key().state() != this) {
throw new IllegalArgumentException(messageFormat("jshell.exc.alien"));
}
return sn;
}
}
/**
* Format using resource bundle look-up using MessageFormat
*
* @param key the resource key
* @param args
*/
String messageFormat(String key, Object... args) {
if (outputRB == null) {
try {
outputRB = ResourceBundle.getBundle(L10N_RB_NAME);
} catch (MissingResourceException mre) {
throw new InternalError("Cannot find ResourceBundle: " + L10N_RB_NAME);
}
}
String s;
try {
s = outputRB.getString(key);
} catch (MissingResourceException mre) {
throw new InternalError("Missing resource: " + key + " in " + L10N_RB_NAME);
}
return MessageFormat.format(s, args);
}
}