All Classes and Interfaces
Class
Description
Abstract Object Operations as defined by EcmaScript
This is a specialization of Slot to store various types of values that are retrieved dynamically
using Java and JavaScript functions.
This is a getter that delegates to a JavaScript function.
Invoke the setter as a JavaScript function, taking care that it might actually be Undefined.
This is a Getter that delegates to a Java function via a MemberBox.
Invoke the setter on this slot via reflection using MemberBox.
This class implements the "arguments" object.
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.
AST node for an Array literal.
The class for Arrow Function Definitions
EcmaScript 6 Rev 14, March 8, 2013 Draft spec , 13.2
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.
AST node for a BigInt literal.
This class makes the Bindings object into a Scriptable.
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 class defines the following built-in functions for the RhinoScriptEngine.
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.
CacheKey is a combination of class and securityContext.
Generates class files from script sources.
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.
This class generates code for a given IR tree.
Generates bytecode for the Interpreter.
Node representing comments.
AST node representing the ternary operator.
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.
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.
Panel that shows information about the context.
Exception thrown by
Context.executeScriptWithContinuations(Script, Scriptable)
and Context.callFunctionWithContinuations(Callable, Scriptable, 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.
The following class save decompilation information about the source.
This is the default error reporter for JavaScript.
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.
Proxy class to implement debug interfaces without bloat of class
files.
Class to store information about a function.
Class to store information about a script source.
Object to represent one stack frame.
Do statement.
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 object that implements deep equality test of objects, including their
reference graph topology, that is in addition to establishing by-value
equality of objects, it also establishes that their reachable object graphs
have identical shape.
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.
Extension of JTextArea for script evaluation input.
Abstraction of evaluation, which can be implemented either by an
interpreter or compiler.
A table for evaluated expressions.
The class of exceptions thrown by the JavaScript engine.
An internal frame for evaluating script.
AST node representing an expression in a statement context.
Implement this interface in order to allow external data to be attached to a ScriptableObject.
Gutter for FileWindows.
Popup menu class for right-clicking on
FileTextAreas.Text area to display script source.
An internal frame for script files.
Find function dialog.
The completors provided with JLine are pretty uptight, they only
complete on a line that it can fully recognize (only composed of
completed strings).
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.
A JavaScript function declaration or expression.
Interface to define classes from generated byte code.
This class provides for sharing functions across multiple threads.
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.
Additional interpreter-specific codes
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.
Adapter to use JS function as implementation of Java interfaces with
single method or multiple methods with the same signature.
Class to hold data corresponding to one interpreted call stack frame.
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.
Provides a key with which to distinguish previously generated
adapter classes stored in a hash table.
Version of
JavaMembers for modular JDKs.Java reflection of JavaScript exceptions.
This class provides implementations of converters for Java objects to be used by the
JSON.stringify method.
An annotation that marks a Java method as JavaScript constructor.
An annotation that marks a Java method as JavaScript function.
An annotation that marks a Java method as JavaScript getter.
Internal frame for the console.
This class converts a stream of JSON tokens into a JSON value.
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,
null, true, false, and debugger.Collection of utilities
AST node representing a label.
A labeled statement.
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.
AST node for let statements and expressions.
Abstract base type for loops.
Rhino script debugger main class.
The shell program.
Class to consolidate all internal implementations of interfaces
to avoid class generation bloat.
Proxy class to avoid proliferation of anonymous classes.
Wrapper class for Method and Constructor instances to cache getParameterTypes() results, recover
from IllegalAccessException in some cases and provide serialization support.
The debugger frame menu bar.
Helper class for showing a message dialog.
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.
Dialog to list the available windows.
A multiplexer for module script providers.
Table model class for watched expressions.
A tree table for browsing script objects.
AST node for a simple name.
Class Namespace
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.
This class implements the BigInt native object.
This class implements the Boolean native object.
This class implements the activation object.
This class is used by the V8 extension "Error.prepareStackTrace." It is passed to that function,
which may then use it to format the stack as it sees fit.
This class represents the JavaScript "DataView" interface, which allows direct manipulations of
the bytes in a NativeArrayBuffer.
This class implements the Date native object.
The class of error objects
We will attch this object to the constructor and use it solely to store the constructor
properties that are "global." We can't make them static because there can be many contexts in
the same JVM.
An array view that stores 32-bit quantities and implements the JavaScript "loat32Array" 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 Math native object.
This class implements the Number native object.
This class implements the Object native object.
This class implements the RegExp native object.
Legacy implementation of RegExp was callable, this class exists to preserve this functionality
This class implements the RegExp constructor native object.
The JavaScript Script object.
This class implements the String 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.
This class implements the object lookup required for the
with statement.New expression.
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.
AST node for a Number literal.
Implementation of resizable array with focus on minimizing memory usage by storing few initial array elements in object fields.
AST node for an Object literal (also called an Object initialiser in
Ecma-262).
AST node for a single name:value entry in an Object literal.
Map to associate objects to integers.
This class performs node transforms to prepare for optimization.
AST 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.AST node for the '.' operator.
Class QName
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.
AST node for a RegExp literal.
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.
The class of exceptions thrown by the JavaScript engine.
This is the implementation of the standard ScriptEngine interface for Rhino.
This is an implementation of the standard Java "ScriptEngine" for Rhino.
A
java.lang.SecurityManager subclass that provides access to
the current top-most script class on the execution stack.Class to consolidate all cases that require to implement Runnable to avoid class generation
bloat.
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.
Class ScriptableOutputStream is an ObjectOutputStream used
to serialize JavaScript objects and functions.
Base type for
AstRoot and FunctionNode nodes, which need to collect much of the
same information.This is the class that implements the runtime.
This is the enumeration needed by the for..in statement.
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.
JLine's ConsoleReaderInputStream is no longer public, therefore we need
to use our own implementation
ShellConsole implementation for JLine v1ShellConsole implementation for JLine v2Deprecated.
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.
This class holds the various SlotMaps of various types, and knows how to atomically switch
between them when we need to so that we use the right data structure at the right time.
A module script provider that uses a module source provider to load modules
and caches the loaded modules.
Interface to provide a source of scripts to the debugger.
This class distinguishes between the three different supported stack trace formats.
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.
A super block is defined as a contiguous chunk of code with a single entry
point and multiple exit points (therefore ending in an unconditional jump
or the end of the method).
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 objecy that obeys the special properties of the
Symbol prototype.
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.
This class extends the SlotMapContainer so that we have thread-safe access to all the properties
of an object.
Throw statement.
This class supports the "setTimeout" and "clearTimeout" methods of semi-standard JavaScript.
An object to go on the priority queue.
This class implements the JavaScript scanner.
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.
An enumeration of built-in native errors.
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.
Helper class for internal representations of type information.
Map to associate non-negative integers to objects or integers.
AST 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.
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.Tree model for script object inspection.
A variable node in the tree.
While statement.
With 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 a call to a Java method or an access to 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.
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.
This abstract class 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.