All Classes and Interfaces
Class
Description
A native function invoker
A abstract memory object that defines operations common to both pointers and
memory buffers
An abstract implementation of
NodeVisitor that has an abstract default visit method, and provides a utility
method to visit children.Base type for the two Ruby Method types.
Newer version of IAccessor which is both context aware AND
it allows it to just reuse get/set on the variables it
tends to represent.
A ThreadLike that weakly references its native thread, for adopted JVM threads we don't want to root.
Represents a method which has been aliased.
Represents an alias statement (
alias newName oldName).Represents a && (and) operator.
Annotation processor for generating "populators" to bind native Java methods as Ruby methods, and
to gather a list of classes seen during compilation that should have their invokers regenerated.
Utility methods for generating bindings at build time.
Visitor interface to be implemented by visitors of the Annotation AST.
A Channel wrapper that will seek to the end of the open file on any write()
operations by performing a seek to eof beforehand.
Represents the argument declarations of a method.
Simple struct to temporarily hold values during part of parsing.
Simple struct to hold values until they can be inserted into the AST.
A description of a single argument in a Ruby argument list.
Represents a Ruby ArgumentError as a throwable Java exception.
Simple Node for named entities.
Encapsulated logic for processing JRuby's command-line arguments.
The diffierent types of arguments identified in a method.
The arity of a method is the number of arguments it takes.
Instruction representing Ruby code of the form: "a['str']"
which is equivalent to: a.[]('str').
Created by headius on 10/23/14.
A shim class created when constructing primitive arrays from proxied Java classes.
Represents an array.
Support methods for (native) arrays.
A collection of utilities for manipulating Java arrays.
ASM helpers for JRuby.
Base class of any node which can be assigned to.
Created by headius on 2/26/15.
Created by headius on 10/23/14.
Shared operations for working atomically with a Ruby object's variable table.
Node that represents an assignment of either an array element or attribute.
Predefined keys for an attribute map that ScriptingContainer has.
A method type for attribute writers (as created by attr_writer or attr_accessor).
A method type for attribute writers (as created by attr_writer or attr_accessor).
Regexp back reference:
- $& last successful match
- $+ highest numbered group matched in last successful match.
This interface should be implemented by writers of Java extensions to JRuby.
Begin/End block.
Represents a literal Bignum.
Represents a big integer literal.
Created by headius on 10/23/14.
Convenience interface for operations which only have two nodes
Internal live representation of a block ({...} or do ...
Represents bidirectional, both Java and Ruby, variables.
Defines a type correspond to Ruby's variables and constant types.
Ruby-Java bi-directional variable map implementation.
Internal live representation of a block ({...} or do ...
Any thing which implements this represents a Callable-like node which can have a block
associated with it as part of that call.
An explicit block argument (&my_block) in parameter list.
The executable body portion of a closure.
A simple interface for creating a callback using JRuby's block logic.
A call to block_given? which can be optimized like defined?(yield) or a regular call.
Represents a defined?(yield) check, which works like a call to block_given? without
requiring special access to the caller's frame.
Perform an optimized block_given? check without accessing a caller's frame.
A Utility class to emulate blocking I/O operations on non-blocking channels.
Represents a block of nodes (read that as list).
Explicit block argument (on caller side):
foobar(1, 2, &foo)
foobar(1, 2, &lhs_which_returns_something_block/proc_like)
bodyNode is any expression which can return something which is ultimately
coercible to a proc.
Represents a 'break' statement.
Represents a multiple-target jump instruction based on a switch-like table
Reference to common builtin types we care about: Object, Array, Hash.
This implementation of
ProfilingService will be used for all profiling methods
which are shipped with jruby.ByteList is simple a collection of bytes in the same way a Java String is a collection
of characters.
Helpers for working with bytelists.
Lexer source for ripper when we have all bytes available to us.
Indicates this method implementation can be used to generate a cacheable method
Method selection logic for calling from Ruby to Java.
A cache of "callables" based on method signature hash.
Deprecated.
Defines a C callback's parameters and return type.
Manages Callback instances for the low level FFI backend.
A Block implemented using a Java-based BlockCallback implementation.
A Block implemented using a Java-based BlockCallback implementation.
A method or operator call.
This is the abstract superclass for all call sites in the system.
A Case statement.
A flow-control exception used internally for Ruby's catch/throw functionality.
Representation of available option categories, with a short name to use
in printing descriptions.
Represents the base build of a CFG.
This produces a linear list of BasicBlocks so that the linearized instruction
list is in executable form.
Created by headius on 5/24/14.
Helper that attempts to improve Channels' static helpers.
The ClassExtensionLibrary wraps a class which implements BasicLibraryService,
and when asked to load the service, does a basicLoad of the BasicLibraryService.
An enum of core JRuby classes.
A class statement (name, superClass, body).
Created by headius on 10/23/14.
Created by headius on 10/23/14.
Utility functions for working with Java classes and their Ruby proxies.
Represents a cache or other mechanism for getting the Ruby-level proxy classes
for a given Java class.
Calculate a value based on an incoming class.
Class variable assignment node.
Deprecated.
An implementation of BiVariable for a Ruby class variable.
Access to a class variable.
Base class for cloning context object.
Marks instrs that accept closure args.
Interpreter knowledge needed to interpret a closure.
This represents a non-temporary variable used in a closure
and defined in this or a parent closure.
Representation of code (executable) memory blocks
Represents a bare class declaration (e.g.
Represents a '::' constant access or method call (Java::JavaClass).
Global scope node (::FooBar).
Values which are referenced in multiple places.
Blocks and methods both share same full build mechanism so they implement this to be buildable.
Load serialized IR from the .class file requested.
A mechanism for executing code against an IRScope or transforming the
IRScopes dependent data.
To get information about all phases of executing a compiler pass.
Represents a Complex literal.
Used by reified classes, this class is tightly coupled with RealClassGenerator, splitInitialize, & finishInitialize
Do not refactor without looking at RCG
Manually added as an override of `new` for Concrete Extension
Represents a Ruby ConcurrencyError as a throwable Java exception.
Concurrent type local context provider.
A hash table with weak keys, full concurrency of retrievals, and
adjustable expected concurrency for updates.
The "ConditionVariable" class from the 'thread' library.
An implementation of BiVariable for a Ruby constant.
A tuple representing the data needed to verify a cached constant:
The value of the constant
The generation of the constant's invalidator at the time of caching
The constant's invalidator
(Optional) the hashcode of the module form which the constant was cache
Created by headius on 2/26/15.
A validator specific to how we manage Ruby constants.
Represents an object that can produce a JIT-optimizable "constant" version of itself.
Created by headius on 1/31/16.
Declaration (and assignment) of a Constant.
The access to a Constant.
Created by headius on 10/23/14.
Common type for all block types which share similar values that ThreadContext uses.
Conversion utilities.
API's which can be used by embedders to construct Ruby builtin core types.
Native part for `require 'jruby/core_ext.rb'`.
Implementation of Ruby 1.9.2's "Coverage" module
A ThreadFactory for when we're using pooled threads; we want to create
the threads with daemon = true so they don't keep us from shutting down.
An assignment to a dynamic variable (e.g.
Converts data from one FFI type to another.
DataType is similar to T_DATA to represent types which are incapable of getting
marshalled.
This is only used for active debugging and should never end up showing up in real executed code.
Methods which help extension authors define their extension.
An enum for all "defined?" messages.
a defined statement.
Supports optimization for define_method.
method definition node.
Methods and blocks both implement these.
Represents a singleton method definition.
For Operands which can be accessed from nested scopes we sometimes need to adjust them
for different depths.
An aggregate data object based on a collection of MethodDescriptors.
This class exists as a counterpart to the dir.c file in
MRI source.
Base class for all D (e.g.
Represents a Ruby DomainError as a throwable Java exception.
Represents a range literal.
A carrier object with two fields
A regexp which contains some expressions which will need to be evaluated every time the regexp
is used for a match.
Created by headius on 10/23/14.
A string which contains some dynamic elements which needs to be evaluated (introduced by #).
Node representing symbol in a form like ':"3jane"'.
This factory extends InvocationMethodFactory by also dumping the classes to
.class files at runtime.
Access a dynamic variable (e.g.
Dynamic backquote string.
DynamicMethod represents a method handle in JRuby, to provide both entry
points into AST and bytecode interpreters, but also to provide handles to
JIT-compiled and hand-implemented Java methods.
A generator for DynamicScope subclasses, using fields for storage and specializing appropriate methods.
Wrapper interface of
JavaEmbedUtils.EvalUnit for embedding.Implementation of org.jruby.javasupport.JavaEmbedUtils.EvalUnit for embeddiing.
This interface defines methods to configure Ruby runtime for embedding.
This interface defines a method to get a instance of requested interface, which
is implemented in Ruby.
The implementation of
EmbedRubyInterfaceAdapter and implements the
method that gets a instance of requested interface, which is implemented in Ruby.Wrapper interface of RubyObjectAdapter for embedding.
Implementation of
EmbedRubyObjectAdapter.Deprecated.
Wrapper interface of
RubyRuntimeAdapter for embedding.Represents a Ruby EncodingError as a throwable Java exception.
Represents a Ruby CompatibilityError as a throwable Java exception.
Represents a Ruby ConverterNotFoundError as a throwable Java exception.
Represents a Ruby InvalidByteSequenceError as a throwable Java exception.
Represents a Ruby UndefinedConversionError as a throwable Java exception.
Represents __ENCODING__.
Fallback function to provide replacements for characters that fail to transcode.
An 'ensure' statement.
Enumerable#to_set (from require 'set')
Represents a C enum
Represents a Ruby EOFError as a throwable Java exception.
This class is a generic unchecked exception raised during evaluating.
Code evaluation type
Changed event hook to an enum that manages a collection of event handlers.
Represents an #{} expression in a string.
Represents a Ruby Exception as a throwable Java exception.
A version of MethodDescriptor that works against ExecutableElement during compile time annotation processing.
InterpreterEngine capable of exiting part way through execution up to a particular instruction.
Methods annotated with this are blessed Native Extension APIs.
A factory that can create a FFI Provider
Represents a false literal.
Represents a RubyFatal as a throwable Java exception.
Represents a method call with self as an implicit receiver.
Populates all the constants for Fcntl from Constantine
The holder of all per-ruby-runtime FFI data
Some utility functions for FFI <=> jffi conversions
Represents a Ruby FiberError as a throwable Java exception.
A RubyThread-aware BlockingQueue wrapper used by Fiber for transferring values.
Created by headius on 2/26/15.
Java field setter (writer) base implementation e.g.
Java field getter (reader) base implementation e.g.
A variable accessor that accesses a field directly;
An implementation of ByteChannel that reads from and writes to a native unix
file descriptor.
An IO implementation that reads/writes to a native file descriptor.
Represents the script's __FILE__.
Represents __FILE__ nodes
Utilities for working with native fileno and Java structures that wrap them.
An almost entirely useless interface for those objects that we _really_ want
to finalize.
Marker interface to allow persistence to know whether operand arity is fixed or variable
Represents an integer literal.
Created by headius on 10/23/14.
This class serves as a registry of all bit flags we use on JRuby objects.
A Range in a boolean expression (named after a FlipFlop component in electronic?).
Represents a Ruby FloatDomainError as a throwable Java exception.
Represents a float literal.
Created by headius on 10/23/14.
A 'for' statement.
A Frame holds per-call information that needs to persist outside the
execution of a given method.
A call to __method__ or __callee__ which can be optimized to use the frame method name directly.
Perform an optimized __method__ or __callee__ invocation without accessing a caller's frame.
Represents a Ruby FrozenError as a throwable Java exception.
Represents a frozen string value.
Created by enebo on 2/27/15.
An aggregate interface for
Function and BiFunction that properly replaces the default
FunctionOneOrTwoOrThree.andThen(Function) for both superinterfaces.A
GenericMap is simply an abstract java.util.Map
implementation for which subclasses really only need to implement
the method entryIterator.Encapsulation of the prepare_getline_args logic from MRI, used by StringIO and IO.
Lexer source from ripper getting a line at a time via 'gets' calls.
Represents an assignment to a global variable.
An implementation of BiVariable for a Ruby global variable.
access to a global variable.
A DynamicMethod backed by one or more java.lang.invoke.MethodHandle objects.
A Literal Hash that can represent either a {a=&b, c=&d} type expression or the list
of default values or kwarg in a method call.
Helper methods which are called by the compiler.
Wraps the target method_missing implementation, passing the called method name as a leading symbol argument.
A lexing unit for scanning a heredoc element.
A lexing unit for scanning a heredoc element.
Does the node contain an argument list?
Deprecated.
an 'if' statement.
Not a double visitor but I did not want both instr and dirgra
to have this visitor have an accept added to it.
Created by enebo on 1/28/17.
Created by enebo on 1/28/17.
Created by enebo on 1/28/17.
A marker for literal nodes.
Operands extending this type can make a reasonable assumption of
immutability.
This class is used to provide an intermediate superclass for modules and classes that include
other modules.
Represents a Ruby IndexError as a throwable Java exception.
Annotation processor for generating "populators" to bind native Java methods as Ruby methods, and
to gather a list of classes seen during compilation that should have their invokers regenerated.
Created by headius on 2/26/15.
Context object when performing an inline.
This represents a linenumber instr that has been inlined into another method/closure.
Use mark to make a safe rewindable cursor.
Created by headius on 2/26/15.
Created by headius on 2/26/15.
Created by headius on 2/26/15.
Created by headius on 10/23/14.
Created by headius on 10/23/14.
An implementation of BiVariable for a Ruby instance variable.
Visitor to search AST nodes for instance variables.
Interface that represents the instance variable aspect of Ruby
objects.
Represents an instance variable assignment.
Represents an instance variable accessor.
Interface that gives access to the internal variables of a Ruby
object.
Marker Enumeration for indicating which methods in the IR are for runtime
use versus compiler use.
Created by enebo on 2/6/15.
Method for -X-C (interpreted only execution).
Base full interpreter.
Represents a Ruby Interrupt as a throwable Java exception.
Represents a Ruby InterruptedRegexpError as a throwable Java exception.
Abstract invalidator of "something".
An implementation of MemoryIO that throws an exception on any access.
Marker interface for nodes invisible to IDE consumers
Bootstrapping logic for invokedynamic-based invocation.
In order to avoid the overhead with reflection-based method handles, this
MethodFactory uses ASM to generate tiny invoker classes.
This invoker uses MethodHandle for all bindings to Java code, rather than generating
stubs or using reflection.
This class is a generic unchecked exception raised during calling methods and
invoking interface methods which are implemented by Ruby scripts.
Created by headius on 10/23/14.
Wrap an IO object in a Channel.
A
ReadableByteChannel wrapper around an IO-like Ruby object.A
ReadableByteChannel and WritableByteChannel wrapper around an IO-like Ruby object.A
WritableByteChannel wrapper around an IO-like Ruby object.Represents an IO encodable object.
Represents a Ruby IOError as a throwable Java exception.
This class wraps a IRubyObject in an InputStream.
FFI specific I/O routines
Represents a combination of stream-opening flags (ModeFlags) and encoding
settings (EncodingOption).
This class wraps a IRubyObject in an OutputStream.
Represents a 'for' loop
Created by headius on 3/10/16.
Represents a method object that can return a Signature and an array of ArgumentDescriptors.
Right now, this class abstracts the following execution scopes:
Method, Closure, Module, Class, MetaClass
Top-level Script, and Eval Script
In the compiler-land, IR versions of these scopes encapsulate only as much
information as is required to convert Ruby code into equivalent Java code.
Created by enebo on 2/25/14.
Abstract class that contains general logic for both IR Compiler and IR Interpreter
Object is the parent class of all classes in Ruby.
Superclass for IR visitors.
Write IR data out to persistent store.
Names are tough to find.
Represents a file which is persisted to storage.
A marker interface for scoped variables (which have an offset and depth).
The IsolatedScriptingContainer does set GEM_HOME and GEM_PATH and JARS_HOME
in such a way that it uses only resources which can be reached with classloader.
This interface is the combination of two needs: 1) A Ruby interpreter position (for warnings
and errors).
Represents a block.
A specialized "main" entry point that assumes it will run a specific file
(jar-bootstrap.rb) when launching.
Loading of Ruby scripts packaged in Jar files.
Used for concrete reified classes.
Deprecated.
since 9.4
Deprecated.
since 9.3
Configuration for Reified classes, both normal, and java concrete extension
Utility functions to help embedders out.
All implementers can be run and will return the last value in the evaluation unit.
An evaluation unit which is based on running JRuby's interpreter (as opposed to the
compiler).
Lazy Java class extensions initialization.
Deprecated.
Represents a special Java implementation of a block.
java.io package Ruby additions.Java::JavaLang package extensions.
Java::JavaLangReflect package extensions.
Java::JavaMath package extensions.
java.net package Ruby additions.java.nio package additions.Deprecated.
since 9.4
A "thin" Java package wrapper (for the runtime to see them as Ruby objects).
Generalized proxy for classes and interfaces.
This class is a scanner generated by
JFlex 1.7.0
from the specification file
core/src/main/java/org/jruby/lexer/JavaSignatureLexer.flexA collection of all call sites used for dynamic calls from JRuby's Java code.
Internal APIs of
JavaSupport.Note: Internal API - subject to change!
Java::JavaTime package extensions.
Java::JavaUtil package extensions.
Deprecated.
Java::JavaLangReflect package extensions.
This class gets specially loaded directly in the JRubyClassLoader so that
we can unregister all JDBC drivers that were loaded/registered.
Marker Enumeration for indicating which methods in the IR are for runtime
use versus compiler use.
This annotation defines a method that we endorse as a usable method for methods which
do not live specifically in the org.jruby.api package space.
this classloader will be populated dynamically in the following ways:
JRuby.runtime.jruby_class_loader.add_url( java.net.URL.new( "file:my.jar" )
$CLASSPATH << 'path/to/class/or/resources'
require 'some.jar'
load 'some.jar'
so it is the classloader for ALL the jars used by gems.This is a concrete class for javax.script.CompiledScript.
Implementation of javax.script.ScriptEngine/Compilable/Invocable.
This class implements javax.script.ScriptEngineFactory.
This file acts as an alternative to NormalizedFile, due to the problems with
current working directory.
Native part of require 'jruby', e.g.
JRuby::CONFIG
Deprecated.
Closest thing to JRubyClassLoader's addURL but for OSGi bundles.
This is a substitute of javax.script.ScriptEngineManager.
Utilities library for all those methods that don't need the full 'java' library
to be loaded.
Deprecated.
Logger which delegates to
Logger.This class should be used for performance reasons if the
Exception don't need a stack trace.
Simple interface so we can ask for jump label for branches or jumps
Implementation of IRCompiler for the JVM.
Context for JITing methods.
Kernel added Java short-cut methods.
Represents a Ruby KeyError as a throwable Java exception.
Simple key-value pair object.
Stubby lambda node (1.9 only)
Created by headius on 10/23/14.
Simple source capable of providing the next line in Ruby source file being lex'd.
Code and constants common to both ripper and main parser.
All Nodes which have a list representation inherit this.
This is not a node in the classic sense in that it has no defined or
interpret method which can be called.
This represents the same function as NODE_LIT in MRI.
Load the block passed to this scope via the on-heap frame (or similar cross-call structure).
Created by cmeier on 7/30/15.
Represents a Ruby LoadError as a throwable Java exception.
Load the block passed to this scope via the on-heap frame (or similar cross-call structure).
Load the "implicit" closure for this scope.
How require works in JRuby
Simple struct to capture name separate from URL.
An assignment to a local variable.
LocalContextProvider provides an instance of
LocalContext from
a specified scope defined by LocalContextScope.LocalContextState defines four scopes to maintain
LocalContext.An implementation of BiVariable for JSR223 style global variable.
Represents a Ruby LocalJumpError as a throwable Java exception.
Access a local variable
Class used to launch the interpreter.
Represents the the dynamic portion of scoping information.
A simple Map-based cache of proxies.
A proxy for wrapping
java.util.Map instances.A type which represents a conversion to/from a native type.
Deprecated, for removal: This API element is subject to removal in a future version.
Marshals objects into Ruby's binary marshal format.
Unmarshals objects from strings or streams in Ruby's marshal format.
Deprecated, for removal: This API element is subject to removal in a future version.
Used when a Regexp literal is the RHS of a match call.
Abstracted memory operations.
Get a list of argument descriptors in prefixed form.
Represents a method wrapped in a block (proc), as in Method#to_proc.
Abstraction of all metadata about a method.
Base class for DefnNode and DefsNode
Implementations of this interface will be used to enhance methods with profiling information/ callbacks.
Common method factory definitions
MethodFactory is used to generate "invokers" or "method handles" given a target
class, method name, and other characteristics.
Created by headius on 2/26/15.
Represents Ruby method names invoked dynamically from Java Code.
Java Method signature declaration
This file represents the POSIX-like mode flags an open channel (as in a
ChannelDescriptor) can have.
valid method declaration modifiers
Module Java extensions, namely java_import and include_package.
Represents a module definition.
This instruction will be generated whenever speculative optimizations are performed
based on assuming that an object's metaclass is C (as determined by the version number
of C -- where the version number changes every time C's class structure changes).
Single type call site
Deprecated MRI-style recursion guard logic pulled out of
Ruby.Deprecated.
Represents a literal string value.
The "Mutex" class from the 'thread' library.
Created by headius on 2/26/15.
Represents a Ruby NameError as a throwable Java exception.
Created by headius on 8/1/15.
Deprecated.
Native types
Note: This is a dead class but we leave it because people write against Visitor
and we do not want those consumers to break.
Represents a 'next' statement.
Represents nil.
A node which behaves like a nil node, but is not actually present in the AST as a syntactical
element (e.g.
represents 'nil'
Base class for all Nodes in the AST
Visitor interface to be implemented by visitors of the jRuby AST.
An instance of Factory that is used when no FFI implementation can be found.
Represents a Ruby ArgumentError as a throwable Java exception.
Represents a Ruby ArgumentError as a throwable Java exception.
Represents a Ruby NoMemoryError as a throwable Java exception.
Represents a Ruby NoMethodError as a throwable Java exception.
A lock-free alternate implementation of
ConcurrentHashMap
with primitive long keys, better scaling properties and
generally lower costs.Marker interface for return, break, next, redo, retry
An instr with no Operands
result instr with no operands
For Instrs with an arbitrary number of Operands.
Created by enebo on 7/28/15.
Deprecated.
replaced with
MonomorphicCallSiteCreated by headius on 10/23/14.
This class provides a File implementation that normalizes all path separators to forward slashes.
Represents a Ruby NotImplementedError as a throwable Java exception.
Represents a $number ($0..$9) variable.
Represents Block.NULL block, the block that cannot be yielded.
An implementation of MemoryIO that throws an exception on any access.
This class represents a singleton type of method used as a marker for
breaking method lookup loops.
A Warnings implementation which silently ignores everything.
Any node representing a numeric value.
An allocator for a Ruby object.
Flags used by RubyBasicObject descendants.
Deprecated, for removal: This API element is subject to removal in a future version.
Maps Java objects to their proxies.
FIXME: This version is faster than the previous, but both suffer from a
crucial flaw: It is impossible to create an ObjectSpace with an iterator
that doesn't either: a.
Created by enebo on 7/27/15.
Result Instr with one operand.
Represents a class loader designed to load exactly one class.
A::B ||= 1
Represents an operator assignment to an element.
Options defines all configuration settings for JRuby in a consistent form.
A set of factory methods to construct optimizing utilities for compilation,
cache invalidation, and so on.
A factory for abstract "constant" representations of objects.
represents '||' (or) statements
Various introspection tricks to access the file system from OSGi.
Attempt at making an osgi bundle an acceptable container for a jruby library
TODO: track the state of the bundle and remove/add the library.
Helper methods for the Ruby Runtime.
adds some helper methods to add Bundle to the LOAD_PATH or GEM_PATH using the
IsolatedScriptingContainer as base.
Load scripts and java classes directly from the OSGi bundles.
Helpers to create a ScriptingContainer and set it up so it lives as well
as possible in the OSGi world.
Logger logging to an output (print) stream.
Utility methods to generate the command-line output strings for help,
extended options, properties, version, and copyright strings.
Represents Java (callable) parameter types
This class is a generic unchecked exception raised during parsing.
Serves as a simple facade for all the parsing magic.
Front-end API to parsing Ruby source.
Provides parser and builder instances.
This is similar to
DelegatingDynamicMethod except that it does not delegate most properties of DynamicMethod.The path type that tells from where Ruby runtime should load the specified file.
A Case statement.
Perl's Hash implementation.
An implementation of BiVariable for a persistent local variable.
Platform specific constants.
C memory pointer operations.
Port of MRI's popen+exec logic.
Simple no-pojo methods for Position of a method (in truth we could use
this anywhere).
Created by headius on 7/22/14.
Representations of as many native posix functions as possible applied to an NIO channel
Captures END statements (END {...})
A pre-execution construction (BEGIN { ...
A pre-execution construction (BEGIN { ...
This class is used as an intermediate superclass for Module#prepend.
For Java primitive types: byte, short, int, long, char, float, double, boolean, void
Assigned names only override based priority of an assigned type, the type must be less than
or equal to the assigned type.
Each
ThreadContext has an ProfileCollection property in profile mode.Encapsulates the logic of recording and reporting profiled timings of
method invocations.
A dynamic method + it's invocation name holder for profiling purposes.
This is a collection af all methods which will be profiled.
The used
ProfilingService will create an instance of this class
at the end of each RubyThread or at jruby shutdown the ProfileReporter.report(ProfileCollection)
is called with the ProfileCollection associated with the current Thread.An interesting callsite in which we will look for monomorphic behavior in case we want to inline.
A DynamicMethod wrapper that performs timed profiling for each call.
A ProfilingService is used to profile jruby programs.
This helper is used to get the configured
ProfilingService for the current Ruby instance.Predefined keys of System properties to get configurations
The "Queue" class from the 'thread' library.
Literal Range with literal endpoints.
Represents a Ruby RangeError as a throwable Java exception.
Literal Rational number.
A variable accessor that accesses a reified java field directly (Storing java objects that may not be IRubyObjects
A ReaderInputStream converts java.io.Reader to java.io.InputStream.
Represents a buffer overflow (too much data returned) when calling `readpartial` on an IO-like object.
On fly .class generator (used for Ruby interface impls).
Gets the keyword arg (or representation of what might be holding keyword args).
This represents a required arg that shows up after optional/rest args
in a method/block parameter list.
Represents a 'redo'
A general purpose reference tracker & reaper utility class.
A DynamicMethod wrapper that performs timed profiling for each call.
A DynamicMethod wrapper that performs timed profiling for each call.
Represents a literal regexp from ruby, constructed on first traversal and then cached.
Represents a Ruby RegexpError as a throwable Java exception.
Represents a simple regular expression literal.
Created by headius on 10/23/14.
Marker interface for generated Java classes that represent a reified Ruby
class (i.e.
Interface is implemented by proxies generated from a JavaProxyClass.
Marker to indicate that rather than assigning nil (where in multiple
places we have nulls getting implicitly converted to nils) we should
raise an error.
Represents the contents of a rescue to be evaluated
f rescue nil
Represents a rescue statement
Created by headius on 10/23/14.
Note: Private API that might get removed later.
Deprecated.
For most instrs that have a result this is their base class.
Represents a 'retry' statement.
Represents a return statement.
Represents the top of the AST.
The Ruby object represents the top-level of a JRuby "instance" in a given VM.
The Java representation of a Ruby ArgumentError.
Implements Enumerator::ArithmeticSequence
The implementation of the built-in class Array in Ruby.
One object version of RubyArraySpecialized.
This is the base class for all specialized RubyArray.
Two object version of RubyArraySpecialized.
RubyBasicObject is the only implementation of the
IRubyObject.Class that keeps track of the finalizers for the object under
operation.
Implementation of the BasicSocket class from Ruby.
Implements Enumerator::Chain
Implementation of the Comparable module.
complex.c as of revision: 20011
The Java representation of a Ruby ConcurrencyError.
Deprecated.
Deprecated.
JRuby's
Date implementation - 'native' parts.This class has
StrptimeParser and provides methods that are calls from JRuby.JRuby's
DateTime implementation - 'native' parts.The Ruby built-in class Dir.
/**
The Java representation of a Ruby DomainError.
The Java representation of a Ruby EncodingError.
The implementation of Ruby's Enumerable module.
Implementation of Ruby's Enumerator module.
Internal Enumerator::FeedValue class to be shared between enumerator and its next-er Fiber.
"Function" type for java-created enumerators with size.
The Java representation of a Ruby EOFError.
The Java representation of a Ruby Fatal.
The Java representation of a Ruby FiberError.
The Ruby File class.
Implements File::Stat
MRI defines the FileTest methods both as module functions on FileTest and
as singleton methods on the File class.
Implementation of the Integer (Fixnum internal) class.
A representation of a float object
The Java representation of a Ruby FloatDomainError.
The Java representation of a Ruby FrozenError.
GC (Garbage Collection) Module
Note: Since we rely on Java's memory model we can't provide the
kind of control over garbage collection that MRI provides.
This class initializes global variables and constants.
Obligate string-keyed and string-valued hash, used for ENV.
A Pseudo-hash whose keys and values are required to be Strings.
Implementation of the Hash class.
The Java representation of a Ruby IndexError.
A structure used to configure new JRuby instances.
Implementation of the Integer class.
The Java representation of a Ruby Interrupt.
The Java representation of a Ruby InterruptedRegexpError.
Represents a Ruby IO::TimeoutErrorError as a throwable Java exception.
The Java representation of a Ruby IOError.
Note: For CVS history, see KernelModule.java.
The Java representation of a Ruby LoadError.
The Java representation of a Ruby LocalJumpError.
Marshal module
Inner class to help with Γ functions
The RubyMethod class represents a RubyMethod object.
Deprecated.
Represents a constant value, possibly hidden (private).
Deprecated.
A wrapper CacheEntryFactory, for delegating cache entry creation along a chain.
The Java representation of a Ruby NameError.
Nested class whose instances act as thunks reacting to to_str method
called from (Exception#to_str, Exception#message)
MRI equivalent: rb_cNameErrorMesg, class name: "message", construction method: "!",
to_str implementation: "name_err_mesg_to_str"
TODO: this class should not be lookupable
A ThreadLike wrapped around a native Thread, for Ruby threads we start and control.
The Java representation of a Ruby ArgumentError.
The Java representation of a Ruby ArgumentError.
The Java representation of a Ruby NoMemoryError.
The Java representation of a Ruby NoMethodError.
The Java representation of a Ruby NotImplementedError.
Base class for all numerical types in ruby.
Deprecated.
Deprecated.
RubyObject represents the implementation of the Object class in Ruby.
Additional interface implemented by proxies that back Java interfaces by
Ruby objects so that we can get back to the original Ruby object from the proxy.
A code generator for Ruby objects, to map known instance variables into fields.
A wrapper for
OutputStream that throws no IOException, instead raising Ruby Exception (unchecked) via the
passed-in runtime.Implements Enumerator::Producer
Implementation of the Random class.
The Java representation of a Ruby RangeError.
Ruby Rational impl (MRI: rational.c).
The Java representation of a Ruby RegexpError.
The Java representation of a Ruby RuntimeError.
The Java representation of a Ruby ScriptError.
The Java representation of a Ruby SecurityError.
Native implementation of Ruby's Set (set.rb replacement).
The Java representation of a Ruby SignalException.
Native implementation of Ruby's SortedSet (set.rb replacement).
The Java representation of a Ruby StandardError.
/**
The Java representation of a Ruby StopIteration.
Implementation of Ruby String class
Concurrency: no synchronization is required among readers, but
all users must synchronize externally with writers.
Encoding aware String construction routines for 1.9
An FString is a frozen string that is also deduplicated and cached.
Helper methods to make Ruby Strings without the ceremony of manually building the string up.
Represents a Ruby symbol (e.g.
The Java representation of a Ruby SyntaxError.
The Java representation of a Ruby SystemCallError.
The Java representation of a Ruby SystemExit.
The Java representation of a Ruby SystemStackError.
Implementation of Ruby's
Thread class.Deprecated.
Thread statuses
The Java representation of a Ruby ThreadError.
Implementation of Ruby's
ThreadGroup class.The Time class.
Support for GNU-C output formatters, see: http://www.gnu.org/software/libc/manual/html_node/Formatting-Calendar-Time.html
The Java representation of a Ruby TypeError.
An unbound method representation (e.g.
The Java representation of a Ruby UncaughtThrowError.
The Java representation of a Ruby ZeroDivisionError.
Represents a Ruby RuntimeError as a throwable Java exception.
Deprecated.
A safer way to parse double values
A safer way to parse float values
Utility class to safely access system properties in security-sensitive
environments.
Singleton class definition.
Reference a StaticScope/IRScope.
Each scope while parsing contains extra information as part of the parsing process.
Wrap a scope for the purpose of finding live module which happens to be associated with it.
Represents an executable Script object and the bytecode that goes with it.
ScriptingContainer provides various methods and resources that are useful
for embedding Ruby in Java.
Search for a constant within the current module.
Represents a Ruby SecurityError as a throwable Java exception.
Created by headius on 6/3/14.
This is a simple implementation of a hard-referenced java.nio.channels.Selector
pool.
Created by headius on 10/23/14.
Represents 'self' keyword
This mess of a class is what happens when all Java gives you is
Runtime.getRuntime().exec().
Created by enebo on 9/26/15.
Represents a Ruby SignalException as a throwable Java exception.
A representation of a Ruby method signature (argument layout, min/max, keyword layout, rest args).
Context info for simple cloning operation.
A carrier object with a single boolean
A carrier object with a single double
A carrier object with a single int
A carrier object with a single long
A carrier object with a single field
Singleton type local context provider.
Created by headius on 2/26/15.
SipHash implementation with hand inlining the SIPROUND.
Represents a site for a call or yield.
Created by headius on 7/8/16.
The "SizedQueue" class from the 'thread' library.
Using SLF4J API as a logging backend.
Encapsulates behavior across the primary socket types Socket,
ServerSocket, and Datagramsocket.
Socket class methods for addresses, structures, and so on.
A variable accessor that uses a stamped volatile int and Unsafe methods to
ensure thread-friendly table updating.
Represents a RubyStandardError as a throwable Java exception.
Default JRuby logger implementation, using System.err.
Represents the unassignable star in a multiple assignent (e.g.
This interpreter is meant to interpret the instructions generated directly from IRBuild.
Created by headius on 2/26/15.
Created by headius on 2/26/15.
Created by headius on 2/26/15.
StaticScope represents lexical scoping of variables and module/class constants.
Gives instances of static scopes based on compile mode.
Represents a Ruby StopIteration as a throwable Java exception.
Represents an Operand that has a Java string form.
An RubyArray that maintains an O(1) Set for fast include? operations.
rb_str_tr / rb_str_tr_bang
tr_setup_table
Representing a simple String literal.
This class is a scanner generated by
JFlex 1.4
on 6/16/17 3:03 PM from the specification file
core/src/main/java/org/jruby/lexer/StrptimeLexer.flexThis is Java implementation of ext/date/date_strptime.c in Ruby 2.3.1.
Ported Date::Format::Bag from lib/ruby/stdlib/date/format.rb in JRuby 9.1.5.0.
This class is ported from RubyDateFormatter.Token in JRuby 9.1.5.0.
Defines the memory layout for a native structure.
A struct member.
A class that performs some subnet calculations given a network address and a subnet mask.
Created by headius on 10/23/14.
A call to super(...) with arguments to a method.
The characters within a Symbol can represent concepts in Ruby.
Represents a symbol (:symbol_name).
Created by headius on 10/23/14.
A literal representing proc'ified symbols, as in &:foo.
Represents a Ruby SyntaxError as a throwable Java exception.
Represents a Ruby SystemCallError as a throwable Java exception.
Represents a RubySystemExit as a throwable Java exception.
A java.lang.Map that defers all methods to System properties.
Utility methods to retrieve System properties or environment variables to
get configuration parameters.
Represents a temporary variable for an unboxed Boolean operand.
Represents a temporary variable for an unboxed Fixnum operand.
Represents a temporary variable for an unboxed Float operand.
Represents a temporary variable for an unboxed int operand.
When we optimize full local variables to be temporary ones we like to keep the name
of what we renamed them as.
A set of variables which are only used in a particular scope and never
visible to Ruby itself.
This enum exists because we will frequently run into an arbitrary temporary variable
and we want to be able to quickly switch on type.
Represents a Runnable that can report what Java thread it is running under.
Represents a Ruby ThreadError as a throwable Java exception.
A thread-based implementation of Ruby 1.9 Fiber library.
ThreadService maintains references to all JRuby-specific thread data structures
needed for Ruby's threading API and for JRuby's execution.
Deprecated.
Time's extensions from `require 'date'`
This is utility class to convert given timezone into integer based timezone
diff.
This instruction toggles a single per thread field which specifies whether an exception
being thrown needs to generate backtrace info.
Instrumented trace.
An implementation of BiVariable for a transient local variable.
A ByteArrayOutputStream that provides access to the contained byte[] buffer.
It consumes three things.
Extension of
BiFunction to three arguments.Represents 'true'.
Instr for two operands.
Result Instr with two operands.
Represents a Ruby TypeError as a throwable Java exception.
Base class for all typed nodes
Represents a Ruby UncaughtThrowError as a throwable Java exception.
This class represents a singleton type of method used as a marker for
missing or "undef'ed" methods.
For argument processing.
Represents an 'undef' statement.
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated, for removal: This API element is subject to removal in a future version.
a bare '*' or nothing.
This marker interface is for JRuby internal exceptions that can't be caught
by Ruby exception handling.
Created by headius on 10/23/14.
Created by headius on 10/23/14.
Represents an until statement.
All this because URL.getPath sucks, and we can't re-open classes in Java ;-).
A collection of JSR223 specific utility methods.
Represents an alias of a global variable.
Abstraction of an accessor for instance or internal variables on Ruby
objects.
A lazy mechanism for accessing VariableAccessors for a given variable name.
This class is responsible to local variable behavior dependent processing.
This class encapculates all logic relating to the management of instance
variable tables in RubyBasicObject instances.
RubyMethod call without any arguments
A simple set that uses weak references to ensure that its elements can be garbage collected.
Class
WeakIdentityHashMap is a hash map that hashes
objects based on System.identityHashMap, and holds weakly onto the
key.Map-like that holds its values weakly and uses object identity for keys.
Map-like that holds its values weakly (backed by a concurrent hash map).
Represents a when condition
Represents a while statement.
A binding of a few key win32 functions we need to behave properly.
A WriterOutputStream converts java.io.Writer to java.io.OutputStream.
A Backtick(`) string
Represents a yield statement.
Created by headius on 1/8/16.
Stubbed out version of our own yydebug impl for debugging if we ever find the need.
zero length list
Represents a Ruby ZeroDivisionError as a throwable Java exception.
Created by headius on 10/23/14.
a call to 'super' with no arguments in a method.