All Classes and Interfaces
Class
Description
TypeInfoFactory implementation with cache.Abstract Object Operations as defined by EcmaScript
Abstract operations for string manipulation as defined by EcmaScript
Property of an object literal.
Interface representing a call frame in the interpreter.
This is a specialization of Slot to store various types of values that are retrieved dynamically
using Java and JavaScript functions.
This class is intended as proxy to give
DebugFrame access to the contents of local
variables.AST node for a JavaScript 1.7 Array comprehension.
AST node for a single 'for (foo in bar)' loop construct in a JavaScript 1.7 Array comprehension.
Contains implementation of shared methods useful for arrays and typed arrays.
AST node for an Array literal.
AST node representing the set of assignment operators such as
=, *= and
+=.Base class for AST node types.
Node for the root of a parse tree.
The base class for Function objects.
A simple console that always works because it only relies on standard input and output.
AST node for a BigInt literal.
A block statement delimited by curly braces.
The class for results of the Function.bind() operation EcmaScript 5 spec, 15.3.4.5
A break statement.
This is a specialization of property access using some lambda functions designed for properties
on built in objects that may be created extremely frequently.
Can provide source code for a built in Function
This class provides opcode values expected by the JVM in Java class files.
Abstract base class that implements caching of loaded module scripts.
Instances of this class represent a loaded and cached module script.
Generic notion of callable object that can execute some script-related code upon request with
specified values for script scope and this objects.
Node representing a catch-clause of a try-statement.
Cache of generated classes and data structures to access Java runtime from JavaScript.
A descriptor for a constructor and its prototype methods which can then be used to build a real
constructor function and prototype during standard object initialisation.
A builder for creating class descriptors.
Enum indicating the destination for an operation.
ClassFileWriter
Thrown for cases where the error in generating the class file is due to a program size
constraints rather than a likely bug in the compiler.
Embeddings that wish to filter Java classes that are visible to scripts through the LiveConnect,
should implement this interface.
ClassValue is really performant for caching per-class data.Common utilities usable by all the compilers for populating
JSDescriptor.Builder entries
from IR nodes.Node representing comments.
CompactSlot<T extends CompactSlot.Descriptor<T,U,O>,U extends PropHolder<U>,O extends ScriptableObject>
CompactSlot.Descriptor<T extends CompactSlot.Descriptor<T,U,O>,U extends PropHolder<U>,O extends ScriptableObject>
Opaque result of compiling a
ScriptNode via an Evaluator.Mutable working state for building an immutable
CompilerData.Parameters for compiling a JavaScript script (i.e. top-level program source) or function.
This class represents a compound operation performed on a non-thread safe map.
AST node for a computed property key, i.e. `[ Expression ]` in an object literal.
AST node representing the ternary operator.
A generic interface for a console that supports input from the user and displays input on the
screen.
This is a service interface to provide consoles.
This class represents a string composed of two components, each of which may be a
java.lang.String or another ConsString.An interface that can be used to implement a constructor function as a lambda.
This class represents the runtime context of an executing script.
Enumeration of evaluation methods supported by Rhino.
Interface to represent arbitrary action that requires to have Context object associated with the
current thread for its execution.
Factory class that Rhino runtime uses to create new
Context instances.Listener of
Context creation and release events.Deprecated.
Exception thrown by
Context.executeScriptWithContinuations(Script, VarScope) and Context.callFunctionWithContinuations(Callable, VarScope, Object[]) when execution encounters a continuation captured by Context.captureContinuation().A continue statement.
Numeric conversions from section 7 of the ECMAScript 6 standard.
Interface to implement if the application is interested in receiving debug information during
execution of a particular script or function.
This interface exposes debugging information from objects.
This interface exposes debugging information from executable code (either functions or top-level
scripts).
Interface to implement if the application is interested in receiving debug information.
This class formats a decimal number into a string representation and stores the result in a
buffer.
The result of decoding a base64 or hex string into bytes, as returned by
Base64Codec.decode(java.lang.String, boolean, java.lang.String) and HexCodec.decode(java.lang.String).The default heuristic for calculating cache expiry of URL-based resources.
Load generated classes.
This is a helper class for implementing wrappers around Scriptable objects.
Common interface for
ArrayLiteral and ObjectLiteral node types, both of which may
appear in "destructuring" expressions or contexts.Dim or Debugger Implementation for Rhino.
Class to store information about a stack.
Class to store information about a function.
Class to store information about a script source.
Object to represent one stack frame.
Do statement.
This class formats a double into a set of digits and an exponent for further formatting by the
Double class.
Stores a reference to the original source code and returns it as necessary.
The class of exceptions raised by the engine as described in ECMA edition 3.
AST node for an indexed property reference, such as
foo['bar'] or foo[2].AST node for an empty expression.
AST node for an empty statement.
Environment, intended to be instantiated at global scope, provides a natural way to access System
properties from JavaScript.
An error reporter that gathers the errors and warnings for later display.
AST node representing a parse error or a warning.
This is interface defines a protocol for the reporting of errors during JavaScript translation or
execution.
Abstraction of evaluation, which can be implemented either by an interpreter or compiler.
The class of exceptions thrown by the JavaScript engine.
AST node representing an expression in a statement context.
Implement this interface in order to allow external data to be attached to a ScriptableObject.
For-in or for-each-in or for-of statement.
C-style for-loop statement.
This is interface that all functions in JavaScript must implement.
AST node for a function call.
Parameters for compiling a JavaScript function (a single function definition).
A JavaScript function declaration or expression.
Interface to define classes from generated byte code.
AST node for a generator method definition in an object literal, i.e.
This class provides for sharing functions across multiple threads.
optioal interface to specify a launcher, that creates a process for the runCommand method.
Interface for communication between the debugger and its GUI.
This class implements the SlotMap interface using a java.util.HashMap.
This generic hash table class is used by Set and Map.
One entry in the hash table.
This is interface defines a protocol for the reporting of errors during JavaScript translation in
IDE-mode.
Master for id-based functions that knows their properties and how to execute them.
Base class for native object implementation that uses IdFunctionObject to export its methods to
script via <class-name>.prototype object.
If-else statement.
This class is a singleton that just exists to serve up the implementation version.
Class ImporterTopLevel
AST node representing an infix (binary operator) expression.
A single-function interface so that we can use lambda functions to lazily initialize native
classes.
Utility class for formatting InterpreterV2 instructions.
Adapter to use JS function as implementation of Java interfaces with single method or multiple
methods with the same signature.
This class rewrites the parse tree into an IR suitable for codegen.
This is a class that makes it easier to iterate over "iterator-like" objects as defined in the
ECMAScript spec.
Java reflection of JavaScript exceptions.
This class provides implementations of converters for Java objects to be used by the
JSON.stringify method.
Represents code that is executable, and potentially resumable.
Represents a mutable
JSCode object in the process of being created, usually as a
child of a JSDescriptor.Builder.A builder for a null code entry.
This interface represent a thing which can be executed in JavaScript, whether that is a script,
function call, or function constructor.
This interface represent a thing which can be executed in JavaScript, which could be a generator,
or potentially in future an async function.
An annotation that marks a Java method as JavaScript constructor.
This class holds all the meta-data associated with a function in as an immutable form as
possible, along with the executable things associated with the function.
A mutable object for creating the final immutable
JSDescriptor.An annotation that marks a Java method as JavaScript function.
Represents a JavaScript function built upon a a
JSDescriptor.An annotation that marks a Java method as JavaScript getter.
This class converts a stream of JSON tokens into a JSON value.
Represents a script object built upon a
JSDescriptor.An annotation that marks a Java method as JavaScript setter.
An annotation that marks a Java method as JavaScript static function.
This example shows how to create a simple JTreeTable component, by using a JTree as a renderer
(and editor) for the cells in a particular column in the JTable.
Used for code generation.
AST node for keyword literals: currently,
this, super, null,
undefined, true, false, debugger, and new.target.Collection of utilities
This class implements a lambda function which is known to the runtime system and which may be
treated specially by the interpreter or runtime.
AST node representing a label.
A labeled statement.
A specialized property accessor using lambda functions, similar to
LambdaSlot, but allows
defining properties with getter and setter lambdas that require access to the owner object
('this').This class implements a JavaScript function that may be used as a constructor by delegating to an
interface that can be easily implemented as a lambda.
This class implements a single JavaScript function that has the prototype of the built-in
Function class, and which is implemented using a single function that can easily be implemented
using a lambda expression.
This is a specialization of property access using some lambda functions.
Avoid loading classes unless they are used.
This is a specialization of Slot to store values that are retrieved via calls to script
functions.
Can provide source code from a lazy
SourceCodeSupplier, that for example can retrieve it
from the database.ClassValue is not present on Android until API level 34.AST node for let statements and expressions.
Packed array-based line number table implementation.
Builder for LineNumberTable.
Abstract base type for loops.
Rhino script debugger main class.
The shell program.
A top-level module scope.
Represents a compiled CommonJS module script.
Should be implemented by Rhino embeddings to allow the require() function to obtain
ModuleScript objects.Represents the source text of the module as a tuple of a reader, a URI, a security domain, and a
cache validator.
Implemented by objects that can provide the source text for the script.
A base implementation for all module script providers that actually load module scripts.
A multiplexer for module script providers.
AST node for a simple name.
This class implements the Array native object.
A NativeArrayBuffer is the backing buffer for a typed array.
This class is the abstract parent for all views of the array.
An array view that stores 64-bit quantities and implements the JavaScript "Float64Array"
interface.
An array view that stores 64-bit quantities and implements the JavaScript "Float64Array"
interface.
This class implements the activation object.
This class is used by the V8 extension "Error.prepareStackTrace."
This class represents the JavaScript "DataView" interface, which allows direct manipulations of
the bytes in a NativeArrayBuffer.
Implementation of ECMAScript 2021 FinalizationRegistry.
An array view that stores 32-bit quantities and implements the JavaScript "Float16Array"
interface.
An array view that stores 32-bit quantities and implements the JavaScript "Float32Array"
interface.
An array view that stores 64-bit quantities and implements the JavaScript "Float64Array"
interface.
This class implements the Function native object.
This class implements generator objects.
This class implements the global native object (function and value properties only).
An array view that stores 16-bit quantities and implements the JavaScript "Int16Array" interface.
An array view that stores 32-bit quantities and implements the JavaScript "Int32Array" interface.
An array view that stores 8-bit quantities and implements the JavaScript "Int8Array" interface.
This class implements iterator objects.
This class reflects Java arrays into the JavaScript environment.
This class reflects Java classes into the JavaScript environment, mainly for constructors and
static members.
This class reflects a single Java constructor into the JavaScript environment.
NativeJavaList is a wrapper for java objects implementing java.util.List
interface.NativeJavaMap is a wrapper for java objects implementing java.util.Map
interface.This class reflects Java methods into the JavaScript environment and handles overloading of
methods.
This class reflects non-Array Java objects into the JavaScript environment.
This class reflects Java packages into the JavaScript environment.
This class reflects Java packages into the JavaScript environment.
This class implements the JSON native object.
This class implements the Object native object.
This class implements the RegExp native object.
This is an implementation of the standard "Symbol" type that implements all of its weird
properties.
This class is the abstract parent for all of the various typed arrays.
An array view that stores 16-bit quantities and implements the JavaScript "Uint16Array"
interface.
An array view that stores 32-bit quantities and implements the JavaScript "Uint32Array"
interface.
An array view that stores 8-bit quantities and implements the JavaScript "Uint8Array" interface.
An array view that stores 8-bit quantities and implements the JavaScript "Uint8ClampedArray"
interface.
This is an implementation of the ES6 WeakMap class.
This is an implementation of the ES6 WeakSet class.
New expression.
Used to store the support structures for a literal object (or array) being built.
This class implements the root of the intermediate representation.
This class transforms a tree to a lower-level representation for codegen.
Simple visitor interface for traversing the AST.
Declaring it as an enum ensures that
NoTypeInfo is always singleton.AST node for a Number literal.
AST node for an Object literal (also called an Object initializer in Ecma-262).
AST node for a single name:value entry in an Object literal.
a
TypeInfo implementation representing ParameterizedTypeAST node for a parenthesized expression.
Breaks a "contentType; charset=encoding" MIME type into content type and encoding parts.
Encapsulates information for a JavaScript parse error or warning.
This class implements the JavaScript parser.
A security controller relying on Java
Policy in effect.A 1-indexed line and column position in a source file.
AST node for the '.' operator.
Interface the common route of JS objects and environment records, i.e. a thing that has
properties and some form of ancestor.
Defines action to perform in response to quit command.
Generic notion of reference object that know how to query/modify the target objects based on some
property/index.
Object that can allows assignments to the result of function calls.
Simple wrapper to use the RegExp engine without js.
AST node for a RegExp literal.
This interface is used to load the RegExp implementation from the classpath.
This class loads the default RegExp implementation.
A proxy for the regexp package, so that the regexp package can be loaded optionally.
Implements the require() function as defined by Common JS modules.
A builder for
Require instances.Return statement.
RhinoConfig provides typesafe and static access methods to a
RhinoProperties default
instance.The class of exceptions thrown by the JavaScript engine.
Utility class to read current rhino configuration from various properties.
Optional Loader interface for loading properties.
A
java.lang.SecurityManager subclass that provides access to the current top-most script
class on the execution stack.Represents a scope in the lexical scope chain.
Interface to provide a scope object for script evaluation to the debugger.
All compiled scripts implement this interface.
This is interface that all objects in JavaScript must implement.
Class ScriptableInputStream is used to read in a JavaScript object or function previously
serialized with a ScriptableOutputStream.
This is the default implementation of the Scriptable interface.
This comparator sorts property fields in spec-compliant order.
This is a single method interface suitable to be implemented as a lambda.
This is a single method interface suitable to be implemented as a lambda.
Class ScriptableOutputStream is an ObjectOutputStream used to serialize JavaScript objects and
functions.
Parameters for compiling a JavaScript script (i.e. top-level program source).
Base type for
AstRoot and FunctionNode nodes, which need to collect much of the
same information.Super type for Javascript scripts and functions.
This is the class that implements the runtime.
This is returned from the various "getFooAndThis" methods, so it can return the result, the
appropriate "this" object, and the name of the property so that a proper exception can be
thrown if the result is not a function.
This is an interface defining a message provider.
Helper to return a string or an integer.
This class represents an element on the script execution stack.
This class describes the support needed to implement security.
This interface makes it possible to pass a lambda function to the various methods in
LambdaConstructor and LambdaFunction that require a Callable that is also Serializable.
This interface makes it possible to pass a lambda function to the various methods in
LambdaConstructor and LambdaFunction that require a Constructable that is also Serializable.
A Slot is the base class for all properties stored in the ScriptableObject class.
A SlotMap is an interface to the main data structure that contains all the "Slots" that back a
ScriptableObject.
A module script provider that uses a module source provider to load modules and caches the loaded
modules.
An object that can provide the source code for the given function.
A lambda that can provide the source code for a given script.
Thrown by
SourceMapV3.parse(java.lang.String) (and friends) when the input is not a valid ECMA-426 source
map.Maps positions in a transpiled (target) script back to positions in the original source.
A
SourceMapper backed by a parsed ECMA-426 plain source map.Interface to provide a source of scripts to the debugger.
AST node for a spread `...expression`.
AST node for a spread `...expression` in an object literal.
This class distinguishes between the three different supported stack trace formats.
A Slot is the base class for all properties stored in the ScriptableObject class.
AST node for a single- or double-quoted string literal.
A module script provider that uses a module source provider to load modules and caches the loaded
modules.
A utility class for lazily instantiated substrings.
GUI for the Rhino debugger.
Switch-case AST node type.
Switch statement AST node type.
Represents a symbol-table entry.
A Symbol is a JavaScript object that obeys the special properties of the Symbol prototype.
Represents the kind of the symbol, built in, registered, or normal.
A SymbolKey is one of the implementations of Symbol.
This interface may be combined with any object that implements Scriptable to add support for
properties keyed by Symbol objects (as opposed to String and number objects as in previous
versions of JavaScript.
This class provides support for implementing Java-style synchronized methods in Javascript.
AST node for a Tagged Template Literal.
AST node for Template Literal Characters.
AST node for a Template literal.
Throw statement.
This class supports the "setTimeout" and "clearTimeout" methods of semi-standard JavaScript.
This class implements the JavaScript scanner.
Error reporter for tools.
A top-level scope object that provides special means to cache and preserve the initial values of
the built-in constructor properties for better ECMAScript compliance.
An enumeration of built-in ECMAScript objects.
TreeTableModel is the model used by a JTreeTable.
This is a wrapper class takes a TreeTableModel and implements the table model interface.
Try/catch/finally statement.
A representation of Java type, aiming at preserving more type information than what a
Class can provideFactory for
TypeInfoAST node representing unary operators such as
typeof and delete.This class implements the Undefined value in JavaScript.
This class is responsible for handling tracking of unhandled Promise rejections.
Unicode properties handler for Java 11 Character class.
Class instances represent serializable tags to mark special Object values.
AST node representing update operators such as
++.Implemented by objects that can be used as heuristic strategies for calculating the expiry of a
cached resource in cases where the server of the resource doesn't provide explicit expiry
information.
Interface for URL connection based security domain providers.
A URL-based script provider that can load modules against a set of base privileged and fallback
URIs.
A list of one or more var, const or let declarations.
A variable declaration or initializer, part of a
VariableDeclaration expression.a
TypeInfo implementation representing TypeVariableInterface that represents an the bindings of an ECMAScript environment record.
While statement.
a
TypeInfo implementation representing WildcardTypeWith statement.
Embeddings that wish to provide their own custom wrappings for Java objects may extend this class
and call
Context.setWrapFactory(WrapFactory) Once an instance of this class or an
extension of this class is enabled for a given context (by calling setWrapFactory on that
context), Rhino will call the methods of this class whenever it needs to wrap a value resulting
from calling a Java method or accessing a Java field.A wrapper for runtime exceptions.
Objects that can wrap other values for reflection in the JS environment will implement Wrapper.
AST node representing an E4X
foo.(bar) query expression.AST node for an E4X XML
[expr] member-ref expression.AST node for an embedded JavaScript expression within an E4X XML literal.
Abstract base type for components that comprise an
XmlLiteral object.An object which specifies an XMLLib implementation to be used at runtime.
AST node for an E4X (Ecma-357) embedded XML literal.
This interface is used to load the XML implementation using the ServiceLoader pattern.
AST node for E4X ".@" and ".." expressions, such as
foo..bar, foo..@bar,
@foo.@bar, and foo..@ns::*.This Interface describes what all XML objects (XML, XMLList) should have in common.
AST node for an E4X XML
[expr] property-ref expression.Base class for E4X XML attribute-access or property-get expressions.
AST node for an XML-text-only component of an XML literal expression.
AST node for JavaScript 1.7
yield expression or statement.
Contextinstances should implementContextFactory.Listener.