JDK 11 jdk.jshell.jmod - JShell Tool

JDK 11 jdk.jshell.jmod is the JMOD file for JDK 11 JShell tool, which can be invoked by the "jshell" command.

JDK 11 JShell tool compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\jdk.jshell.jmod.

JDK 11 JShell tool compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.

JDK 11 JShell tool source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\jdk.jshell.

You can click and view the content of each source code file in the list below.

✍: FYIcenter

jdk/jshell/package-info.java

/*
 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

/**
 * Provides interfaces for creating tools, such as a Read-Eval-Print Loop (REPL),
 * which interactively evaluate "snippets" of Java programming language code.
 * Where a "snippet" is a single expression, statement, or declaration.
 * This functionality can be used to enhance tools such as IDEs or can be
 * stand-alone.
 * <p>
 * {@link jdk.jshell.JShell} is the central class.  An instance of
 * <code>JShell</code> holds the evaluation state, which is both the current
 * set of source snippets and the execution state they have produced.
 * <p>
 * Each source snippet is represented by an instance of a subclass of
 * {@link jdk.jshell.Snippet}. For example, a statement is represented by an
 * instance of {@link jdk.jshell.StatementSnippet}, and a method declaration is
 * represented by an instance of {@link jdk.jshell.MethodSnippet}.
 * Snippets are created when
 * {@link jdk.jshell.JShell#eval(java.lang.String) JShell.eval(String)}
 * is invoked with an input which includes one or more snippets of code.
 * <p>
 * Any change to the compilation status of a snippet is reported with a
 * {@link jdk.jshell.SnippetEvent}.  There are three major kinds of
 * changes to the status of a snippet: it can created with <code>eval</code>,
 * it can be dropped from the active source state with
 * {@link jdk.jshell.JShell#drop(jdk.jshell.Snippet)}, and it can have
 * its status updated as a result of a status change in another snippet.
 * For
 * example: given <code>js</code>, an instance of <code>JShell</code>, executing
 * <code>js.eval("int x = 5;")</code> will add the variable <code>x</code> to
 * the source state and will generate an event describing the creation of a
 * {@link jdk.jshell.VarSnippet} for <code>x</code>. Then executing
 * <code>js.eval("int timesx(int val) { return val * x; }")</code> will add
 * a method to the source state and will generate an event
 * describing the creation of a {@link jdk.jshell.MethodSnippet} for
 * <code>timesx</code>.
 * Assume that <code>varx</code> holds the snippet created by the first
 * call to <code>eval</code>, executing <code>js.drop(varx)</code> will
 * generate two events: one for changing the status of the
 * variable snippet to <code>DROPPED</code> and one for
 * updating the method snippet (which now has an unresolved reference to
 * <code>x</code>).
 * <p>
 * Of course, for any general application of the API, the input would not be
 * fixed strings, but would come from the user. Below is a very simplified
 * example of how the API might be used to implement a REPL.
 * <pre>
* {@code
 *     import java.io.ByteArrayInputStream;
 *     import java.io.Console;
 *     import java.util.List;
 *     import jdk.jshell.*;
 *     import jdk.jshell.Snippet.Status;
 *
 *     class ExampleJShell {
 *         public static void main(String[] args) {
 *             Console console = System.console();
 *             try (JShell js = JShell.create()) {
 *                 do {
 *                     System.out.print("Enter some Java code: ");
 *                     String input = console.readLine();
 *                     if (input == null) {
 *                         break;
 *                     }
 *                     List<SnippetEvent> events = js.eval(input);
 *                     for (SnippetEvent e : events) {
 *                         StringBuilder sb = new StringBuilder();
 *                         if (e.causeSnippet == null) {
 *                             //  We have a snippet creation event
 *                             switch (e.status) {
 *                                 case VALID:
 *                                     sb.append("Successful ");
 *                                     break;
 *                                 case RECOVERABLE_DEFINED:
 *                                     sb.append("With unresolved references ");
 *                                     break;
 *                                 case RECOVERABLE_NOT_DEFINED:
 *                                     sb.append("Possibly reparable, failed  ");
 *                                     break;
 *                                 case REJECTED:
 *                                     sb.append("Failed ");
 *                                     break;
 *                             }
 *                             if (e.previousStatus == Status.NONEXISTENT) {
 *                                 sb.append("addition");
 *                             } else {
 *                                 sb.append("modification");
 *                             }
 *                             sb.append(" of ");
 *                             sb.append(e.snippet.source());
 *                             System.out.println(sb);
 *                             if (e.value != null) {
 *                                 System.out.printf("Value is: %s\n", e.value);
 *                             }
 *                             System.out.flush();
 *                         }
 *                     }
 *                 } while (true);
 *             }
 *             System.out.println("\nGoodbye");
 *         }
 *     }
 * }
 * </pre>
 * <p>
 * To register for status change events use
 * {@link jdk.jshell.JShell#onSnippetEvent(java.util.function.Consumer)}.
 * These events are only generated by <code>eval</code> and <code>drop</code>,
 * the return values of these methods are the list of events generated by that
 * call.  So, as in the example above, events can be used without registering
 * to receive events.
 * <p>
 * If you experiment with this example, you will see that failing to terminate
 * a statement or variable declaration with a semi-colon will simply fail.
 * An unfinished entry (for example a desired multi-line method) will also just
 * fail after one line.  The utilities in {@link jdk.jshell.SourceCodeAnalysis}
 * provide source boundary and completeness analysis to address cases like
 * those.  <code>SourceCodeAnalysis</code> also provides suggested completions
 * of input, as might be used in tab-completion.
 *
 * @since 9
 */


package jdk.jshell;

jdk/jshell/package-info.java

 

JDK 11 jdk.jsobject.jmod - JS Object Module

JDK 11 jdk.jlink.jmod - JLink Tool

Download and Use JDK 11

⇑⇑ FAQ for JDK (Java Development Kit)

2020-06-30, 7851👍, 0💬