Ruby

java.lang.Object
- org.jruby.Ruby

```
public final class Ruby
extends java.lang.Object
```
The Ruby object represents the top-level of a JRuby "instance" in a given VM. JRuby supports spawning multiple instances in the same JVM. Generally, objects created under these instances are tied to a given runtime, for such details as identity and type, because multiple Ruby instances means there are multiple instances of each class. This means that in multi-runtime mode (or really, multi-VM mode, where each JRuby instance is a ruby "VM"), objects generally can't be transported across runtimes without marshaling. This class roots everything that makes the JRuby runtime function, and provides a number of utility methods for constructing global types and accessing global runtime structures.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`Ruby.CallTraceFuncHook`
`private static class`	`Ruby.ExecRecursiveParams`
`static interface`	`Ruby.ObjectSpacer`
`private static class`	`Ruby.RecursiveError`
`static interface`	`Ruby.RecursiveFunction`

Field Summary

Fields
Modifier and Type	Field and Description
`private static java.util.regex.Pattern`	`ADDR_NOT_AVAIL_PATTERN`
`private java.util.Set<RubyModule>`	`allModules`
`private IRubyObject`	`argsFile`
`private RubyClass`	`argumentError` All the core classes we keep hard references to.
`private RubyClass`	`arrayClass` All the core classes we keep hard references to.
`private java.util.Stack<RubyProc>`	`atExitBlocks`
`private java.util.concurrent.atomic.AtomicInteger`	`backtraceCount`
`private RubyClass`	`basicObjectClass` All the core classes we keep hard references to.
`private BeanManager`	`beanManager`
`private RubyClass`	`bignumClass` All the core classes we keep hard references to.
`private RubyClass`	`bindingClass` All the core classes we keep hard references to.
`private boolean`	`booting`
`private java.util.Map<java.lang.String,java.util.Map<java.lang.String,java.lang.String>>`	`boundMethods`
`private java.util.concurrent.atomic.AtomicInteger`	`callerCount`
`private Ruby.CallTraceFuncHook`	`callTraceFuncHook`
`private RubyHash`	`charsetMap`
`private Invalidator`	`checkpointInvalidator`
`private ClassCache`	`classCacheBean`
`private RubyClass`	`classClass` All the core classes we keep hard references to.
`private RubyModule`	`comparableModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private RubyClass`	`complexClass` All the core classes we keep hard references to.
`private RubyClass`	`concurrencyError` All the core classes we keep hard references to.
`private RubyInstanceConfig`	`config`
`private Config`	`configBean`
`private java.util.concurrent.ConcurrentHashMap<java.lang.String,Invalidator>`	`constantNameInvalidators`
`private RubyClass`	`continuationClass` All the core classes we keep hard references to.
`private RubyClass`	`converterClass` All the core classes we keep hard references to.
`private RubyClass`	`converterNotFoundError` All the core classes we keep hard references to.
`private CoverageData`	`coverageData`
`private java.lang.String`	`currentDirectory`
`private int`	`currentLine`
`private boolean`	`debug`
`private org.jcodings.Encoding`	`defaultExternalEncoding`
`private org.jcodings.Encoding`	`defaultInternalEncoding`
`private DynamicMethod`	`defaultMethodMissing`
`private RubyRandom.RandomType`	`defaultRand`
`private RubyThreadGroup`	`defaultThreadGroup`
`private java.util.EnumMap<DefinedMessage,RubyString>`	`definedMessages`
`private RubyClass`	`dirClass` All the core classes we keep hard references to.
`private static Ruby.ObjectSpacer`	`DISABLED_OBJECTSPACE`
`private boolean`	`doNotReverseLookupEnabled`
`private RubyClass`	`dummyClass` All the core classes we keep hard references to.
`private java.util.concurrent.atomic.AtomicLong`	`dynamicMethodSerial`
`private static EventHook[]`	`EMPTY_HOOKS`
`private RubyArray`	`emptyFrozenArray`
`private static Ruby.ObjectSpacer`	`ENABLED_OBJECTSPACE`
`private RubyClass`	`encodingClass` All the core classes we keep hard references to.
`private RubyClass`	`encodingCompatibilityError` All the core classes we keep hard references to.
`private RubyClass`	`encodingError` All the core classes we keep hard references to.
`private EncodingService`	`encodingService`
`private RubyModule`	`enumerableModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private RubyClass`	`enumeratorClass` All the core classes we keep hard references to.
`private RubyHash`	`envObject`
`private RubyClass`	`eofError` All the core classes we keep hard references to.
`private java.io.PrintStream`	`err`
`static java.lang.String`	`ERRNO_BACKTRACE_MESSAGE`
`private RubyModule`	`errnoModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private java.util.Map<java.lang.Integer,RubyClass>`	`errnos`
`private RubyModule`	`etcModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private EventHook[]`	`eventHooks`
`private static java.util.EnumSet<RubyEvent>`	`EVENTS2_0`
`private RubyClass`	`exceptionClass` All the core classes we keep hard references to.
`private java.util.concurrent.atomic.AtomicInteger`	`exceptionCount`
`private java.util.concurrent.ExecutorService`	`executor`
`private RubyClass`	`falseClass` All the core classes we keep hard references to.
`private RubyBoolean`	`falseObject`
`private RubyClass`	`fatal` All the core classes we keep hard references to.
`private FFI`	`ffi`
`private RubyClass`	`fiberError` All the core classes we keep hard references to.
`private java.util.concurrent.ExecutorService`	`fiberExecutor`
`private RubyClass`	`fileClass` All the core classes we keep hard references to.
`private java.util.Map<java.lang.Integer,java.lang.Integer>`	`filenoExtIntMap`
`private java.util.Map<java.lang.Integer,java.lang.Integer>`	`filenoIntExtMap`
`private RubyClass`	`fileStatClass` All the core classes we keep hard references to.
`private RubyModule`	`fileTestModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private java.util.Map<Finalizable,java.lang.Object>`	`finalizers` A list of "external" finalizers (the ones, registered via ObjectSpace), weakly referenced, to be executed on tearDown.
`private java.lang.Object`	`finalizersMutex`
`RubyFixnum[]`	`fixnumCache`
`private RubyClass`	`fixnumClass` All the core classes we keep hard references to.
`private Invalidator`	`fixnumInvalidator`
`private boolean`	`fixnumReopened`
`private RubyClass`	`floatClass` All the core classes we keep hard references to.
`private RubyClass`	`floatDomainError` All the core classes we keep hard references to.
`private Invalidator`	`floatInvalidator`
`private boolean`	`floatReopened`
`private RubyModule`	`gcModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private boolean`	`globalAbortOnExceptionEnabled`
`private static Ruby`	`globalRuntime` The "global" runtime.
`private long`	`globalState`
`private GlobalVariables`	`globalVariables`
`private RubyClass`	`groupStruct` All the core classes we keep hard references to.
`private boolean`	`hasEventHooks`
`private RubyClass`	`hashClass` All the core classes we keep hard references to.
`private long`	`hashSeedK0` The runtime-local seed for hash randomization
`private long`	`hashSeedK1`
`private java.lang.Object`	`hierarchyLock`
`private java.io.InputStream`	`in`
`private RubyClass`	`indexError` All the core classes we keep hard references to.
`private java.lang.ThreadLocal<java.lang.Boolean>`	`inRecursiveListOperation`
`private java.lang.ThreadLocal<java.util.Map<java.lang.Object,java.lang.Object>>`	`inspect`
`private RubyClass`	`integerClass` All the core classes we keep hard references to.
`private java.util.Map<Finalizable,java.lang.Object>`	`internalFinalizers` A list of JRuby-internal finalizers, weakly referenced, to be executed on tearDown.
`private java.lang.Object`	`internalFinalizersMutex`
`private RubyClass`	`interrupt` All the core classes we keep hard references to.
`private RubyClass`	`interruptedRegexpError` All the core classes we keep hard references to.
`private RubyClass`	`invalidByteSequenceError` All the core classes we keep hard references to.
`private RubyClass`	`ioClass` All the core classes we keep hard references to.
`private RubyClass`	`ioError` All the core classes we keep hard references to.
`private IRManager`	`irManager`
`private boolean`	`is1_9`
`private boolean`	`is2_0`
`private JavaProxyClassFactory`	`javaProxyClassFactory`
`private JavaSupport`	`javaSupport`
`private JITCompiler`	`jitCompiler`
`private java.util.Set<Script>`	`jittedMethods`
`private JRubyClassLoader`	`jrubyClassLoader`
`private KCode`	`kcode`
`private RubyModule`	`kernelModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private RubyClass`	`keyError` All the core classes we keep hard references to.
`private RubyClass`	`loadError` All the core classes we keep hard references to.
`private LoadService`	`loadService`
`private RubyClass`	`localJumpError` All the core classes we keep hard references to.
`private RubyClass`	`locationClass` All the core classes we keep hard references to.
`private static Logger`	`LOG` The logger used to log relevant bits.
`private RubyModule`	`marshalModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private RubyClass`	`matchDataClass` All the core classes we keep hard references to.
`private RubyClass`	`mathDomainError` All the core classes we keep hard references to.
`private RubyModule`	`mathModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private RubyClass`	`methodClass` All the core classes we keep hard references to.
`private RubyClass`	`moduleClass` All the core classes we keep hard references to.
`private java.util.concurrent.atomic.AtomicInteger`	`moduleGeneration`
`private java.util.concurrent.atomic.AtomicInteger`	`moduleLastId`
`private RubyClass`	`nameError` All the core classes we keep hard references to.
`private RubyClass`	`nameErrorMessage` All the core classes we keep hard references to.
`private RubyClass`	`nativeException` All the core classes we keep hard references to.
`static int`	`NIL_PREFILLED_ARRAY_SIZE`
`private RubyClass`	`nilClass` All the core classes we keep hard references to.
`private RubyNil`	`nilObject`
`private IRubyObject[]`	`nilPrefilledArray`
`private RubyClass`	`noMemoryError` All the core classes we keep hard references to.
`private RubyClass`	`noMethodError` All the core classes we keep hard references to.
`private DynamicMethod`	`normalMethodMissing`
`private RubyClass`	`notImplementedError` All the core classes we keep hard references to.
`private RubyClass`	`numericClass` All the core classes we keep hard references to.
`private RubyClass`	`objectClass` All the core classes we keep hard references to.
`private ObjectSpace`	`objectSpace`
`private boolean`	`objectSpaceEnabled`
`private RubyModule`	`objectSpaceModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private Ruby.ObjectSpacer`	`objectSpacer`
`private java.io.PrintStream`	`out`
`private Parser`	`parser`
`private ParserStats`	`parserStats`
`private RubyClass`	`passwdStruct` All the core classes we keep hard references to.
`private jnr.posix.POSIX`	`posix`
`private RubyModule`	`precisionModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private DynamicMethod`	`privateMethodMissing`
`private RubyClass`	`procClass` All the core classes we keep hard references to.
`private RubyModule`	`processModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private RubyModule`	`procGIDModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private RubyClass`	`procStatusClass` All the core classes we keep hard references to.
`private RubyModule`	`procSysModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private RubyModule`	`procUIDModule` All the core modules we keep direct references to, for quick access and to ensure they remain available.
`private Profile`	`profile`
`private ProfiledMethods`	`profiledMethods`
`private ProfilingServiceLookup`	`profilingServiceLookup` Used to find the ProfilingService implementation to use.
`private DynamicMethod`	`protectedMethodMissing`
`private java.util.Random`	`random` The runtime-local random number generator.
`private RubyClass`	`randomClass` All the core classes we keep hard references to.
`private RubyClass`	`rangeClass` All the core classes we keep hard references to.
`private RubyClass`	`rangeError` All the core classes we keep hard references to.
`private RubyClass`	`rationalClass` All the core classes we keep hard references to.
`private GlobalVariable`	`recordSeparatorVar`
`private java.lang.ThreadLocal<java.util.Map<java.lang.String,RubyHash>>`	`recursive`
`private RubySymbol`	`recursiveKey`
`private RubyClass`	`regexpClass` All the core classes we keep hard references to.
`private RubyClass`	`regexpError` All the core classes we keep hard references to.
`private DynamicMethod`	`respondTo`
`private DynamicMethod`	`respondToMissing`
`private IRubyObject`	`rootFiber`
`private static java.util.concurrent.atomic.AtomicInteger`	`RUNTIME_NUMBER`
`private Runtime`	`runtimeBean`
`private RuntimeCache`	`runtimeCache`
`private RubyClass`	`runtimeError` All the core classes we keep hard references to.
`private int`	`runtimeNumber`
`private RubyClass`	`scriptError` All the core classes we keep hard references to.
`private RubyClass`	`securityError` All the core classes we keep hard references to.
`private static boolean`	`securityRestricted`
`private SelectorPool`	`selectorPool`
`private RubyClass`	`signalException` All the core classes we keep hard references to.
`private IRubyObject[]`	`singleNilArray`
`private boolean`	`siphashEnabled`
`private RubyClass`	`standardError` All the core classes we keep hard references to.
`private long`	`startTime`
`private StaticScopeFactory`	`staticScopeFactory`
`static java.lang.String`	`STOPIERATION_BACKTRACE_MESSAGE`
`private RubyClass`	`stopIteration` All the core classes we keep hard references to.
`private RubyClass`	`stringClass` All the core classes we keep hard references to.
`private RubyClass`	`structClass` All the core classes we keep hard references to.
`private DynamicMethod`	`superMethodMissing`
`private RubyClass`	`symbolClass` All the core classes we keep hard references to.
`private java.util.concurrent.atomic.AtomicInteger`	`symbolLastId`
`private RubySymbol.SymbolTable`	`symbolTable`
`private RubyClass`	`syntaxError` All the core classes we keep hard references to.
`private RubyClass`	`systemCallError` All the core classes we keep hard references to.
`private RubyClass`	`systemExit` All the core classes we keep hard references to.
`private RubyClass`	`systemStackError` All the core classes we keep hard references to.
`private RubyClass`	`threadClass` All the core classes we keep hard references to.
`private RubyClass`	`threadError` All the core classes we keep hard references to.
`private RubyClass`	`threadGroupClass` All the core classes we keep hard references to.
`private static java.lang.ThreadLocal<Ruby>`	`threadLocalRuntime` The "thread local" runtime.
`private ThreadService`	`threadService`
`private java.util.EnumMap<RubyThread.Status,RubyString>`	`threadStatuses`
`private RubyClass`	`timeClass` All the core classes we keep hard references to.
`private java.util.Map<java.lang.String,org.joda.time.DateTimeZone>`	`timeZoneCache`
`private RubyClass`	`tmsStruct` All the core classes we keep hard references to.
`private IRubyObject`	`topSelf`
`private RubyClass`	`trueClass` All the core classes we keep hard references to.
`private RubyBoolean`	`trueObject`
`private RubyClass`	`typeError` All the core classes we keep hard references to.
`private RubyClass`	`unboundMethodClass` All the core classes we keep hard references to.
`private RubyClass`	`undefinedConversionError` All the core classes we keep hard references to.
`private DynamicMethod`	`variableMethodMissing`
`private boolean`	`verbose`
`private IRubyObject`	`verboseValue`
`private java.util.concurrent.atomic.AtomicInteger`	`warningCount`
`private RubyWarnings`	`warnings`
`private boolean`	`warningsEnabled`
`private RubyClass`	`yielderClass` All the core classes we keep hard references to.
`private RubyClass`	`zeroDivisionError` All the core classes we keep hard references to.

Constructor Summary

Constructors
Modifier Constructor and Description

private Ruby(RubyInstanceConfig config)
Create and initialize a new JRuby runtime.

Constructors
Modifier	Constructor and Description
`private`	`Ruby(RubyInstanceConfig config)` Create and initialize a new JRuby runtime.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addBoundMethod(java.lang.String className, java.lang.String methodName, java.lang.String rubyName)`
`private void`	`addBuiltinIfAllowed(java.lang.String name, Library lib)`
`private Invalidator`	`addConstantInvalidator(java.lang.String constantName)`
`void`	`addEventHook(EventHook hook)`
`void`	`addFinalizer(Finalizable finalizer)`
`void`	`addInternalFinalizer(Finalizable finalizer)`
`private void`	`addLazyBuiltin(java.lang.String name, java.lang.String shortName, java.lang.String className)`
`void`	`addModule(RubyModule module)`
`(package private) void`	`addProfiledMethod(java.lang.String name, DynamicMethod method)` Deprecated. This should be an implementation detail of the ProfilingService and should remove from the Ruby class.
`void`	`addToObjectSpace(boolean useObjectSpace, IRubyObject object)`
`int`	`allocModuleId()`
`int`	`allocSymbolId()`
`private void`	`bootstrap()`
`CallbackFactory`	`callbackFactory(java.lang.Class<?> type)` Deprecated.
`void`	`callEventHooks(ThreadContext context, RubyEvent event, java.lang.String file, int line, java.lang.String name, IRubyObject type)`
`void`	`checkSafeString(IRubyObject object)` Deprecated.
`static void`	`clearGlobalRuntime()` Clear the global runtime.
`void`	`compileAndLoadFile(java.lang.String filename, java.io.InputStream in, boolean wrap)`
`private void`	`createSysErr(int i, java.lang.String name)` Creates a system error.
`RubyClass`	`defineClass(java.lang.String name, RubyClass superClass, ObjectAllocator allocator)` Define a new class under the Object namespace.
`RubyClass`	`defineClass(java.lang.String name, RubyClass superClass, ObjectAllocator allocator, CallSite[] callSites)` A variation of defineClass that allows passing in an array of subplementary call sites for improving dynamic invocation performance.
`private RubyClass`	`defineClassIfAllowed(java.lang.String name, RubyClass superClass)`
`RubyClass`	`defineClassUnder(java.lang.String name, RubyClass superClass, ObjectAllocator allocator, RubyModule parent)` Define a new class with the given name under the given module or class namespace.
`RubyClass`	`defineClassUnder(java.lang.String name, RubyClass superClass, ObjectAllocator allocator, RubyModule parent, CallSite[] callSites)` A variation of defineClassUnder that allows passing in an array of supplementary call sites to improve dynamic invocation.
`void`	`defineGlobalConstant(java.lang.String name, IRubyObject value)` rb_define_global_const Define a constant on the global namespace (i.e.
`RubyModule`	`defineModule(java.lang.String name)` Define a new module under the Object namespace.
`RubyModule`	`defineModuleUnder(java.lang.String name, RubyModule parent)` Define a new module with the given name under the given module or class namespace.
`void`	`defineReadonlyVariable(java.lang.String name, IRubyObject value, GlobalVariable.Scope scope)` defines a readonly global variable
`void`	`defineVariable(GlobalVariable variable, GlobalVariable.Scope scope)` Defines a global variable
`void`	`eachModule(Function1<java.lang.Object,IRubyObject> func)`
`IRubyObject`	`evalScriptlet(java.lang.String script)` Evaluates a script under the current scope (perhaps the top-level scope) and returns the result (generally the last value calculated).
`IRubyObject`	`evalScriptlet(java.lang.String script, DynamicScope scope)` Evaluates a script under the current scope (perhaps the top-level scope) and returns the result (generally the last value calculated).
`IRubyObject`	`execRecursive(Ruby.RecursiveFunction func, IRubyObject obj)` Perform a recursive walk on the given object using the given function.
`private IRubyObject`	`execRecursiveI(Ruby.ExecRecursiveParams p)`
`private IRubyObject`	`execRecursiveInternal(Ruby.RecursiveFunction func, IRubyObject obj, IRubyObject pairid, boolean outer)`
`IRubyObject`	`execRecursiveOuter(Ruby.RecursiveFunction func, IRubyObject obj)` Perform a recursive walk on the given object using the given function.
`IRubyObject`	`executeScript(java.lang.String script, java.lang.String filename)` Parse and execute the specified script This differs from the other methods in that it accepts a string-based script and parses and runs it as though it were loaded at a command-line.
`private void`	`failForcedCompile(Node scriptNode)`
`RubyClass`	`fastGetClass(java.lang.String internedName)` Deprecated.
`RubyModule`	`fastGetModule(java.lang.String internedName)` Deprecated.
`RubySymbol`	`fastNewSymbol(java.lang.String internedName)` Faster than `newSymbol(String)` if you already have an interned name String.
`IRubyObject`	`fetchGlobalConstant(java.lang.String name)` Fetch a constant from the global namespace (i.e.
`IRubyObject`	`getArgsFile()`
`RubyClass`	`getArgumentError()`
`RubyClass`	`getArray()`
`int`	`getBacktraceCount()` Get the current backtrace count.
`RubyClass`	`getBasicObject()`
`BeanManager`	`getBeanManager()`
`RubyClass`	`getBignum()`
`RubyClass`	`getBinding()`
`java.util.Map<java.lang.String,java.util.Map<java.lang.String,java.lang.String>>`	`getBoundMethods()`
`int`	`getCallerCount()` Get the current backtrace count.
`RubyHash`	`getCharsetMap()`
`Invalidator`	`getCheckpointInvalidator()`
`RubyClass`	`getClass(java.lang.String name)` Retrieve the class with the given name from the Object namespace.
`RubyClass`	`getClassClass()`
`RubyModule`	`getClassFromPath(java.lang.String path)`
`static java.lang.ClassLoader`	`getClassLoader()`
`RubyModule`	`getComparable()`
`RubyClass`	`getComplex()`
`RubyClass`	`getConcurrencyError()`
`int`	`getConstantGeneration()` Deprecated.
`Invalidator`	`getConstantInvalidator(java.lang.String constantName)`
`RubyClass`	`getContinuation()`
`RubyClass`	`getConverter()`
`RubyClass`	`getConverterNotFoundError()`
`CoverageData`	`getCoverageData()`
`ThreadContext`	`getCurrentContext()`
`java.lang.String`	`getCurrentDirectory()`
`static Ruby`	`getCurrentInstance()` Deprecated.
`int`	`getCurrentLine()`
`IRubyObject`	`getDebug()` Getter for property isDebug.
`org.jcodings.Encoding`	`getDefaultExternalEncoding()`
`static Ruby`	`getDefaultInstance()` Deprecated. use #newInstance()
`org.jcodings.Encoding`	`getDefaultInternalEncoding()` This is an internal encoding if actually specified via default_internal= or passed in via -E.
`DynamicMethod`	`getDefaultMethodMissing()`
`RubyRandom.RandomType`	`getDefaultRand()`
`RubyThreadGroup`	`getDefaultThreadGroup()`
`RubyString`	`getDefinedMessage(DefinedMessage definedMessage)`
`ChannelDescriptor`	`getDescriptorByFileno(int aFileno)` Deprecated.
`RubyClass`	`getDir()`
`RubyClass`	`getDummy()`
`RubyArray`	`getEmptyFrozenArray()`
`RubyClass`	`getEncoding()`
`RubyClass`	`getEncodingCompatibilityError()`
`RubyClass`	`getEncodingError()`
`EncodingService`	`getEncodingService()`
`RubyModule`	`getEnumerable()`
`RubyClass`	`getEnumerator()`
`RubyHash`	`getENV()`
`RubyClass`	`getEOFError()`
`java.io.PrintStream`	`getErr()`
`RubyModule`	`getErrno()`
`RubyClass`	`getErrno(int n)`
`java.io.PrintStream`	`getErrorStream()`
`RubyModule`	`getEtc()`
`RubyClass`	`getException()`
`int`	`getExceptionCount()` Get the current exception count.
`java.util.concurrent.ExecutorService`	`getExecutor()`
`RubyBoolean`	`getFalse()` Returns the "false" instance from the instance pool.
`RubyClass`	`getFalseClass()`
`RubyClass`	`getFatal()`
`FFI`	`getFFI()`
`RubyClass`	`getFiberError()`
`java.util.concurrent.ExecutorService`	`getFiberExecutor()`
`RubyClass`	`getFile()`
`int`	`getFileno(ChannelDescriptor descriptor)` Get the "external" fileno for a given ChannelDescriptor.
`int`	`getFilenoExtMap(int external)`
`int`	`getFilenoIntMap(int internal)`
`int`	`getFilenoIntMapSize()`
`RubyClass`	`getFileStat()`
`RubyModule`	`getFileTest()`
`RubyClass`	`getFixnum()`
`Invalidator`	`getFixnumInvalidator()` Retrieve the invalidator for Fixnum reopening
`RubyClass`	`getFloat()`
`RubyClass`	`getFloatDomainError()`
`Invalidator`	`getFloatInvalidator()` Retrieve the invalidator for Float reopening
`RubyModule`	`getGC()`
`static Ruby`	`getGlobalRuntime()` Get the global runtime.
`long`	`getGlobalState()` GET_VM_STATE_VERSION
`GlobalVariables`	`getGlobalVariables()`
`IRubyObject`	`getGroupStruct()`
`RubyClass`	`getHash()`
`long`	`getHashSeedK0()`
`long`	`getHashSeedK1()`
`java.lang.Object`	`getHierarchyLock()` Get the global object used to synchronize class-hierarchy modifications like cache invalidation, subclass sets, and included hierarchy sets.
`java.io.InputStream`	`getIn()`
`RubyClass`	`getIndexError()`
`java.io.InputStream`	`getInputStream()`
`RubyInstanceConfig`	`getInstanceConfig()`
`RubyClass`	`getInteger()`
`RubyClass`	`getInterrupt()`
`RubyClass`	`getInterruptedRegexpError()`
`RubyClass`	`getInvalidByteSequenceError()`
`RubyClass`	`getIO()`
`RubyClass`	`getIOError()`
`IRManager`	`getIRManager()`
`JavaProxyClassFactory`	`getJavaProxyClassFactory()`
`JavaSupport`	`getJavaSupport()`
`JITCompiler`	`getJITCompiler()`
`java.util.Set<Script>`	`getJittedMethods()`
`JRubyClassLoader`	`getJRubyClassLoader()` TODO the property `jrubyClassLoader` will only be set in constructor.
`java.lang.String`	`getJRubyHome()`
`KCode`	`getKCode()`
`RubyModule`	`getKernel()`
`RubyClass`	`getKeyError()`
`RubyClass`	`getLoadError()`
`LoadService`	`getLoadService()` Returns the loadService.
`RubyClass`	`getLocalJumpError()`
`RubyClass`	`getLocation()`
`RubyModule`	`getMarshal()`
`RubyClass`	`getMatchData()`
`RubyModule`	`getMath()`
`RubyClass`	`getMathDomainError()`
`RubyClass`	`getMethod()`
`RubyClass`	`getModule()`
`RubyModule`	`getModule(java.lang.String name)` Retrieve the module with the given name from the Object namespace.
`RubyClass`	`getNameError()`
`RubyClass`	`getNameErrorMessage()`
`RubyClass`	`getNativeException()`
`long`	`getNextDynamicMethodSerial()` Get a new serial number for a new DynamicMethod instance
`int`	`getNextModuleGeneration()` Get a new generation number for a module or class.
`IRubyObject`	`getNil()` Returns the "nil" singleton instance.
`RubyClass`	`getNilClass()`
`IRubyObject[]`	`getNilPrefilledArray()`
`RubyClass`	`getNoMemoryError()`
`RubyClass`	`getNoMethodError()`
`DynamicMethod`	`getNormalMethodMissing()`
`RubyClass`	`getNotImplementedError()`
`RubyClass`	`getNumeric()`
`RubyClass`	`getObject()`
`ObjectSpace`	`getObjectSpace()`
`RubyModule`	`getObjectSpaceModule()`
`RubyModule`	`getOrCreateModule(java.lang.String name)` From Object, retrieve the named module.
`java.io.PrintStream`	`getOut()`
`java.io.PrintStream`	`getOutputStream()`
`Parser`	`getParser()`
`IRubyObject`	`getPasswdStruct()`
`jnr.posix.POSIX`	`getPosix()`
`RubyModule`	`getPrecision()`
`DynamicMethod`	`getPrivateMethodMissing()`
`RubyClass`	`getProc()`
`RubyModule`	`getProcess()`
`RubyModule`	`getProcGID()`
`RubyClass`	`getProcStatus()`
`RubyModule`	`getProcSysModule()`
`RubyModule`	`getProcUID()`
`Profile`	`getProfile()`
`ProfiledMethods`	`getProfiledMethods()` Deprecated. This should be an implementation detail of the ProfilingService and should remove from the Ruby class.
`ProfilingService`	`getProfilingService()`
`private ProfilingServiceLookup`	`getProfilingServiceLookup()` Simple getter for #profilingServiceLookup to avoid direct property access
`DynamicMethod`	`getProtectedMethodMissing()`
`java.util.Random`	`getRandom()`
`RubyClass`	`getRandomClass()`
`RubyClass`	`getRange()`
`RubyClass`	`getRangeError()`
`RubyClass`	`getRational()`
`GlobalVariable`	`getRecordSeparatorVar()`
`RubyClass`	`getRegexp()`
`RubyClass`	`getRegexpError()`
`DynamicMethod`	`getRespondToMethod()`
`DynamicMethod`	`getRespondToMissingMethod()`
`IRubyObject`	`getRootFiber()`
`RuntimeCache`	`getRuntimeCache()` Get the core class RuntimeCache instance, for doing dynamic calls from core class methods.
`RubyClass`	`getRuntimeError()`
`int`	`getRuntimeNumber()`
`int`	`getSafeLevel()` Deprecated.
`RubyClass`	`getSecurityError()`
`SelectorPool`	`getSelectorPool()` Get the runtime-global selector pool
`RubyClass`	`getSignalException()`
`IRubyObject[]`	`getSingleNilArray()`
`RubyClass`	`getStandardError()`
`long`	`getStartTime()`
`StaticScopeFactory`	`getStaticScopeFactory()`
`RubyClass`	`getStopIteration()`
`RubyClass`	`getString()`
`RubyClass`	`getStructClass()`
`DynamicMethod`	`getSuperMethodMissing()`
`RubyClass`	`getSymbol()`
`RubySymbol.SymbolTable`	`getSymbolTable()`
`RubyClass`	`getSyntaxError()`
`RubyClass`	`getSystemCallError()`
`RubyClass`	`getSystemExit()`
`RubyClass`	`getSystemStackError()`
`RubyClass`	`getThread()`
`RubyClass`	`getThreadError()`
`RubyClass`	`getThreadGroup()`
`static Ruby`	`getThreadLocalRuntime()` Get the thread-local runtime for the current thread, or null if unset.
`ThreadService`	`getThreadService()`
`RubyString`	`getThreadStatus(RubyThread.Status status)`
`RubyClass`	`getTime()`
`java.util.Map<java.lang.String,org.joda.time.DateTimeZone>`	`getTimezoneCache()`
`IRubyObject`	`getTmsStruct()`
`IRubyObject`	`getTopSelf()` Getter for property rubyTopSelf.
`RubyBoolean`	`getTrue()` Returns the "true" instance from the instance pool.
`RubyClass`	`getTrueClass()`
`RubyClass`	`getTypeError()`
`RubyClass`	`getUnboundMethod()`
`RubyClass`	`getUndefinedConversionError()`
`DynamicMethod`	`getVariableMethodMissing()`
`IRubyObject`	`getVerbose()` Getter for property isVerbose.
`int`	`getWarningCount()` Get the current backtrace count.
`RubyWarnings`	`getWarnings()`
`RubyClass`	`getYielder()`
`RubyClass`	`getZeroDivisionError()`
`private void`	`handeCompileError(Node node, java.lang.Throwable t)`
`boolean`	`hasEventHooks()`
`void`	`incGlobalState()` INC_VM_STATE_VERSION
`void`	`incrementBacktraceCount()` Increment the count of backtraces generated by code in this runtime.
`void`	`incrementCallerCount()` Increment the count of backtraces generated by code in this runtime.
`void`	`incrementExceptionCount()` Increment the count of exceptions generated by code in this runtime.
`void`	`incrementWarningCount()` Increment the count of backtraces generated for warnings in this runtime.
`private void`	`init()` This method is called immediately after constructing the Ruby instance.
`private void`	`initBuiltins()`
`private void`	`initCore()`
`private void`	`initDefinedMessages()`
`private void`	`initErrno()` Create module Errno's Variables.
`private void`	`initExceptions()`
`private void`	`initRoot()`
`private void`	`initRubyKernel()`
`private void`	`initThreadStatuses()`
`boolean`	`is1_8()`
`boolean`	`is1_9()`
`boolean`	`is2_0()`
`boolean`	`isBooting()`
`boolean`	`isClassDefined(java.lang.String name)`
`boolean`	`isDebug()`
`boolean`	`isDoNotReverseLookupEnabled()`
`boolean`	`isFixnumReopened()` Whether the Float class has been reopened and modified
`boolean`	`isFloatReopened()` Whether the Float class has been reopened and modified
`boolean`	`isGlobalAbortOnExceptionEnabled()`
`static boolean`	`isGlobalRuntimeReady()` Tests whether globalRuntime has been instantiated or not.
`boolean`	`isInspecting(java.lang.Object obj)`
`boolean`	`isObjectSpaceEnabled()`
`static boolean`	`isSecurityRestricted()`
`boolean`	`isSiphashEnabled()`
`boolean`	`isVerbose()`
`<E extends java.lang.Enum<E>> void`	`loadConstantSet(RubyModule module, java.lang.Class<E> enumClass)`
`void`	`loadConstantSet(RubyModule module, java.lang.String constantSetName)`
`void`	`loadExtension(java.lang.String extName, BasicLibraryService extension, boolean wrap)` Load the given BasicLibraryService instance, wrapping it in Ruby framing to ensure it is isolated from any parent scope.
`void`	`loadFile(java.lang.String scriptName, java.io.InputStream in, boolean wrap)`
`void`	`loadScript(Script script)`
`void`	`loadScript(Script script, boolean wrap)`
`RaiseException`	`newArgumentError(int got, int expected)`
`RaiseException`	`newArgumentError(java.lang.String message)`
`RaiseException`	`newArgumentError(java.lang.String name, int got, int expected)`
`RubyArray`	`newArray()`
`RubyArray`	`newArray(int size)`
`RubyArray`	`newArray(IRubyObject... objects)`
`RubyArray`	`newArray(IRubyObject object)`
`RubyArray`	`newArray(IRubyObject car, IRubyObject cdr)`
`RubyArray`	`newArray(java.util.List<IRubyObject> list)`
`RubyArray`	`newArrayLight()`
`RubyArray`	`newArrayNoCopy(IRubyObject... objects)`
`RubyArray`	`newArrayNoCopyLight(IRubyObject... objects)`
`RubyBinding`	`newBinding()`
`RubyBinding`	`newBinding(Binding binding)`
`RubyProc`	`newBlockPassProc(Block.Type type, Block block)`
`RubyBoolean`	`newBoolean(boolean value)`
`RaiseException`	`newConcurrencyError(java.lang.String message)`
`RaiseException`	`newConverterNotFoundError(java.lang.String message)`
`RubyObject.Data`	`newData(RubyClass objectClass, java.lang.Object sval)`
`RubyArray`	`newEmptyArray()`
`RaiseException`	`newEncodingCompatibilityError(java.lang.String message)`
`RaiseException`	`newEncodingError(java.lang.String message)`
`RaiseException`	`newEOFError()`
`RaiseException`	`newEOFError(java.lang.String message)`
`RaiseException`	`newErrnoEACCESError(java.lang.String message)`
`RaiseException`	`newErrnoEADDRFromBindException(java.net.BindException be)`
`RaiseException`	`newErrnoEADDRFromBindException(java.net.BindException be, java.lang.String contextMessage)`
`RaiseException`	`newErrnoEADDRINUSEError()`
`RaiseException`	`newErrnoEADDRINUSEError(java.lang.String message)`
`RaiseException`	`newErrnoEADDRNOTAVAILError(java.lang.String message)`
`RaiseException`	`newErrnoEAGAINError(java.lang.String message)`
`RaiseException`	`newErrnoEAGAINReadableError(java.lang.String message)`
`RaiseException`	`newErrnoEAGAINWritableError(java.lang.String message)`
`RaiseException`	`newErrnoEBADFError()`
`RaiseException`	`newErrnoEBADFError(java.lang.String message)`
`RaiseException`	`newErrnoECHILDError()`
`RaiseException`	`newErrnoECONNABORTEDError()`
`RaiseException`	`newErrnoECONNREFUSEDError()`
`RaiseException`	`newErrnoECONNRESETError()`
`RaiseException`	`newErrnoEDESTADDRREQError(java.lang.String func)`
`RaiseException`	`newErrnoEDOMError(java.lang.String message)`
`RaiseException`	`newErrnoEEXISTError(java.lang.String message)`
`RaiseException`	`newErrnoEHOSTUNREACHError(java.lang.String message)`
`RaiseException`	`newErrnoEINPROGRESSError()`
`RaiseException`	`newErrnoEINPROGRESSError(java.lang.String message)`
`RaiseException`	`newErrnoEINPROGRESSWritableError()`
`RaiseException`	`newErrnoEINPROGRESSWritableError(java.lang.String message)`
`RaiseException`	`newErrnoEINVALError()`
`RaiseException`	`newErrnoEINVALError(java.lang.String message)`
`RaiseException`	`newErrnoEISCONNError()`
`RaiseException`	`newErrnoEISCONNError(java.lang.String message)`
`RaiseException`	`newErrnoEISDirError()`
`RaiseException`	`newErrnoEISDirError(java.lang.String message)`
`RaiseException`	`newErrnoENOENTError()`
`RaiseException`	`newErrnoENOENTError(java.lang.String message)`
`RaiseException`	`newErrnoENOPROTOOPTError()`
`RaiseException`	`newErrnoENOTCONNError()`
`RaiseException`	`newErrnoENOTCONNError(java.lang.String message)`
`RaiseException`	`newErrnoENOTDIRError(java.lang.String message)`
`RaiseException`	`newErrnoENOTEMPTYError(java.lang.String message)`
`RaiseException`	`newErrnoENOTSOCKError(java.lang.String message)`
`RaiseException`	`newErrnoEPERMError(java.lang.String name)`
`RaiseException`	`newErrnoEPIPEError()`
`RaiseException`	`newErrnoESPIPEError()`
`RaiseException`	`newErrnoESPIPEError(java.lang.String message)`
`RaiseException`	`newErrnoESRCHError()`
`RaiseException`	`newErrnoEWOULDBLOCKError()`
`RaiseException`	`newErrnoFromInt(int errno)`
`RaiseException`	`newErrnoFromInt(int errno, java.lang.String message)`
`RaiseException`	`newErrnoFromInt(int errno, java.lang.String methodName, java.lang.String message)`
`RaiseException`	`newErrnoFromLastPOSIXErrno()`
`RaiseException`	`newFiberError(java.lang.String message)`
`RubyFileStat`	`newFileStat(java.io.FileDescriptor descriptor)`
`RubyFileStat`	`newFileStat(java.lang.String filename, boolean lstat)`
`RubyFixnum`	`newFixnum(jnr.constants.Constant value)`
`RubyFixnum`	`newFixnum(int value)`
`RubyFixnum`	`newFixnum(long value)`
`RubyFloat`	`newFloat(double value)`
`RaiseException`	`newFloatDomainError(java.lang.String message)`
`RaiseException`	`newFrozenError(java.lang.String objectType)`
`RaiseException`	`newFrozenError(java.lang.String objectType, boolean runtimeError)`
`RaiseException`	`newIllegalSequence(java.lang.String message)`
`RaiseException`	`newIndexError(java.lang.String message)`
`static Ruby`	`newInstance()` Returns a new instance of the JRuby runtime configured with defaults.
`static Ruby`	`newInstance(java.io.InputStream in, java.io.PrintStream out, java.io.PrintStream err)` Returns a new instance of the JRuby runtime configured with the given input, output and error streams and otherwise default configuration (except where specified system properties alter defaults).
`static Ruby`	`newInstance(RubyInstanceConfig config)` Returns a new instance of the JRuby runtime configured as specified.
`RaiseException`	`newInterruptedRegexpError(java.lang.String message)`
`RaiseException`	`newInvalidByteSequenceError(java.lang.String message)`
`RaiseException`	`newInvalidEncoding(java.lang.String message)`
`RaiseException`	`newIOError(java.lang.String message)`
`RaiseException`	`newIOErrorFromException(java.io.IOException ioe)`
`RaiseException`	`newKeyError(java.lang.String message)`
`private RaiseException`	`newLightweightErrnoException(RubyClass exceptionClass, java.lang.String message)` Generate one of the ERRNO exceptions.
`RaiseException`	`newLightweightStopIterationError(java.lang.String message)` Generate a StopIteration exception.
`RaiseException`	`newLoadError(java.lang.String message)`
`RaiseException`	`newLoadError(java.lang.String message, java.lang.String path)`
`RaiseException`	`newLocalJumpError(RubyLocalJumpError.Reason reason, IRubyObject exitValue, java.lang.String message)`
`RaiseException`	`newLocalJumpErrorNoBlock()`
`RaiseException`	`newMathDomainError(java.lang.String message)`
`RaiseException`	`newNameError(java.lang.String message, java.lang.String name)`
`RaiseException`	`newNameError(java.lang.String message, java.lang.String name, java.lang.Throwable origException)`
`RaiseException`	`newNameError(java.lang.String message, java.lang.String name, java.lang.Throwable origException, boolean printWhenVerbose)`
`RaiseException`	`newNameErrorObject(java.lang.String message, IRubyObject name)`
`RaiseException`	`newNoMethodError(java.lang.String message, java.lang.String name, IRubyObject args)`
`RaiseException`	`newNotImplementedError(java.lang.String message)`
`RubyNumeric`	`newNumeric()`
`RubyProc`	`newProc(Block.Type type, Block block)`
`RaiseException`	`newRaiseException(RubyClass exceptionClass, java.lang.String message)`
`RaiseException`	`newRangeError(java.lang.String message)`
`RubyRational`	`newRational(long num, long den)`
`RubyRational`	`newRationalReduced(long num, long den)`
`RaiseException`	`newRedoLocalJumpError()`
`RaiseException`	`newRegexpError(java.lang.String message)`
`RaiseException`	`newRuntimeError(java.lang.String message)`
`RaiseException`	`newSecurityError(java.lang.String message)`
`RaiseException`	`newStandardError(java.lang.String message)`
`RubyString`	`newString()`
`RubyString`	`newString(org.jruby.util.ByteList byteList)`
`RubyString`	`newString(java.lang.String string)`
`RubyString`	`newStringShared(org.jruby.util.ByteList byteList)` Deprecated.
`RubySymbol`	`newSymbol(org.jruby.util.ByteList name)`
`RubySymbol`	`newSymbol(java.lang.String name)`
`RaiseException`	`newSyntaxError(java.lang.String message)`
`RaiseException`	`newSystemCallError(java.lang.String message)`
`RaiseException`	`newSystemExit(int status)`
`RaiseException`	`newSystemExit(int status, java.lang.String message)`
`RaiseException`	`newSystemStackError(java.lang.String message)`
`RaiseException`	`newSystemStackError(java.lang.String message, java.lang.StackOverflowError soe)`
`RaiseException`	`newThreadError(java.lang.String message)`
`RubyTime`	`newTime(long milliseconds)`
`RaiseException`	`newTypeError(IRubyObject receivedObject, RubyClass expectedType)`
`RaiseException`	`newTypeError(IRubyObject receivedObject, RubyModule expectedType)`
`RaiseException`	`newTypeError(IRubyObject receivedObject, java.lang.String expectedType)`
`RaiseException`	`newTypeError(java.lang.String message)`
`RaiseException`	`newUndefinedConversionError(java.lang.String message)`
`RaiseException`	`newZeroDivisionError()`
`Node`	`parse(org.jruby.util.ByteList content, java.lang.String file, DynamicScope scope, int lineNumber, boolean extraPositionInformation)`
`Node`	`parse(java.lang.String content, java.lang.String file, DynamicScope scope, int lineNumber, boolean extraPositionInformation)` Deprecated.
`Node`	`parseEval(org.jruby.util.ByteList content, java.lang.String file, DynamicScope scope, int lineNumber)`
`Node`	`parseEval(java.lang.String content, java.lang.String file, DynamicScope scope, int lineNumber)`
`Node`	`parseFile(java.io.InputStream in, java.lang.String file, DynamicScope scope)`
`Node`	`parseFile(java.io.InputStream in, java.lang.String file, DynamicScope scope, int lineNumber)`
`Node`	`parseFileFromMain(java.io.InputStream in, java.lang.String file, DynamicScope scope)`
`Node`	`parseFromMain(java.io.InputStream inputStream, java.lang.String filename)` Parse the script contained in the given input stream, using the given filename as the name of the script, and return the root Node.
`Node`	`parseInline(java.io.InputStream in, java.lang.String file, DynamicScope scope)`
`void`	`printError(RubyException excp)` Prints an error with backtrace to the error stream.
`void`	`printProfileData(ProfileCollection profileData)` TDOD remove the synchronized.
`IRubyObject`	`pushExitBlock(RubyProc proc)` Push block onto exit stack.
`void`	`putFilenoMap(int external, int internal)`
`private boolean`	`recursiveCheck(IRubyObject list, IRubyObject obj_id, IRubyObject paired_obj_id)`
`private IRubyObject`	`recursiveListAccess()`
`private void`	`recursiveListClear()`
`<T extends IRubyObject> T`	`recursiveListOperation(java.util.concurrent.Callable<T> body)` Begin a recursive walk that may make one or more calls to `execRecursive`.
`private void`	`recursivePop(IRubyObject list, IRubyObject obj, IRubyObject paired_obj)`
`private void`	`recursivePush(IRubyObject list, IRubyObject obj, IRubyObject paired_obj)`
`void`	`registerDescriptor(ChannelDescriptor descriptor)` Deprecated.
`void`	`registerDescriptor(ChannelDescriptor descriptor, boolean isRetained)` Deprecated.
`void`	`registerInspecting(java.lang.Object obj)`
`void`	`registerMBeans()`
`(package private) void`	`reinitialize(boolean reinitCore)`
`void`	`releaseClassLoader()` By default `tearDown(boolean)` does not release the class-loader's resources as threads might be still running accessing the classes/packages even after the runtime has been torn down.
`void`	`removeEventHook(EventHook hook)`
`void`	`removeFilenoIntMap(int internal)`
`void`	`removeFinalizer(Finalizable finalizer)`
`void`	`removeInternalFinalizer(Finalizable finalizer)`
`void`	`reopenFixnum()` Mark Fixnum as reopened
`void`	`reopenFloat()` Mark Float as reopened
`void`	`runFromMain(java.io.InputStream inputStream, java.lang.String filename)` Run the script contained in the specified input stream, using the specified filename as the name of the script being executed.
`IRubyObject`	`runInterpreter(Node scriptNode)`
`IRubyObject`	`runInterpreter(ThreadContext context, Node rootNode, IRubyObject self)`
`IRubyObject`	`runInterpreterBody(Node scriptNode)` This is used for the "gets" loop, and we bypass 'load' to use an already-prepared, already-pushed scope for the script body.
`IRubyObject`	`runNormally(Node scriptNode)` Run the specified script without any of the loop-processing wrapper code.
`IRubyObject`	`runNormally(Node scriptNode, boolean unused)` Deprecated.
`IRubyObject`	`runScript(Script script)`
`IRubyObject`	`runScript(Script script, boolean wrap)`
`IRubyObject`	`runScriptBody(Script script)` This is used for the "gets" loop, and we bypass 'load' to use an already-prepared, already-pushed scope for the script body.
`IRubyObject`	`runWithGetsLoop(Node scriptNode, boolean printing, boolean processLineEnds, boolean split)` Run the given script with a "while gets; end" loop wrapped around it.
`IRubyObject`	`runWithGetsLoop(Node scriptNode, boolean printing, boolean processLineEnds, boolean split, boolean unused)` Deprecated.
`void`	`secure(int level)` Deprecated.
`void`	`setArgsFile(IRubyObject argsFile)`
`(package private) void`	`setArray(RubyClass arrayClass)`
`(package private) void`	`setBignum(RubyClass bignumClass)`
`(package private) void`	`setBinding(RubyClass bindingClass)`
`(package private) void`	`setComparable(RubyModule comparableModule)`
`(package private) void`	`setComplex(RubyClass complexClass)`
`(package private) void`	`setContinuation(RubyClass continuationClass)`
`(package private) void`	`setConverter(RubyClass converterClass)`
`void`	`setCurrentDirectory(java.lang.String dir)`
`static void`	`setCurrentInstance(Ruby runtime)` Deprecated.
`void`	`setCurrentLine(int line)`
`void`	`setDebug(IRubyObject debug)` Setter for property isDebug.
`void`	`setDefaultExternalEncoding(org.jcodings.Encoding defaultExternalEncoding)`
`void`	`setDefaultInternalEncoding(org.jcodings.Encoding defaultInternalEncoding)`
`void`	`setDefaultMethodMissing(DynamicMethod method)`
`void`	`setDefaultRand(RubyRandom.RandomType defaultRand)`
`(package private) void`	`setDefaultThreadGroup(RubyThreadGroup defaultThreadGroup)`
`(package private) void`	`setDir(RubyClass dirClass)`
`void`	`setDoNotReverseLookupEnabled(boolean b)`
`(package private) void`	`setEncoding(RubyClass encodingClass)`
`(package private) void`	`setEnumerable(RubyModule enumerableModule)`
`(package private) void`	`setEnumerator(RubyClass enumeratorClass)`
`void`	`setENV(RubyHash env)`
`void`	`setEtc(RubyModule etcModule)`
`(package private) void`	`setException(RubyClass exceptionClass)`
`(package private) void`	`setFalseClass(RubyClass falseClass)`
`void`	`setFFI(FFI ffi)`
`(package private) void`	`setFile(RubyClass fileClass)`
`(package private) void`	`setFileStat(RubyClass fileStatClass)`
`(package private) void`	`setFileTest(RubyModule fileTestModule)`
`(package private) void`	`setFixnum(RubyClass fixnumClass)`
`(package private) void`	`setFloat(RubyClass floatClass)`
`(package private) void`	`setGC(RubyModule gcModule)`
`void`	`setGlobalAbortOnExceptionEnabled(boolean enable)`
`private static void`	`setGlobalRuntimeFirstTimeOnly(Ruby runtime)` Set the global runtime to the given runtime only if it has no been set.
`void`	`setGlobalVariables(GlobalVariables globalVariables)`
`void`	`setGroupStruct(RubyClass groupStruct)`
`(package private) void`	`setHash(RubyClass hashClass)`
`(package private) void`	`setInteger(RubyClass integerClass)`
`(package private) void`	`setIO(RubyClass ioClass)`
`void`	`setJavaProxyClassFactory(JavaProxyClassFactory factory)`
`void`	`setJRubyHome(java.lang.String home)`
`void`	`setKCode(KCode kcode)`
`(package private) void`	`setKernel(RubyModule kernelModule)`
`void`	`setLocation(RubyClass location)`
`(package private) void`	`setMarshal(RubyModule marshalModule)`
`(package private) void`	`setMatchData(RubyClass matchDataClass)`
`(package private) void`	`setMath(RubyModule mathModule)`
`(package private) void`	`setMethod(RubyClass methodClass)`
`private void`	`setNetworkStack()`
`(package private) void`	`setNilClass(RubyClass nilClass)`
`void`	`setNormalMethodMissing(DynamicMethod method)`
`(package private) void`	`setNumeric(RubyClass numericClass)`
`void`	`setObjectSpaceEnabled(boolean objectSpaceEnabled)`
`(package private) void`	`setObjectSpaceModule(RubyModule objectSpaceModule)`
`void`	`setPasswdStruct(RubyClass passwdStruct)`
`(package private) void`	`setPrecision(RubyModule precisionModule)`
`void`	`setPrivateMethodMissing(DynamicMethod method)`
`(package private) void`	`setProc(RubyClass procClass)`
`(package private) void`	`setProcess(RubyModule processModule)`
`(package private) void`	`setProcGID(RubyModule procGIDModule)`
`(package private) void`	`setProcStatus(RubyClass procStatusClass)`
`(package private) void`	`setProcSys(RubyModule procSysModule)`
`(package private) void`	`setProcUID(RubyModule procUIDModule)`
`void`	`setProtectedMethodMissing(DynamicMethod method)`
`(package private) void`	`setRandomClass(RubyClass randomClass)`
`(package private) void`	`setRange(RubyClass rangeClass)`
`(package private) void`	`setRational(RubyClass rationalClass)`
`void`	`setRecordSeparatorVar(GlobalVariable recordSeparatorVar)`
`(package private) void`	`setRegexp(RubyClass regexpClass)`
`void`	`setRespondToMethod(DynamicMethod rtm)`
`void`	`setRespondToMissingMethod(DynamicMethod rtmm)`
`void`	`setRootFiber(IRubyObject fiber)`
`void`	`setSafeLevel(int safeLevel)` Deprecated.
`static void`	`setSecurityRestricted(boolean restricted)`
`(package private) void`	`setString(RubyClass stringClass)`
`(package private) void`	`setStructClass(RubyClass structClass)`
`void`	`setSuperMethodMissing(DynamicMethod method)`
`(package private) void`	`setSymbol(RubyClass symbolClass)`
`(package private) void`	`setThread(RubyClass threadClass)`
`(package private) void`	`setThreadGroup(RubyClass threadGroupClass)`
`static void`	`setThreadLocalRuntime(Ruby ruby)` Set the thread-local runtime to the given runtime.
`(package private) void`	`setTime(RubyClass timeClass)`
`(package private) void`	`setTmsStruct(RubyClass tmsStruct)`
`void`	`setTraceFunction(RubyProc traceFunction)`
`(package private) void`	`setTrueClass(RubyClass trueClass)`
`(package private) void`	`setUnboundMethod(RubyClass unboundMethodClass)`
`private void`	`setupSourceEncoding(ParserConfiguration parserConfig)`
`void`	`setVariableMethodMissing(DynamicMethod method)`
`void`	`setVerbose(IRubyObject verbose)` Setter for property isVerbose.
`(package private) void`	`setYielder(RubyClass yielderClass)`
`void`	`tearDown()` Make sure Kernel#at_exit procs getService invoked on runtime shutdown.
`void`	`tearDown(boolean systemExit)`
`Script`	`tryCompile(Node node)` Try to compile the code associated with the given Node, returning an instance of the successfully-compiled Script or null if the script could not be compiled.
`Script`	`tryCompile(Node node, ASTInspector inspector)` Try to compile the code associated with the given Node, returning an instance of the successfully-compiled Script or null if the script could not be compiled.
`private Script`	`tryCompile(Node node, java.lang.String cachedClassName, JRubyClassLoader classLoader, ASTInspector inspector, boolean dump)`
`private Script`	`tryCompile(Node node, java.lang.String cachedClassName, JRubyClassLoader classLoader, boolean dump)`
`void`	`unregisterDescriptor(int aFileno)` Deprecated.
`void`	`unregisterInspecting(java.lang.Object obj)`
`void`	`useAsGlobalRuntime()` Convenience method for java integrators who may need to switch the notion of "global" runtime.
`boolean`	`warningsEnabled()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - LOG
```
private static final Logger LOG
```
    The logger used to log relevant bits.
  - NIL_PREFILLED_ARRAY_SIZE
```
public static final int NIL_PREFILLED_ARRAY_SIZE
```
    See Also:
    
    Constant Field Values
  - nilPrefilledArray
```
private final IRubyObject[] nilPrefilledArray
```
  - errnos
```
private java.util.Map<java.lang.Integer,RubyClass> errnos
```
  - defaultRand
```
private RubyRandom.RandomType defaultRand
```
  - charsetMap
```
private RubyHash charsetMap
```
  - EVENTS2_0
```
private static final java.util.EnumSet<RubyEvent> EVENTS2_0
```
  - callTraceFuncHook
```
private final Ruby.CallTraceFuncHook callTraceFuncHook
```
  - ADDR_NOT_AVAIL_PATTERN
```
private static final java.util.regex.Pattern ADDR_NOT_AVAIL_PATTERN
```
  - filenoExtIntMap
```
private final java.util.Map<java.lang.Integer,java.lang.Integer> filenoExtIntMap
```
  - filenoIntExtMap
```
private final java.util.Map<java.lang.Integer,java.lang.Integer> filenoIntExtMap
```
  - inspect
```
private java.lang.ThreadLocal<java.util.Map<java.lang.Object,java.lang.Object>> inspect
```
  - constantNameInvalidators
```
private final java.util.concurrent.ConcurrentHashMap<java.lang.String,Invalidator> constantNameInvalidators
```
  - checkpointInvalidator
```
private final Invalidator checkpointInvalidator
```
  - threadService
```
private final ThreadService threadService
```
  - posix
```
private jnr.posix.POSIX posix
```
  - objectSpace
```
private final ObjectSpace objectSpace
```
  - symbolTable
```
private final RubySymbol.SymbolTable symbolTable
```
  - EMPTY_HOOKS
```
private static final EventHook[] EMPTY_HOOKS
```
  - eventHooks
```
private volatile EventHook[] eventHooks
```
  - hasEventHooks
```
private boolean hasEventHooks
```
  - globalAbortOnExceptionEnabled
```
private boolean globalAbortOnExceptionEnabled
```
  - doNotReverseLookupEnabled
```
private boolean doNotReverseLookupEnabled
```
  - objectSpaceEnabled
```
private volatile boolean objectSpaceEnabled
```
  - siphashEnabled
```
private boolean siphashEnabled
```
  - jittedMethods
```
private final java.util.Set<Script> jittedMethods
```
  - globalState
```
private long globalState
```
  - topSelf
```
private IRubyObject topSelf
```
  - rootFiber
```
private IRubyObject rootFiber
```
  - nilObject
```
private RubyNil nilObject
```
  - singleNilArray
```
private IRubyObject[] singleNilArray
```
  - trueObject
```
private RubyBoolean trueObject
```
  - falseObject
```
private RubyBoolean falseObject
```
  - fixnumCache
```
public final RubyFixnum[] fixnumCache
```
  - verbose
```
private boolean verbose
```
  - warningsEnabled
```
private boolean warningsEnabled
```
  - debug
```
private boolean debug
```
  - verboseValue
```
private IRubyObject verboseValue
```
  - defaultThreadGroup
```
private RubyThreadGroup defaultThreadGroup
```
  - basicObjectClass
```
private RubyClass basicObjectClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - objectClass
```
private RubyClass objectClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - moduleClass
```
private RubyClass moduleClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - classClass
```
private RubyClass classClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - nilClass
```
private RubyClass nilClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - trueClass
```
private RubyClass trueClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - falseClass
```
private RubyClass falseClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - numericClass
```
private RubyClass numericClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - floatClass
```
private RubyClass floatClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - integerClass
```
private RubyClass integerClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - fixnumClass
```
private RubyClass fixnumClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - complexClass
```
private RubyClass complexClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - rationalClass
```
private RubyClass rationalClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - enumeratorClass
```
private RubyClass enumeratorClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - yielderClass
```
private RubyClass yielderClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - arrayClass
```
private RubyClass arrayClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - hashClass
```
private RubyClass hashClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - rangeClass
```
private RubyClass rangeClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - stringClass
```
private RubyClass stringClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - encodingClass
```
private RubyClass encodingClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - converterClass
```
private RubyClass converterClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - symbolClass
```
private RubyClass symbolClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - procClass
```
private RubyClass procClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - bindingClass
```
private RubyClass bindingClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - methodClass
```
private RubyClass methodClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - unboundMethodClass
```
private RubyClass unboundMethodClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - matchDataClass
```
private RubyClass matchDataClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - regexpClass
```
private RubyClass regexpClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - timeClass
```
private RubyClass timeClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - bignumClass
```
private RubyClass bignumClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - dirClass
```
private RubyClass dirClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - fileClass
```
private RubyClass fileClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - fileStatClass
```
private RubyClass fileStatClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - ioClass
```
private RubyClass ioClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - threadClass
```
private RubyClass threadClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - threadGroupClass
```
private RubyClass threadGroupClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - continuationClass
```
private RubyClass continuationClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - structClass
```
private RubyClass structClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - tmsStruct
```
private RubyClass tmsStruct
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - passwdStruct
```
private RubyClass passwdStruct
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - groupStruct
```
private RubyClass groupStruct
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - procStatusClass
```
private RubyClass procStatusClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - exceptionClass
```
private RubyClass exceptionClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - runtimeError
```
private RubyClass runtimeError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - ioError
```
private RubyClass ioError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - scriptError
```
private RubyClass scriptError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - nameError
```
private RubyClass nameError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - nameErrorMessage
```
private RubyClass nameErrorMessage
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - noMethodError
```
private RubyClass noMethodError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - signalException
```
private RubyClass signalException
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - rangeError
```
private RubyClass rangeError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - dummyClass
```
private RubyClass dummyClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - systemExit
```
private RubyClass systemExit
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - localJumpError
```
private RubyClass localJumpError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - nativeException
```
private RubyClass nativeException
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - systemCallError
```
private RubyClass systemCallError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - fatal
```
private RubyClass fatal
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - interrupt
```
private RubyClass interrupt
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - typeError
```
private RubyClass typeError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - argumentError
```
private RubyClass argumentError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - indexError
```
private RubyClass indexError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - stopIteration
```
private RubyClass stopIteration
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - syntaxError
```
private RubyClass syntaxError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - standardError
```
private RubyClass standardError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - loadError
```
private RubyClass loadError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - notImplementedError
```
private RubyClass notImplementedError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - securityError
```
private RubyClass securityError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - noMemoryError
```
private RubyClass noMemoryError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - regexpError
```
private RubyClass regexpError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - eofError
```
private RubyClass eofError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - threadError
```
private RubyClass threadError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - concurrencyError
```
private RubyClass concurrencyError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - systemStackError
```
private RubyClass systemStackError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - zeroDivisionError
```
private RubyClass zeroDivisionError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - floatDomainError
```
private RubyClass floatDomainError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - mathDomainError
```
private RubyClass mathDomainError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - encodingError
```
private RubyClass encodingError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - encodingCompatibilityError
```
private RubyClass encodingCompatibilityError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - converterNotFoundError
```
private RubyClass converterNotFoundError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - undefinedConversionError
```
private RubyClass undefinedConversionError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - invalidByteSequenceError
```
private RubyClass invalidByteSequenceError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - fiberError
```
private RubyClass fiberError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - randomClass
```
private RubyClass randomClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - keyError
```
private RubyClass keyError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - locationClass
```
private RubyClass locationClass
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - interruptedRegexpError
```
private RubyClass interruptedRegexpError
```
    All the core classes we keep hard references to. These are here largely so that if someone redefines String or Array we won't start blowing up creating strings and arrays internally. They also provide much faster access than going through normal hash lookup on the Object class.
  - kernelModule
```
private RubyModule kernelModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - comparableModule
```
private RubyModule comparableModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - enumerableModule
```
private RubyModule enumerableModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - mathModule
```
private RubyModule mathModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - marshalModule
```
private RubyModule marshalModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - etcModule
```
private RubyModule etcModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - fileTestModule
```
private RubyModule fileTestModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - gcModule
```
private RubyModule gcModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - objectSpaceModule
```
private RubyModule objectSpaceModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - processModule
```
private RubyModule processModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - procUIDModule
```
private RubyModule procUIDModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - procGIDModule
```
private RubyModule procGIDModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - procSysModule
```
private RubyModule procSysModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - precisionModule
```
private RubyModule precisionModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - errnoModule
```
private RubyModule errnoModule
```
    All the core modules we keep direct references to, for quick access and to ensure they remain available.
  - privateMethodMissing
```
private DynamicMethod privateMethodMissing
```
  - protectedMethodMissing
```
private DynamicMethod protectedMethodMissing
```
  - variableMethodMissing
```
private DynamicMethod variableMethodMissing
```
  - superMethodMissing
```
private DynamicMethod superMethodMissing
```
  - normalMethodMissing
```
private DynamicMethod normalMethodMissing
```
  - defaultMethodMissing
```
private DynamicMethod defaultMethodMissing
```
  - respondTo
```
private DynamicMethod respondTo
```
  - respondToMissing
```
private DynamicMethod respondToMissing
```
  - recordSeparatorVar
```
private GlobalVariable recordSeparatorVar
```
  - currentDirectory
```
private volatile java.lang.String currentDirectory
```
  - currentLine
```
private volatile int currentLine
```
  - argsFile
```
private volatile IRubyObject argsFile
```
  - startTime
```
private final long startTime
```
  - config
```
private final RubyInstanceConfig config
```
  - is1_9
```
private boolean is1_9
```
  - is2_0
```
private boolean is2_0
```
  - in
```
private java.io.InputStream in
```
  - out
```
private java.io.PrintStream out
```
  - err
```
private java.io.PrintStream err
```
  - javaSupport
```
private JavaSupport javaSupport
```
  - jrubyClassLoader
```
private JRubyClassLoader jrubyClassLoader
```
  - beanManager
```
private BeanManager beanManager
```
  - parserStats
```
private ParserStats parserStats
```
  - jitCompiler
```
private final JITCompiler jitCompiler
```
  - securityRestricted
```
private static volatile boolean securityRestricted
```
  - parser
```
private final Parser parser
```
  - loadService
```
private LoadService loadService
```
  - defaultInternalEncoding
```
private org.jcodings.Encoding defaultInternalEncoding
```
  - defaultExternalEncoding
```
private org.jcodings.Encoding defaultExternalEncoding
```
  - encodingService
```
private EncodingService encodingService
```
  - globalVariables
```
private GlobalVariables globalVariables
```
  - warnings
```
private final RubyWarnings warnings
```
  - atExitBlocks
```
private final java.util.Stack<RubyProc> atExitBlocks
```
  - profile
```
private Profile profile
```
  - kcode
```
private KCode kcode
```
  - symbolLastId
```
private final java.util.concurrent.atomic.AtomicInteger symbolLastId
```
  - moduleLastId
```
private final java.util.concurrent.atomic.AtomicInteger moduleLastId
```
  - allModules
```
private final java.util.Set<RubyModule> allModules
```
  - timeZoneCache
```
private final java.util.Map<java.lang.String,org.joda.time.DateTimeZone> timeZoneCache
```
  - finalizers
```
private java.util.Map<Finalizable,java.lang.Object> finalizers
```
    A list of "external" finalizers (the ones, registered via ObjectSpace), weakly referenced, to be executed on tearDown.
  - internalFinalizers
```
private java.util.Map<Finalizable,java.lang.Object> internalFinalizers
```
    A list of JRuby-internal finalizers, weakly referenced, to be executed on tearDown.
  - finalizersMutex
```
private final java.lang.Object finalizersMutex
```
  - internalFinalizersMutex
```
private final java.lang.Object internalFinalizersMutex
```
  - executor
```
private java.util.concurrent.ExecutorService executor
```
  - fiberExecutor
```
private java.util.concurrent.ExecutorService fiberExecutor
```
  - hierarchyLock
```
private final java.lang.Object hierarchyLock
```
  - dynamicMethodSerial
```
private final java.util.concurrent.atomic.AtomicLong dynamicMethodSerial
```
  - moduleGeneration
```
private final java.util.concurrent.atomic.AtomicInteger moduleGeneration
```
  - boundMethods
```
private final java.util.Map<java.lang.String,java.util.Map<java.lang.String,java.lang.String>> boundMethods
```
  - selectorPool
```
private final SelectorPool selectorPool
```
  - runtimeCache
```
private final RuntimeCache runtimeCache
```
  - profiledMethods
```
private final ProfiledMethods profiledMethods
```
  - ERRNO_BACKTRACE_MESSAGE
```
public static final java.lang.String ERRNO_BACKTRACE_MESSAGE
```
    See Also:
    
    Constant Field Values
  - STOPIERATION_BACKTRACE_MESSAGE
```
public static final java.lang.String STOPIERATION_BACKTRACE_MESSAGE
```
    See Also:
    
    Constant Field Values
  - exceptionCount
```
private final java.util.concurrent.atomic.AtomicInteger exceptionCount
```
  - backtraceCount
```
private final java.util.concurrent.atomic.AtomicInteger backtraceCount
```
  - callerCount
```
private final java.util.concurrent.atomic.AtomicInteger callerCount
```
  - warningCount
```
private final java.util.concurrent.atomic.AtomicInteger warningCount
```
  - fixnumInvalidator
```
private Invalidator fixnumInvalidator
```
  - floatInvalidator
```
private Invalidator floatInvalidator
```
  - fixnumReopened
```
private boolean fixnumReopened
```
  - floatReopened
```
private boolean floatReopened
```
  - booting
```
private volatile boolean booting
```
  - envObject
```
private RubyHash envObject
```
  - coverageData
```
private final CoverageData coverageData
```
  - globalRuntime
```
private static Ruby globalRuntime
```
    The "global" runtime. Set to the first runtime created, normally.
  - threadLocalRuntime
```
private static java.lang.ThreadLocal<Ruby> threadLocalRuntime
```
    The "thread local" runtime. Set to the global runtime if unset.
  - random
```
private final java.util.Random random
```
    The runtime-local random number generator. Uses SecureRandom if permissions allow.
  - hashSeedK0
```
private long hashSeedK0
```
    The runtime-local seed for hash randomization
  - hashSeedK1
```
private long hashSeedK1
```
  - staticScopeFactory
```
private StaticScopeFactory staticScopeFactory
```
  - irManager
```
private IRManager irManager
```
  - recursive
```
private java.lang.ThreadLocal<java.util.Map<java.lang.String,RubyHash>> recursive
```
  - recursiveKey
```
private RubySymbol recursiveKey
```
  - inRecursiveListOperation
```
private java.lang.ThreadLocal<java.lang.Boolean> inRecursiveListOperation
```
  - ffi
```
private FFI ffi
```
  - javaProxyClassFactory
```
private JavaProxyClassFactory javaProxyClassFactory
```
  - profilingServiceLookup
```
private final ProfilingServiceLookup profilingServiceLookup
```
    Used to find the ProfilingService implementation to use. If profiling is disabled it's null
  - definedMessages
```
private java.util.EnumMap<DefinedMessage,RubyString> definedMessages
```
  - threadStatuses
```
private java.util.EnumMap<RubyThread.Status,RubyString> threadStatuses
```
  - DISABLED_OBJECTSPACE
```
private static final Ruby.ObjectSpacer DISABLED_OBJECTSPACE
```
  - ENABLED_OBJECTSPACE
```
private static final Ruby.ObjectSpacer ENABLED_OBJECTSPACE
```
  - objectSpacer
```
private final Ruby.ObjectSpacer objectSpacer
```
  - emptyFrozenArray
```
private RubyArray emptyFrozenArray
```
  - RUNTIME_NUMBER
```
private static final java.util.concurrent.atomic.AtomicInteger RUNTIME_NUMBER
```
  - runtimeNumber
```
private final int runtimeNumber
```
  - configBean
```
private final Config configBean
```
  - classCacheBean
```
private final ClassCache classCacheBean
```
  - runtimeBean
```
private final Runtime runtimeBean
```
- Constructor Detail
  - Ruby
```
private Ruby(RubyInstanceConfig config)
```
    Create and initialize a new JRuby runtime. The properties of the specified RubyInstanceConfig will be used to determine various JRuby runtime characteristics.
    
    Parameters:
    
    config - The configuration to use for the new instance
    
    See Also:
    
    RubyInstanceConfig
- Method Detail
  - registerMBeans
```
public void registerMBeans()
```
  - reinitialize
```
void reinitialize(boolean reinitCore)
```
  - newInstance
```
public static Ruby newInstance()
```
    Returns a new instance of the JRuby runtime configured with defaults.
    
    Returns:
    
    the JRuby runtime
    
    See Also:
    
    RubyInstanceConfig
  - newInstance
```
public static Ruby newInstance(RubyInstanceConfig config)
```
    Returns a new instance of the JRuby runtime configured as specified.
    
    Parameters:
    
    config - The instance configuration
    
    Returns:
    
    The JRuby runtime
    
    See Also:
    
    RubyInstanceConfig
  - newInstance
```
public static Ruby newInstance(java.io.InputStream in,
                               java.io.PrintStream out,
                               java.io.PrintStream err)
```
    Returns a new instance of the JRuby runtime configured with the given input, output and error streams and otherwise default configuration (except where specified system properties alter defaults).
    
    Parameters:
    
    in - the custom input stream
    
    out - the custom output stream
    
    err - the custom error stream
    
    Returns:
    
    the JRuby runtime
    
    See Also:
    
    RubyInstanceConfig
  - isGlobalRuntimeReady
```
public static boolean isGlobalRuntimeReady()
```
    Tests whether globalRuntime has been instantiated or not. This method is used by singleton model of org.jruby.embed.ScriptingContainer to decide what RubyInstanceConfig should be used. When a global runtime is not there, RubyInstanceConfig of AbstractContextProvider will be used to enact configurations set by a user. When a global runtime is already instantiated, RubyInstanceConfig of the global runtime should be used in ScriptingContaiener.
    
    Returns:
    
    true if a global runtime is instantiated, false for other.
  - setGlobalRuntimeFirstTimeOnly
```
private static void setGlobalRuntimeFirstTimeOnly(Ruby runtime)
```
    Set the global runtime to the given runtime only if it has no been set.
    
    Parameters:
    
    runtime - the runtime to use for global runtime
  - getGlobalRuntime
```
public static Ruby getGlobalRuntime()
```
    Get the global runtime.
    
    Returns:
    
    the global runtime
  - useAsGlobalRuntime
```
public void useAsGlobalRuntime()
```
    Convenience method for java integrators who may need to switch the notion of "global" runtime. Use JRuby.runtime.use_as_global_runtime from Ruby code to activate the current runtime as the global one.
  - clearGlobalRuntime
```
public static void clearGlobalRuntime()
```
    Clear the global runtime.
  - getThreadLocalRuntime
```
public static Ruby getThreadLocalRuntime()
```
    Get the thread-local runtime for the current thread, or null if unset.
    
    Returns:
    
    the thread-local runtime, or null if unset
  - setThreadLocalRuntime
```
public static void setThreadLocalRuntime(Ruby ruby)
```
    Set the thread-local runtime to the given runtime. Note that static threadlocals like this one can leak resources across (for example) application redeploys. If you use this, it is your responsibility to clean it up appropriately.
    
    Parameters:
    
    ruby - the new runtime for thread-local
  - evalScriptlet
```
public IRubyObject evalScriptlet(java.lang.String script)
```
    Evaluates a script under the current scope (perhaps the top-level scope) and returns the result (generally the last value calculated). This version goes straight into the interpreter, bypassing compilation and runtime preparation typical to normal script runs.
    
    Parameters:
    
    script - The scriptlet to run
  - evalScriptlet
```
public IRubyObject evalScriptlet(java.lang.String script,
                                 DynamicScope scope)
```
    Evaluates a script under the current scope (perhaps the top-level scope) and returns the result (generally the last value calculated). This version goes straight into the interpreter, bypassing compilation and runtime preparation typical to normal script runs. This version accepts a scope to use, so you can eval many times against the same scope.
    
    Parameters:
    
    script - The scriptlet to run
    
    scope - The scope to execute against (ManyVarsDynamicScope is recommended, so it can grow as needed)
  - executeScript
```
public IRubyObject executeScript(java.lang.String script,
                                 java.lang.String filename)
```
    Parse and execute the specified script This differs from the other methods in that it accepts a string-based script and parses and runs it as though it were loaded at a command-line. This is the preferred way to start up a new script when calling directly into the Ruby object (which is generally *dis*couraged.
    
    Parameters:
    
    script - The contents of the script to run as a normal, root script
    
    Returns:
    
    The last value of the script
  - runFromMain
```
public void runFromMain(java.io.InputStream inputStream,
                        java.lang.String filename)
```
    Run the script contained in the specified input stream, using the specified filename as the name of the script being executed. The stream will be read fully before being parsed and executed. The given filename will be used for the ruby $PROGRAM_NAME and $0 global variables in this runtime. This method is intended to be called once per runtime, generally from Main or from main-like top-level entry points. As part of executing the script loaded from the input stream, various RubyInstanceConfig properties will be used to determine whether to compile the script before execution or run with various wrappers (for looping, printing, and so on, see jruby -help).
    
    Parameters:
    
    inputStream - The InputStream from which to read the script contents
    
    filename - The filename to use when parsing, and for $PROGRAM_NAME and $0 ruby global variables.
  - parseFromMain
```
public Node parseFromMain(java.io.InputStream inputStream,
                          java.lang.String filename)
```
    Parse the script contained in the given input stream, using the given filename as the name of the script, and return the root Node. This is used to verify that the script syntax is valid, for jruby -c. The current scope (generally the top-level scope) is used as the parent scope for parsing.
    
    Parameters:
    
    inputStream - The input stream from which to read the script
    
    filename - The filename to use for parsing
  - runWithGetsLoop
```
@Deprecated
public IRubyObject runWithGetsLoop(Node scriptNode,
                                               boolean printing,
                                               boolean processLineEnds,
                                               boolean split,
                                               boolean unused)
```
    Deprecated.
    
    Run the given script with a "while gets; end" loop wrapped around it. This is primarily used for the -n command-line flag, to allow writing a short script that processes input lines using the specified code.
    
    Parameters:
    
    scriptNode - The root node of the script to execute
    
    printing - Whether $_ should be printed after each loop (as in the -p command-line flag)
    
    processLineEnds - Whether line endings should be processed by setting $\ to $/ and chop!ing every line read
    
    split - Whether to split each line read using String#split bytecode before executing.
    
    Returns:
    
    The result of executing the specified script
  - runWithGetsLoop
```
public IRubyObject runWithGetsLoop(Node scriptNode,
                                   boolean printing,
                                   boolean processLineEnds,
                                   boolean split)
```
    Run the given script with a "while gets; end" loop wrapped around it. This is primarily used for the -n command-line flag, to allow writing a short script that processes input lines using the specified code.
    
    Parameters:
    
    scriptNode - The root node of the script to execute
    
    printing - Whether $_ should be printed after each loop (as in the -p command-line flag)
    
    processLineEnds - Whether line endings should be processed by setting $\ to $/ and chop!ing every line read
    
    split - Whether to split each line read using String#split bytecode before executing.
    
    Returns:
    
    The result of executing the specified script
  - runNormally
```
@Deprecated
public IRubyObject runNormally(Node scriptNode,
                                           boolean unused)
```
    Deprecated.
    
    Run the specified script without any of the loop-processing wrapper code.
    
    Parameters:
    
    scriptNode - The root node of the script to be executed bytecode before execution
    
    Returns:
    
    The result of executing the script
  - runNormally
```
public IRubyObject runNormally(Node scriptNode)
```
    Run the specified script without any of the loop-processing wrapper code.
    
    Parameters:
    
    scriptNode - The root node of the script to be executed bytecode before execution
    
    Returns:
    
    The result of executing the script
  - tryCompile
```
public Script tryCompile(Node node)
```
    Try to compile the code associated with the given Node, returning an instance of the successfully-compiled Script or null if the script could not be compiled.
    
    Parameters:
    
    node - The node to attempt to compiled
    
    Returns:
    
    an instance of the successfully-compiled Script, or null.
  - tryCompile
```
public Script tryCompile(Node node,
                         ASTInspector inspector)
```
    Try to compile the code associated with the given Node, returning an instance of the successfully-compiled Script or null if the script could not be compiled. This version accepts an ASTInspector instance assumed to have appropriate flags set for compile optimizations, such as to turn on heap-based local variables to share an existing scope.
    
    Parameters:
    
    node - The node to attempt to compiled
    
    inspector - The ASTInspector to use for making optimization decisions
    
    Returns:
    
    an instance of the successfully-compiled Script, or null.
  - failForcedCompile
```
private void failForcedCompile(Node scriptNode)
                        throws RaiseException
```
    Throws:
    
    RaiseException
  - handeCompileError
```
private void handeCompileError(Node node,
                               java.lang.Throwable t)
```
  - tryCompile
```
private Script tryCompile(Node node,
                          java.lang.String cachedClassName,
                          JRubyClassLoader classLoader,
                          boolean dump)
```
  - tryCompile
```
private Script tryCompile(Node node,
                          java.lang.String cachedClassName,
                          JRubyClassLoader classLoader,
                          ASTInspector inspector,
                          boolean dump)
```
  - runScript
```
public IRubyObject runScript(Script script)
```
  - runScript
```
public IRubyObject runScript(Script script,
                             boolean wrap)
```
  - runScriptBody
```
public IRubyObject runScriptBody(Script script)
```
    This is used for the "gets" loop, and we bypass 'load' to use an already-prepared, already-pushed scope for the script body.
  - runInterpreter
```
public IRubyObject runInterpreter(ThreadContext context,
                                  Node rootNode,
                                  IRubyObject self)
```
  - runInterpreter
```
public IRubyObject runInterpreter(Node scriptNode)
```
  - runInterpreterBody
```
public IRubyObject runInterpreterBody(Node scriptNode)
```
    This is used for the "gets" loop, and we bypass 'load' to use an already-prepared, already-pushed scope for the script body.
  - getParser
```
public Parser getParser()
```
  - getBeanManager
```
public BeanManager getBeanManager()
```
  - getJITCompiler
```
public JITCompiler getJITCompiler()
```
  - getDefaultInstance
```
public static Ruby getDefaultInstance()
```
    Deprecated. use #newInstance()
  - getCurrentInstance
```
@Deprecated
public static Ruby getCurrentInstance()
```
    Deprecated.
  - setCurrentInstance
```
@Deprecated
public static void setCurrentInstance(Ruby runtime)
```
    Deprecated.
  - allocSymbolId
```
public int allocSymbolId()
```
  - allocModuleId
```
public int allocModuleId()
```
  - addModule
```
public void addModule(RubyModule module)
```
  - eachModule
```
public void eachModule(Function1<java.lang.Object,IRubyObject> func)
```
  - getModule
```
public RubyModule getModule(java.lang.String name)
```
    Retrieve the module with the given name from the Object namespace.
    
    Parameters:
    
    name - The name of the module
    
    Returns:
    
    The module or null if not found
  - fastGetModule
```
@Deprecated
public RubyModule fastGetModule(java.lang.String internedName)
```
    Deprecated.
  - getClass
```
public RubyClass getClass(java.lang.String name)
```
    Retrieve the class with the given name from the Object namespace.
    
    Parameters:
    
    name - The name of the class
    
    Returns:
    
    The class
  - fastGetClass
```
@Deprecated
public RubyClass fastGetClass(java.lang.String internedName)
```
    Deprecated.
    
    Retrieve the class with the given name from the Object namespace. The module name must be an interned string, but this method will be faster than the non-interned version.
    
    Parameters:
    
    internedName - the name of the class; must be an interned String!
    
    Returns:
  - defineClass
```
public RubyClass defineClass(java.lang.String name,
                             RubyClass superClass,
                             ObjectAllocator allocator)
```
    Define a new class under the Object namespace. Roughly equivalent to rb_define_class in MRI.
    
    Parameters:
    
    name - The name for the new class
    
    superClass - The super class for the new class
    
    allocator - An ObjectAllocator instance that can construct instances of the new class.
    
    Returns:
    
    The new class
  - defineClass
```
public RubyClass defineClass(java.lang.String name,
                             RubyClass superClass,
                             ObjectAllocator allocator,
                             CallSite[] callSites)
```
    A variation of defineClass that allows passing in an array of subplementary call sites for improving dynamic invocation performance.
    
    Parameters:
    
    name - The name for the new class
    
    superClass - The super class for the new class
    
    allocator - An ObjectAllocator instance that can construct instances of the new class.
    
    Returns:
    
    The new class
  - defineClassUnder
```
public RubyClass defineClassUnder(java.lang.String name,
                                  RubyClass superClass,
                                  ObjectAllocator allocator,
                                  RubyModule parent)
```
    Define a new class with the given name under the given module or class namespace. Roughly equivalent to rb_define_class_under in MRI. If the name specified is already bound, its value will be returned if: * It is a class * No new superclass is being defined
    
    Parameters:
    
    name - The name for the new class
    
    superClass - The super class for the new class
    
    allocator - An ObjectAllocator instance that can construct instances of the new class.
    
    parent - The namespace under which to define the new class
    
    Returns:
    
    The new class
  - defineClassUnder
```
public RubyClass defineClassUnder(java.lang.String name,
                                  RubyClass superClass,
                                  ObjectAllocator allocator,
                                  RubyModule parent,
                                  CallSite[] callSites)
```
    A variation of defineClassUnder that allows passing in an array of supplementary call sites to improve dynamic invocation.
    
    Parameters:
    
    name - The name for the new class
    
    superClass - The super class for the new class
    
    allocator - An ObjectAllocator instance that can construct instances of the new class.
    
    parent - The namespace under which to define the new class
    
    callSites - The array of call sites to add
    
    Returns:
    
    The new class
  - defineModule
```
public RubyModule defineModule(java.lang.String name)
```
    Define a new module under the Object namespace. Roughly equivalent to rb_define_module in MRI.
    
    Parameters:
    
    name - The name of the new module
  - defineModuleUnder
```
public RubyModule defineModuleUnder(java.lang.String name,
                                    RubyModule parent)
```
    Define a new module with the given name under the given module or class namespace. Roughly equivalent to rb_define_module_under in MRI.
    
    Parameters:
    
    name - The name of the new module
    
    parent - The class or module namespace under which to define the module
  - getOrCreateModule
```
public RubyModule getOrCreateModule(java.lang.String name)
```
    From Object, retrieve the named module. If it doesn't exist a new module is created.
    
    Parameters:
    
    name - The name of the module
  - getKCode
```
public KCode getKCode()
```
  - setKCode
```
public void setKCode(KCode kcode)
```
  - defineGlobalConstant
```
public void defineGlobalConstant(java.lang.String name,
                                 IRubyObject value)
```
    rb_define_global_const Define a constant on the global namespace (i.e. Object) with the given name and value.
    
    Parameters:
    
    name - the name
    
    value - the value
  - fetchGlobalConstant
```
public IRubyObject fetchGlobalConstant(java.lang.String name)
```
    Fetch a constant from the global namespace (i.e. Object) with the given name.
    
    Parameters:
    
    name - the name
    
    Returns:
    
    the value
  - isClassDefined
```
public boolean isClassDefined(java.lang.String name)
```
  - init
```
private void init()
```
    This method is called immediately after constructing the Ruby instance. The main thread is prepared for execution, all core classes and libraries are initialized, and any libraries required on the command line are loaded.
  - bootstrap
```
private void bootstrap()
```
  - initDefinedMessages
```
private void initDefinedMessages()
```
  - initThreadStatuses
```
private void initThreadStatuses()
```
  - initRoot
```
private void initRoot()
```
  - initCore
```
private void initCore()
```
  - getNilPrefilledArray
```
public IRubyObject[] getNilPrefilledArray()
```
  - initExceptions
```
private void initExceptions()
```
  - defineClassIfAllowed
```
private RubyClass defineClassIfAllowed(java.lang.String name,
                                       RubyClass superClass)
```
  - getErrno
```
public RubyClass getErrno(int n)
```
  - initErrno
```
private void initErrno()
```
    Create module Errno's Variables. We have this method since Errno does not have it's own java class.
  - createSysErr
```
private void createSysErr(int i,
                          java.lang.String name)
```
    Creates a system error.
    
    Parameters:
    
    i - the error code (will probably use a java exception instead)
    
    name - of the error to define.
  - initBuiltins
```
private void initBuiltins()
```
  - initRubyKernel
```
private void initRubyKernel()
```
  - addLazyBuiltin
```
private void addLazyBuiltin(java.lang.String name,
                            java.lang.String shortName,
                            java.lang.String className)
```
  - addBuiltinIfAllowed
```
private void addBuiltinIfAllowed(java.lang.String name,
                                 Library lib)
```
  - getIRManager
```
public IRManager getIRManager()
```
  - getTopSelf
```
public IRubyObject getTopSelf()
```
    Getter for property rubyTopSelf.
    
    Returns:
    
    Value of property rubyTopSelf.
  - getRootFiber
```
public IRubyObject getRootFiber()
```
  - setRootFiber
```
public void setRootFiber(IRubyObject fiber)
```
  - setCurrentDirectory
```
public void setCurrentDirectory(java.lang.String dir)
```
  - getCurrentDirectory
```
public java.lang.String getCurrentDirectory()
```
  - setCurrentLine
```
public void setCurrentLine(int line)
```
  - getCurrentLine
```
public int getCurrentLine()
```
  - setArgsFile
```
public void setArgsFile(IRubyObject argsFile)
```
  - getArgsFile
```
public IRubyObject getArgsFile()
```
  - getEtc
```
public RubyModule getEtc()
```
  - setEtc
```
public void setEtc(RubyModule etcModule)
```
  - getObject
```
public RubyClass getObject()
```
  - getBasicObject
```
public RubyClass getBasicObject()
```
  - getModule
```
public RubyClass getModule()
```
  - getClassClass
```
public RubyClass getClassClass()
```
  - getKernel
```
public RubyModule getKernel()
```
  - setKernel
```
void setKernel(RubyModule kernelModule)
```
  - getPrivateMethodMissing
```
public DynamicMethod getPrivateMethodMissing()
```
  - setPrivateMethodMissing
```
public void setPrivateMethodMissing(DynamicMethod method)
```
  - getProtectedMethodMissing
```
public DynamicMethod getProtectedMethodMissing()
```
  - setProtectedMethodMissing
```
public void setProtectedMethodMissing(DynamicMethod method)
```
  - getVariableMethodMissing
```
public DynamicMethod getVariableMethodMissing()
```
  - setVariableMethodMissing
```
public void setVariableMethodMissing(DynamicMethod method)
```
  - getSuperMethodMissing
```
public DynamicMethod getSuperMethodMissing()
```
  - setSuperMethodMissing
```
public void setSuperMethodMissing(DynamicMethod method)
```
  - getNormalMethodMissing
```
public DynamicMethod getNormalMethodMissing()
```
  - setNormalMethodMissing
```
public void setNormalMethodMissing(DynamicMethod method)
```
  - getDefaultMethodMissing
```
public DynamicMethod getDefaultMethodMissing()
```
  - setDefaultMethodMissing
```
public void setDefaultMethodMissing(DynamicMethod method)
```
  - getRespondToMethod
```
public DynamicMethod getRespondToMethod()
```
  - setRespondToMethod
```
public void setRespondToMethod(DynamicMethod rtm)
```
  - getRespondToMissingMethod
```
public DynamicMethod getRespondToMissingMethod()
```
  - setRespondToMissingMethod
```
public void setRespondToMissingMethod(DynamicMethod rtmm)
```
  - getDummy
```
public RubyClass getDummy()
```
  - getComparable
```
public RubyModule getComparable()
```
  - setComparable
```
void setComparable(RubyModule comparableModule)
```
  - getNumeric
```
public RubyClass getNumeric()
```
  - setNumeric
```
void setNumeric(RubyClass numericClass)
```
  - getFloat
```
public RubyClass getFloat()
```
  - setFloat
```
void setFloat(RubyClass floatClass)
```
  - getInteger
```
public RubyClass getInteger()
```
  - setInteger
```
void setInteger(RubyClass integerClass)
```
  - getFixnum
```
public RubyClass getFixnum()
```
  - setFixnum
```
void setFixnum(RubyClass fixnumClass)
```
  - getComplex
```
public RubyClass getComplex()
```
  - setComplex
```
void setComplex(RubyClass complexClass)
```
  - getRational
```
public RubyClass getRational()
```
  - setRational
```
void setRational(RubyClass rationalClass)
```
  - getEnumerable
```
public RubyModule getEnumerable()
```
  - setEnumerable
```
void setEnumerable(RubyModule enumerableModule)
```
  - getEnumerator
```
public RubyClass getEnumerator()
```
  - setEnumerator
```
void setEnumerator(RubyClass enumeratorClass)
```
  - getYielder
```
public RubyClass getYielder()
```
  - setYielder
```
void setYielder(RubyClass yielderClass)
```
  - getString
```
public RubyClass getString()
```
  - setString
```
void setString(RubyClass stringClass)
```
  - getEncoding
```
public RubyClass getEncoding()
```
  - setEncoding
```
void setEncoding(RubyClass encodingClass)
```
  - getConverter
```
public RubyClass getConverter()
```
  - setConverter
```
void setConverter(RubyClass converterClass)
```
  - getSymbol
```
public RubyClass getSymbol()
```
  - setSymbol
```
void setSymbol(RubyClass symbolClass)
```
  - getArray
```
public RubyClass getArray()
```
  - setArray
```
void setArray(RubyClass arrayClass)
```
  - getHash
```
public RubyClass getHash()
```
  - setHash
```
void setHash(RubyClass hashClass)
```
  - getRange
```
public RubyClass getRange()
```
  - setRange
```
void setRange(RubyClass rangeClass)
```
  - getTrue
```
public RubyBoolean getTrue()
```
    Returns the "true" instance from the instance pool.
    
    Returns:
    
    The "true" instance.
  - getFalse
```
public RubyBoolean getFalse()
```
    Returns the "false" instance from the instance pool.
    
    Returns:
    
    The "false" instance.
  - getNil
```
public IRubyObject getNil()
```
    Returns the "nil" singleton instance.
    
    Returns:
    
    "nil"
  - getSingleNilArray
```
public IRubyObject[] getSingleNilArray()
```
  - getNilClass
```
public RubyClass getNilClass()
```
  - setNilClass
```
void setNilClass(RubyClass nilClass)
```
  - getTrueClass
```
public RubyClass getTrueClass()
```
  - setTrueClass
```
void setTrueClass(RubyClass trueClass)
```
  - getFalseClass
```
public RubyClass getFalseClass()
```
  - setFalseClass
```
void setFalseClass(RubyClass falseClass)
```
  - getProc
```
public RubyClass getProc()
```
  - setProc
```
void setProc(RubyClass procClass)
```
  - getBinding
```
public RubyClass getBinding()
```
  - setBinding
```
void setBinding(RubyClass bindingClass)
```
  - getMethod
```
public RubyClass getMethod()
```
  - setMethod
```
void setMethod(RubyClass methodClass)
```
  - getUnboundMethod
```
public RubyClass getUnboundMethod()
```
  - setUnboundMethod
```
void setUnboundMethod(RubyClass unboundMethodClass)
```
  - getMatchData
```
public RubyClass getMatchData()
```
  - setMatchData
```
void setMatchData(RubyClass matchDataClass)
```
  - getRegexp
```
public RubyClass getRegexp()
```
  - setRegexp
```
void setRegexp(RubyClass regexpClass)
```
  - getTime
```
public RubyClass getTime()
```
  - setTime
```
void setTime(RubyClass timeClass)
```
  - getMath
```
public RubyModule getMath()
```
  - setMath
```
void setMath(RubyModule mathModule)
```
  - getMarshal
```
public RubyModule getMarshal()
```
  - setMarshal
```
void setMarshal(RubyModule marshalModule)
```
  - getBignum
```
public RubyClass getBignum()
```
  - setBignum
```
void setBignum(RubyClass bignumClass)
```
  - getDir
```
public RubyClass getDir()
```
  - setDir
```
void setDir(RubyClass dirClass)
```
  - getFile
```
public RubyClass getFile()
```
  - setFile
```
void setFile(RubyClass fileClass)
```
  - getFileStat
```
public RubyClass getFileStat()
```
  - setFileStat
```
void setFileStat(RubyClass fileStatClass)
```
  - getFileTest
```
public RubyModule getFileTest()
```
  - setFileTest
```
void setFileTest(RubyModule fileTestModule)
```
  - getIO
```
public RubyClass getIO()
```
  - setIO
```
void setIO(RubyClass ioClass)
```
  - getThread
```
public RubyClass getThread()
```
  - setThread
```
void setThread(RubyClass threadClass)
```
  - getThreadGroup
```
public RubyClass getThreadGroup()
```
  - setThreadGroup
```
void setThreadGroup(RubyClass threadGroupClass)
```
  - getDefaultThreadGroup
```
public RubyThreadGroup getDefaultThreadGroup()
```
  - setDefaultThreadGroup
```
void setDefaultThreadGroup(RubyThreadGroup defaultThreadGroup)
```
  - getContinuation
```
public RubyClass getContinuation()
```
  - setContinuation
```
void setContinuation(RubyClass continuationClass)
```
  - getStructClass
```
public RubyClass getStructClass()
```
  - setStructClass
```
void setStructClass(RubyClass structClass)
```
  - getRandomClass
```
public RubyClass getRandomClass()
```
  - setRandomClass
```
void setRandomClass(RubyClass randomClass)
```
  - getTmsStruct
```
public IRubyObject getTmsStruct()
```
  - setTmsStruct
```
void setTmsStruct(RubyClass tmsStruct)
```
  - getPasswdStruct
```
public IRubyObject getPasswdStruct()
```
  - setPasswdStruct
```
public void setPasswdStruct(RubyClass passwdStruct)
```
  - getGroupStruct
```
public IRubyObject getGroupStruct()
```
  - setGroupStruct
```
public void setGroupStruct(RubyClass groupStruct)
```
  - getGC
```
public RubyModule getGC()
```
  - setGC
```
void setGC(RubyModule gcModule)
```
  - getObjectSpaceModule
```
public RubyModule getObjectSpaceModule()
```
  - setObjectSpaceModule
```
void setObjectSpaceModule(RubyModule objectSpaceModule)
```
  - getProcess
```
public RubyModule getProcess()
```
  - setProcess
```
void setProcess(RubyModule processModule)
```
  - getProcStatus
```
public RubyClass getProcStatus()
```
  - setProcStatus
```
void setProcStatus(RubyClass procStatusClass)
```
  - getProcUID
```
public RubyModule getProcUID()
```
  - setProcUID
```
void setProcUID(RubyModule procUIDModule)
```
  - getProcGID
```
public RubyModule getProcGID()
```
  - setProcGID
```
void setProcGID(RubyModule procGIDModule)
```
  - getProcSysModule
```
public RubyModule getProcSysModule()
```
  - setProcSys
```
void setProcSys(RubyModule procSysModule)
```
  - getPrecision
```
public RubyModule getPrecision()
```
  - setPrecision
```
void setPrecision(RubyModule precisionModule)
```
  - getENV
```
public RubyHash getENV()
```
  - setENV
```
public void setENV(RubyHash env)
```
  - getLocation
```
public RubyClass getLocation()
```
  - setLocation
```
public void setLocation(RubyClass location)
```
  - getErrno
```
public RubyModule getErrno()
```
  - getException
```
public RubyClass getException()
```
  - setException
```
void setException(RubyClass exceptionClass)
```
  - getNameError
```
public RubyClass getNameError()
```
  - getNameErrorMessage
```
public RubyClass getNameErrorMessage()
```
  - getNoMethodError
```
public RubyClass getNoMethodError()
```
  - getSignalException
```
public RubyClass getSignalException()
```
  - getRangeError
```
public RubyClass getRangeError()
```
  - getSystemExit
```
public RubyClass getSystemExit()
```
  - getLocalJumpError
```
public RubyClass getLocalJumpError()
```
  - getNativeException
```
public RubyClass getNativeException()
```
  - getSystemCallError
```
public RubyClass getSystemCallError()
```
  - getKeyError
```
public RubyClass getKeyError()
```
  - getFatal
```
public RubyClass getFatal()
```
  - getInterrupt
```
public RubyClass getInterrupt()
```
  - getTypeError
```
public RubyClass getTypeError()
```
  - getArgumentError
```
public RubyClass getArgumentError()
```
  - getIndexError
```
public RubyClass getIndexError()
```
  - getStopIteration
```
public RubyClass getStopIteration()
```
  - getSyntaxError
```
public RubyClass getSyntaxError()
```
  - getStandardError
```
public RubyClass getStandardError()
```
  - getRuntimeError
```
public RubyClass getRuntimeError()
```
  - getIOError
```
public RubyClass getIOError()
```
  - getLoadError
```
public RubyClass getLoadError()
```
  - getNotImplementedError
```
public RubyClass getNotImplementedError()
```
  - getSecurityError
```
public RubyClass getSecurityError()
```
  - getNoMemoryError
```
public RubyClass getNoMemoryError()
```
  - getRegexpError
```
public RubyClass getRegexpError()
```
  - getInterruptedRegexpError
```
public RubyClass getInterruptedRegexpError()
```
  - getEOFError
```
public RubyClass getEOFError()
```
  - getThreadError
```
public RubyClass getThreadError()
```
  - getConcurrencyError
```
public RubyClass getConcurrencyError()
```
  - getSystemStackError
```
public RubyClass getSystemStackError()
```
  - getZeroDivisionError
```
public RubyClass getZeroDivisionError()
```
  - getFloatDomainError
```
public RubyClass getFloatDomainError()
```
  - getMathDomainError
```
public RubyClass getMathDomainError()
```
  - getEncodingError
```
public RubyClass getEncodingError()
```
  - getEncodingCompatibilityError
```
public RubyClass getEncodingCompatibilityError()
```
  - getConverterNotFoundError
```
public RubyClass getConverterNotFoundError()
```
  - getFiberError
```
public RubyClass getFiberError()
```
  - getUndefinedConversionError
```
public RubyClass getUndefinedConversionError()
```
  - getInvalidByteSequenceError
```
public RubyClass getInvalidByteSequenceError()
```
  - getDefaultRand
```
public RubyRandom.RandomType getDefaultRand()
```
  - setDefaultRand
```
public void setDefaultRand(RubyRandom.RandomType defaultRand)
```
  - getCharsetMap
```
public RubyHash getCharsetMap()
```
  - getVerbose
```
public IRubyObject getVerbose()
```
    Getter for property isVerbose.
    
    Returns:
    
    Value of property isVerbose.
  - isVerbose
```
public boolean isVerbose()
```
  - warningsEnabled
```
public boolean warningsEnabled()
```
  - setVerbose
```
public void setVerbose(IRubyObject verbose)
```
    Setter for property isVerbose.
    
    Parameters:
    
    verbose - New value of property isVerbose.
  - getDebug
```
public IRubyObject getDebug()
```
    Getter for property isDebug.
    
    Returns:
    
    Value of property isDebug.
  - isDebug
```
public boolean isDebug()
```
  - setDebug
```
public void setDebug(IRubyObject debug)
```
    Setter for property isDebug.
    
    Parameters:
    
    debug - New value of property isDebug.
  - getJavaSupport
```
public JavaSupport getJavaSupport()
```
  - getClassLoader
```
public static java.lang.ClassLoader getClassLoader()
```
  - getJRubyClassLoader
```
public JRubyClassLoader getJRubyClassLoader()
```
    TODO the property jrubyClassLoader will only be set in constructor. in the first call of getJRubyClassLoader. So the field jrubyClassLoader can be final set in the constructor directly and we avoid the synchronized here.
    
    Returns:
  - defineVariable
```
public void defineVariable(GlobalVariable variable,
                           GlobalVariable.Scope scope)
```
    Defines a global variable
  - defineReadonlyVariable
```
public void defineReadonlyVariable(java.lang.String name,
                                   IRubyObject value,
                                   GlobalVariable.Scope scope)
```
    defines a readonly global variable
  - parseFile
```
public Node parseFile(java.io.InputStream in,
                      java.lang.String file,
                      DynamicScope scope,
                      int lineNumber)
```
  - parseFileFromMain
```
public Node parseFileFromMain(java.io.InputStream in,
                              java.lang.String file,
                              DynamicScope scope)
```
  - parseFile
```
public Node parseFile(java.io.InputStream in,
                      java.lang.String file,
                      DynamicScope scope)
```
  - parseInline
```
public Node parseInline(java.io.InputStream in,
                        java.lang.String file,
                        DynamicScope scope)
```
  - setupSourceEncoding
```
private void setupSourceEncoding(ParserConfiguration parserConfig)
```
  - parseEval
```
public Node parseEval(java.lang.String content,
                      java.lang.String file,
                      DynamicScope scope,
                      int lineNumber)
```
  - parse
```
@Deprecated
public Node parse(java.lang.String content,
                              java.lang.String file,
                              DynamicScope scope,
                              int lineNumber,
                              boolean extraPositionInformation)
```
    Deprecated.
  - parseEval
```
public Node parseEval(org.jruby.util.ByteList content,
                      java.lang.String file,
                      DynamicScope scope,
                      int lineNumber)
```
  - parse
```
public Node parse(org.jruby.util.ByteList content,
                  java.lang.String file,
                  DynamicScope scope,
                  int lineNumber,
                  boolean extraPositionInformation)
```
  - getThreadService
```
public ThreadService getThreadService()
```
  - getCurrentContext
```
public ThreadContext getCurrentContext()
```
  - getLoadService
```
public LoadService getLoadService()
```
    Returns the loadService.
    
    Returns:
    
    ILoadService
  - getDefaultInternalEncoding
```
public org.jcodings.Encoding getDefaultInternalEncoding()
```
    This is an internal encoding if actually specified via default_internal= or passed in via -E.
    
    Returns:
    
    null or encoding
  - setDefaultInternalEncoding
```
public void setDefaultInternalEncoding(org.jcodings.Encoding defaultInternalEncoding)
```
  - getDefaultExternalEncoding
```
public org.jcodings.Encoding getDefaultExternalEncoding()
```
  - setDefaultExternalEncoding
```
public void setDefaultExternalEncoding(org.jcodings.Encoding defaultExternalEncoding)
```
  - getEncodingService
```
public EncodingService getEncodingService()
```
  - getWarnings
```
public RubyWarnings getWarnings()
```
  - getErrorStream
```
public java.io.PrintStream getErrorStream()
```
  - getInputStream
```
public java.io.InputStream getInputStream()
```
  - getOutputStream
```
public java.io.PrintStream getOutputStream()
```
  - getClassFromPath
```
public RubyModule getClassFromPath(java.lang.String path)
```
  - printError
```
public void printError(RubyException excp)
```
    Prints an error with backtrace to the error stream. MRI: eval.c - error_print()
  - loadFile
```
public void loadFile(java.lang.String scriptName,
                     java.io.InputStream in,
                     boolean wrap)
```
  - compileAndLoadFile
```
public void compileAndLoadFile(java.lang.String filename,
                               java.io.InputStream in,
                               boolean wrap)
```
  - loadScript
```
public void loadScript(Script script)
```
  - loadScript
```
public void loadScript(Script script,
                       boolean wrap)
```
  - loadExtension
```
public void loadExtension(java.lang.String extName,
                          BasicLibraryService extension,
                          boolean wrap)
```
    Load the given BasicLibraryService instance, wrapping it in Ruby framing to ensure it is isolated from any parent scope.
    
    Parameters:
    
    extName - The name of the extension, to go on the frame wrapping it
    
    extension - The extension object to load
    
    wrap - Whether to use a new "self" for toplevel
  - addBoundMethod
```
public void addBoundMethod(java.lang.String className,
                           java.lang.String methodName,
                           java.lang.String rubyName)
```
  - getBoundMethods
```
public java.util.Map<java.lang.String,java.util.Map<java.lang.String,java.lang.String>> getBoundMethods()
```
  - setJavaProxyClassFactory
```
public void setJavaProxyClassFactory(JavaProxyClassFactory factory)
```
  - getJavaProxyClassFactory
```
public JavaProxyClassFactory getJavaProxyClassFactory()
```
  - addEventHook
```
public void addEventHook(EventHook hook)
```
  - removeEventHook
```
public void removeEventHook(EventHook hook)
```
  - setTraceFunction
```
public void setTraceFunction(RubyProc traceFunction)
```
  - callEventHooks
```
public void callEventHooks(ThreadContext context,
                           RubyEvent event,
                           java.lang.String file,
                           int line,
                           java.lang.String name,
                           IRubyObject type)
```
  - hasEventHooks
```
public boolean hasEventHooks()
```
  - getGlobalVariables
```
public GlobalVariables getGlobalVariables()
```
  - setGlobalVariables
```
public void setGlobalVariables(GlobalVariables globalVariables)
```
  - pushExitBlock
```
public IRubyObject pushExitBlock(RubyProc proc)
```
    Push block onto exit stack. When runtime environment exits these blocks will be evaluated.
    
    Returns:
    
    the element that was pushed onto stack
  - addInternalFinalizer
```
public void addInternalFinalizer(Finalizable finalizer)
```
  - addFinalizer
```
public void addFinalizer(Finalizable finalizer)
```
  - removeInternalFinalizer
```
public void removeInternalFinalizer(Finalizable finalizer)
```
  - removeFinalizer
```
public void removeFinalizer(Finalizable finalizer)
```
  - tearDown
```
public void tearDown()
```
    Make sure Kernel#at_exit procs getService invoked on runtime shutdown. This method needs to be explicitly called to work properly. I thought about using finalize(), but that did not work and I am not sure the runtime will be at a state to run procs by the time Ruby is going away. This method can contain any other things that need to be cleaned up at shutdown.
  - tearDown
```
public void tearDown(boolean systemExit)
```
  - releaseClassLoader
```
public void releaseClassLoader()
```
    By default tearDown(boolean) does not release the class-loader's resources as threads might be still running accessing the classes/packages even after the runtime has been torn down. This method exists to handle such cases, e.g. with embedded uses we always release the runtime loader but not otherwise - you should do that manually.
  - printProfileData
```
public void printProfileData(ProfileCollection profileData)
```
    TDOD remove the synchronized. Synchronization should be a implementation detail of the ProfilingService.
    
    Parameters:
    
    profileData -
    
    output -
  - getProfilingServiceLookup
```
private ProfilingServiceLookup getProfilingServiceLookup()
```
    Simple getter for #profilingServiceLookup to avoid direct property access
    
    Returns:
    
    #profilingServiceLookup
  - getProfilingService
```
public ProfilingService getProfilingService()
```
    Returns:
    
    the, for this ruby instance, configured implementation of ProfilingService, or null
  - newEmptyArray
```
public RubyArray newEmptyArray()
```
  - newArray
```
public RubyArray newArray()
```
  - newArrayLight
```
public RubyArray newArrayLight()
```
  - newArray
```
public RubyArray newArray(IRubyObject object)
```
  - newArray
```
public RubyArray newArray(IRubyObject car,
                          IRubyObject cdr)
```
  - newArray
```
public RubyArray newArray(IRubyObject... objects)
```
  - newArrayNoCopy
```
public RubyArray newArrayNoCopy(IRubyObject... objects)
```
  - newArrayNoCopyLight
```
public RubyArray newArrayNoCopyLight(IRubyObject... objects)
```
  - newArray
```
public RubyArray newArray(java.util.List<IRubyObject> list)
```
  - newArray
```
public RubyArray newArray(int size)
```
  - getEmptyFrozenArray
```
public RubyArray getEmptyFrozenArray()
```
  - newBoolean
```
public RubyBoolean newBoolean(boolean value)
```
  - newFileStat
```
public RubyFileStat newFileStat(java.lang.String filename,
                                boolean lstat)
```
  - newFileStat
```
public RubyFileStat newFileStat(java.io.FileDescriptor descriptor)
```
  - newFixnum
```
public RubyFixnum newFixnum(long value)
```
  - newFixnum
```
public RubyFixnum newFixnum(int value)
```
  - newFixnum
```
public RubyFixnum newFixnum(jnr.constants.Constant value)
```
  - newFloat
```
public RubyFloat newFloat(double value)
```
  - newNumeric
```
public RubyNumeric newNumeric()
```
  - newRational
```
public RubyRational newRational(long num,
                                long den)
```
  - newRationalReduced
```
public RubyRational newRationalReduced(long num,
                                       long den)
```
  - newProc
```
public RubyProc newProc(Block.Type type,
                        Block block)
```
  - newBlockPassProc
```
public RubyProc newBlockPassProc(Block.Type type,
                                 Block block)
```
  - newBinding
```
public RubyBinding newBinding()
```
  - newBinding
```
public RubyBinding newBinding(Binding binding)
```
  - newString
```
public RubyString newString()
```
  - newString
```
public RubyString newString(java.lang.String string)
```
  - newString
```
public RubyString newString(org.jruby.util.ByteList byteList)
```
  - newStringShared
```
@Deprecated
public RubyString newStringShared(org.jruby.util.ByteList byteList)
```
    Deprecated.
  - newSymbol
```
public RubySymbol newSymbol(java.lang.String name)
```
  - newSymbol
```
public RubySymbol newSymbol(org.jruby.util.ByteList name)
```
  - fastNewSymbol
```
public RubySymbol fastNewSymbol(java.lang.String internedName)
```
    Faster than newSymbol(String) if you already have an interned name String. Don't intern your string just to call this version - the overhead of interning will more than wipe out any benefit from the faster lookup.
    
    Parameters:
    
    internedName - the symbol name, must be interned! if in doubt, call newSymbol(String) instead.
    
    Returns:
    
    the symbol for name
  - newTime
```
public RubyTime newTime(long milliseconds)
```
  - newRuntimeError
```
public RaiseException newRuntimeError(java.lang.String message)
```
  - newArgumentError
```
public RaiseException newArgumentError(java.lang.String message)
```
  - newArgumentError
```
public RaiseException newArgumentError(int got,
                                       int expected)
```
  - newArgumentError
```
public RaiseException newArgumentError(java.lang.String name,
                                       int got,
                                       int expected)
```
  - newErrnoEBADFError
```
public RaiseException newErrnoEBADFError()
```
  - newErrnoEISCONNError
```
public RaiseException newErrnoEISCONNError()
```
  - newErrnoEINPROGRESSError
```
public RaiseException newErrnoEINPROGRESSError()
```
  - newErrnoEINPROGRESSWritableError
```
public RaiseException newErrnoEINPROGRESSWritableError()
```
  - newErrnoENOPROTOOPTError
```
public RaiseException newErrnoENOPROTOOPTError()
```
  - newErrnoEPIPEError
```
public RaiseException newErrnoEPIPEError()
```
  - newErrnoECONNABORTEDError
```
public RaiseException newErrnoECONNABORTEDError()
```
  - newErrnoECONNREFUSEDError
```
public RaiseException newErrnoECONNREFUSEDError()
```
  - newErrnoECONNRESETError
```
public RaiseException newErrnoECONNRESETError()
```
  - newErrnoEADDRINUSEError
```
public RaiseException newErrnoEADDRINUSEError()
```
  - newErrnoEADDRINUSEError
```
public RaiseException newErrnoEADDRINUSEError(java.lang.String message)
```
  - newErrnoEHOSTUNREACHError
```
public RaiseException newErrnoEHOSTUNREACHError(java.lang.String message)
```
  - newErrnoEINVALError
```
public RaiseException newErrnoEINVALError()
```
  - newErrnoENOENTError
```
public RaiseException newErrnoENOENTError()
```
  - newErrnoEACCESError
```
public RaiseException newErrnoEACCESError(java.lang.String message)
```
  - newErrnoEAGAINError
```
public RaiseException newErrnoEAGAINError(java.lang.String message)
```
  - newErrnoEAGAINReadableError
```
public RaiseException newErrnoEAGAINReadableError(java.lang.String message)
```
  - newErrnoEAGAINWritableError
```
public RaiseException newErrnoEAGAINWritableError(java.lang.String message)
```
  - newErrnoEISDirError
```
public RaiseException newErrnoEISDirError(java.lang.String message)
```
  - newErrnoEPERMError
```
public RaiseException newErrnoEPERMError(java.lang.String name)
```
  - newErrnoEISDirError
```
public RaiseException newErrnoEISDirError()
```
  - newErrnoESPIPEError
```
public RaiseException newErrnoESPIPEError()
```
  - newErrnoEBADFError
```
public RaiseException newErrnoEBADFError(java.lang.String message)
```
  - newErrnoEINPROGRESSError
```
public RaiseException newErrnoEINPROGRESSError(java.lang.String message)
```
  - newErrnoEINPROGRESSWritableError
```
public RaiseException newErrnoEINPROGRESSWritableError(java.lang.String message)
```
  - newErrnoEISCONNError
```
public RaiseException newErrnoEISCONNError(java.lang.String message)
```
  - newErrnoEINVALError
```
public RaiseException newErrnoEINVALError(java.lang.String message)
```
  - newErrnoENOTDIRError
```
public RaiseException newErrnoENOTDIRError(java.lang.String message)
```
  - newErrnoENOTEMPTYError
```
public RaiseException newErrnoENOTEMPTYError(java.lang.String message)
```
  - newErrnoENOTSOCKError
```
public RaiseException newErrnoENOTSOCKError(java.lang.String message)
```
  - newErrnoENOTCONNError
```
public RaiseException newErrnoENOTCONNError(java.lang.String message)
```
  - newErrnoENOTCONNError
```
public RaiseException newErrnoENOTCONNError()
```
  - newErrnoENOENTError
```
public RaiseException newErrnoENOENTError(java.lang.String message)
```
  - newErrnoESPIPEError
```
public RaiseException newErrnoESPIPEError(java.lang.String message)
```
  - newErrnoEEXISTError
```
public RaiseException newErrnoEEXISTError(java.lang.String message)
```
  - newErrnoEDOMError
```
public RaiseException newErrnoEDOMError(java.lang.String message)
```
  - newErrnoECHILDError
```
public RaiseException newErrnoECHILDError()
```
  - newErrnoEADDRNOTAVAILError
```
public RaiseException newErrnoEADDRNOTAVAILError(java.lang.String message)
```
  - newErrnoESRCHError
```
public RaiseException newErrnoESRCHError()
```
  - newErrnoEWOULDBLOCKError
```
public RaiseException newErrnoEWOULDBLOCKError()
```
  - newErrnoEDESTADDRREQError
```
public RaiseException newErrnoEDESTADDRREQError(java.lang.String func)
```
  - newIndexError
```
public RaiseException newIndexError(java.lang.String message)
```
  - newSecurityError
```
public RaiseException newSecurityError(java.lang.String message)
```
  - newSystemCallError
```
public RaiseException newSystemCallError(java.lang.String message)
```
  - newKeyError
```
public RaiseException newKeyError(java.lang.String message)
```
  - newErrnoFromLastPOSIXErrno
```
public RaiseException newErrnoFromLastPOSIXErrno()
```
  - newErrnoFromInt
```
public RaiseException newErrnoFromInt(int errno,
                                      java.lang.String methodName,
                                      java.lang.String message)
```
  - newErrnoFromInt
```
public RaiseException newErrnoFromInt(int errno,
                                      java.lang.String message)
```
  - newErrnoFromInt
```
public RaiseException newErrnoFromInt(int errno)
```
  - newErrnoEADDRFromBindException
```
public RaiseException newErrnoEADDRFromBindException(java.net.BindException be)
```
  - newErrnoEADDRFromBindException
```
public RaiseException newErrnoEADDRFromBindException(java.net.BindException be,
                                                     java.lang.String contextMessage)
```
  - newTypeError
```
public RaiseException newTypeError(java.lang.String message)
```
  - newThreadError
```
public RaiseException newThreadError(java.lang.String message)
```
  - newConcurrencyError
```
public RaiseException newConcurrencyError(java.lang.String message)
```
  - newSyntaxError
```
public RaiseException newSyntaxError(java.lang.String message)
```
  - newRegexpError
```
public RaiseException newRegexpError(java.lang.String message)
```
  - newInterruptedRegexpError
```
public RaiseException newInterruptedRegexpError(java.lang.String message)
```
  - newRangeError
```
public RaiseException newRangeError(java.lang.String message)
```
  - newNotImplementedError
```
public RaiseException newNotImplementedError(java.lang.String message)
```
  - newInvalidEncoding
```
public RaiseException newInvalidEncoding(java.lang.String message)
```
  - newIllegalSequence
```
public RaiseException newIllegalSequence(java.lang.String message)
```
  - newNoMethodError
```
public RaiseException newNoMethodError(java.lang.String message,
                                       java.lang.String name,
                                       IRubyObject args)
```
  - newNameError
```
public RaiseException newNameError(java.lang.String message,
                                   java.lang.String name)
```
  - newNameErrorObject
```
public RaiseException newNameErrorObject(java.lang.String message,
                                         IRubyObject name)
```
  - newNameError
```
public RaiseException newNameError(java.lang.String message,
                                   java.lang.String name,
                                   java.lang.Throwable origException)
```
  - newNameError
```
public RaiseException newNameError(java.lang.String message,
                                   java.lang.String name,
                                   java.lang.Throwable origException,
                                   boolean printWhenVerbose)
```
  - newLocalJumpError
```
public RaiseException newLocalJumpError(RubyLocalJumpError.Reason reason,
                                        IRubyObject exitValue,
                                        java.lang.String message)
```
  - newLocalJumpErrorNoBlock
```
public RaiseException newLocalJumpErrorNoBlock()
```
  - newRedoLocalJumpError
```
public RaiseException newRedoLocalJumpError()
```
  - newLoadError
```
public RaiseException newLoadError(java.lang.String message)
```
  - newLoadError
```
public RaiseException newLoadError(java.lang.String message,
                                   java.lang.String path)
```
  - newFrozenError
```
public RaiseException newFrozenError(java.lang.String objectType)
```
  - newFrozenError
```
public RaiseException newFrozenError(java.lang.String objectType,
                                     boolean runtimeError)
```
  - newSystemStackError
```
public RaiseException newSystemStackError(java.lang.String message)
```
  - newSystemStackError
```
public RaiseException newSystemStackError(java.lang.String message,
                                          java.lang.StackOverflowError soe)
```
  - newSystemExit
```
public RaiseException newSystemExit(int status)
```
  - newSystemExit
```
public RaiseException newSystemExit(int status,
                                    java.lang.String message)
```
  - newIOError
```
public RaiseException newIOError(java.lang.String message)
```
  - newStandardError
```
public RaiseException newStandardError(java.lang.String message)
```
  - newIOErrorFromException
```
public RaiseException newIOErrorFromException(java.io.IOException ioe)
```
  - newTypeError
```
public RaiseException newTypeError(IRubyObject receivedObject,
                                   RubyClass expectedType)
```
  - newTypeError
```
public RaiseException newTypeError(IRubyObject receivedObject,
                                   RubyModule expectedType)
```
  - newTypeError
```
public RaiseException newTypeError(IRubyObject receivedObject,
                                   java.lang.String expectedType)
```
  - newEOFError
```
public RaiseException newEOFError()
```
  - newEOFError
```
public RaiseException newEOFError(java.lang.String message)
```
  - newZeroDivisionError
```
public RaiseException newZeroDivisionError()
```
  - newFloatDomainError
```
public RaiseException newFloatDomainError(java.lang.String message)
```
  - newMathDomainError
```
public RaiseException newMathDomainError(java.lang.String message)
```
  - newEncodingError
```
public RaiseException newEncodingError(java.lang.String message)
```
  - newEncodingCompatibilityError
```
public RaiseException newEncodingCompatibilityError(java.lang.String message)
```
  - newConverterNotFoundError
```
public RaiseException newConverterNotFoundError(java.lang.String message)
```
  - newFiberError
```
public RaiseException newFiberError(java.lang.String message)
```
  - newUndefinedConversionError
```
public RaiseException newUndefinedConversionError(java.lang.String message)
```
  - newInvalidByteSequenceError
```
public RaiseException newInvalidByteSequenceError(java.lang.String message)
```
  - newRaiseException
```
public RaiseException newRaiseException(RubyClass exceptionClass,
                                        java.lang.String message)
```
    Parameters:
    
    exceptionClass -
    
    message -
    
    Returns:
  - newLightweightErrnoException
```
private RaiseException newLightweightErrnoException(RubyClass exceptionClass,
                                                    java.lang.String message)
```
    Generate one of the ERRNO exceptions. This differs from the normal logic by avoiding the generation of a backtrace. Many ERRNO values are expected, such as EAGAIN, and JRuby pays a very high cost to generate backtraces that are never used. The flags -Xerrno.backtrace=true or the property jruby.errno.backtrace=true forces all errno exceptions to generate a backtrace.
    
    Parameters:
    
    exceptionClass -
    
    message -
    
    Returns:
  - newLightweightStopIterationError
```
public RaiseException newLightweightStopIterationError(java.lang.String message)
```
    Generate a StopIteration exception. This differs from the normal logic by avoiding the generation of a backtrace. StopIteration is used by Enumerator to end an external iteration, and so generating a full backtrace is usually unreasonable overhead. The flag -Xstop_iteration.backtrace=true or the property jruby.stop_iteration.backtrace=true forces all StopIteration exceptions to generate a backtrace.
    
    Parameters:
    
    message - the message for the exception
  - newData
```
public RubyObject.Data newData(RubyClass objectClass,
                               java.lang.Object sval)
```
  - getSymbolTable
```
public RubySymbol.SymbolTable getSymbolTable()
```
  - getObjectSpace
```
public ObjectSpace getObjectSpace()
```
  - putFilenoMap
```
public void putFilenoMap(int external,
                         int internal)
```
  - getFilenoExtMap
```
public int getFilenoExtMap(int external)
```
  - getFilenoIntMap
```
public int getFilenoIntMap(int internal)
```
  - getFilenoIntMapSize
```
public int getFilenoIntMapSize()
```
  - removeFilenoIntMap
```
public void removeFilenoIntMap(int internal)
```
  - getFileno
```
public int getFileno(ChannelDescriptor descriptor)
```
    Get the "external" fileno for a given ChannelDescriptor. Primarily for the shared 0, 1, and 2 filenos, which we can't actually share across JRuby runtimes.
    
    Parameters:
    
    descriptor - The descriptor for which to getService the fileno
    
    Returns:
    
    The external fileno for the descriptor
  - registerDescriptor
```
@Deprecated
public void registerDescriptor(ChannelDescriptor descriptor,
                                           boolean isRetained)
```
    Deprecated.
  - registerDescriptor
```
@Deprecated
public void registerDescriptor(ChannelDescriptor descriptor)
```
    Deprecated.
  - unregisterDescriptor
```
@Deprecated
public void unregisterDescriptor(int aFileno)
```
    Deprecated.
  - getDescriptorByFileno
```
@Deprecated
public ChannelDescriptor getDescriptorByFileno(int aFileno)
```
    Deprecated.
  - getIn
```
public java.io.InputStream getIn()
```
  - getOut
```
public java.io.PrintStream getOut()
```
  - getErr
```
public java.io.PrintStream getErr()
```
  - isGlobalAbortOnExceptionEnabled
```
public boolean isGlobalAbortOnExceptionEnabled()
```
  - setGlobalAbortOnExceptionEnabled
```
public void setGlobalAbortOnExceptionEnabled(boolean enable)
```
  - isDoNotReverseLookupEnabled
```
public boolean isDoNotReverseLookupEnabled()
```
  - setDoNotReverseLookupEnabled
```
public void setDoNotReverseLookupEnabled(boolean b)
```
  - registerInspecting
```
public void registerInspecting(java.lang.Object obj)
```
  - isInspecting
```
public boolean isInspecting(java.lang.Object obj)
```
  - unregisterInspecting
```
public void unregisterInspecting(java.lang.Object obj)
```
  - recursiveListAccess
```
private IRubyObject recursiveListAccess()
```
  - recursiveListClear
```
private void recursiveListClear()
```
  - recursivePush
```
private void recursivePush(IRubyObject list,
                           IRubyObject obj,
                           IRubyObject paired_obj)
```
  - recursivePop
```
private void recursivePop(IRubyObject list,
                          IRubyObject obj,
                          IRubyObject paired_obj)
```
  - recursiveCheck
```
private boolean recursiveCheck(IRubyObject list,
                               IRubyObject obj_id,
                               IRubyObject paired_obj_id)
```
  - execRecursiveI
```
private IRubyObject execRecursiveI(Ruby.ExecRecursiveParams p)
```
  - execRecursiveInternal
```
private IRubyObject execRecursiveInternal(Ruby.RecursiveFunction func,
                                          IRubyObject obj,
                                          IRubyObject pairid,
                                          boolean outer)
```
  - execRecursive
```
public IRubyObject execRecursive(Ruby.RecursiveFunction func,
                                 IRubyObject obj)
```
    Perform a recursive walk on the given object using the given function. Do not call this method directly unless you know you're within a call to recursiveListOperation, which will ensure the thread-local recursion tracking data structs are cleared. MRI: rb_exec_recursive Calls func(obj, arg, recursive), where recursive is non-zero if the current method is called recursively on obj
    
    Parameters:
    
    func -
    
    obj -
    
    Returns:
  - execRecursiveOuter
```
public IRubyObject execRecursiveOuter(Ruby.RecursiveFunction func,
                                      IRubyObject obj)
```
    Perform a recursive walk on the given object using the given function. Treat this as the outermost call, cleaning up recursive structures. MRI: rb_exec_recursive_outer If recursion is detected on the current method and obj, the outermost func will be called with (obj, arg, Qtrue). All inner func will be short-circuited using throw.
    
    Parameters:
    
    func -
    
    obj -
    
    Returns:
  - recursiveListOperation
```
public <T extends IRubyObject> T recursiveListOperation(java.util.concurrent.Callable<T> body)
```
    Begin a recursive walk that may make one or more calls to execRecursive. Clean up recursive structures once complete.
    
    Type Parameters:
    
    T -
    
    Parameters:
    
    body -
    
    Returns:
  - isObjectSpaceEnabled
```
public boolean isObjectSpaceEnabled()
```
  - setObjectSpaceEnabled
```
public void setObjectSpaceEnabled(boolean objectSpaceEnabled)
```
  - isSiphashEnabled
```
public boolean isSiphashEnabled()
```
  - getStartTime
```
public long getStartTime()
```
  - getProfile
```
public Profile getProfile()
```
  - getJRubyHome
```
public java.lang.String getJRubyHome()
```
  - setJRubyHome
```
public void setJRubyHome(java.lang.String home)
```
  - getInstanceConfig
```
public RubyInstanceConfig getInstanceConfig()
```
  - is1_8
```
public boolean is1_8()
```
  - is1_9
```
public boolean is1_9()
```
  - is2_0
```
public boolean is2_0()
```
  - getGlobalState
```
public long getGlobalState()
```
    GET_VM_STATE_VERSION
  - incGlobalState
```
public void incGlobalState()
```
    INC_VM_STATE_VERSION
  - isSecurityRestricted
```
public static boolean isSecurityRestricted()
```
  - setSecurityRestricted
```
public static void setSecurityRestricted(boolean restricted)
```
  - getPosix
```
public jnr.posix.POSIX getPosix()
```
  - setRecordSeparatorVar
```
public void setRecordSeparatorVar(GlobalVariable recordSeparatorVar)
```
  - getRecordSeparatorVar
```
public GlobalVariable getRecordSeparatorVar()
```
  - getJittedMethods
```
public java.util.Set<Script> getJittedMethods()
```
  - getExecutor
```
public java.util.concurrent.ExecutorService getExecutor()
```
  - getFiberExecutor
```
public java.util.concurrent.ExecutorService getFiberExecutor()
```
  - getTimezoneCache
```
public java.util.Map<java.lang.String,org.joda.time.DateTimeZone> getTimezoneCache()
```
  - getConstantGeneration
```
@Deprecated
public int getConstantGeneration()
```
    Deprecated.
  - getConstantInvalidator
```
public Invalidator getConstantInvalidator(java.lang.String constantName)
```
  - addConstantInvalidator
```
private Invalidator addConstantInvalidator(java.lang.String constantName)
```
  - getCheckpointInvalidator
```
public Invalidator getCheckpointInvalidator()
```
  - loadConstantSet
```
public <E extends java.lang.Enum<E>> void loadConstantSet(RubyModule module,
                                                          java.lang.Class<E> enumClass)
```
  - loadConstantSet
```
public void loadConstantSet(RubyModule module,
                            java.lang.String constantSetName)
```
  - getNextDynamicMethodSerial
```
public long getNextDynamicMethodSerial()
```
    Get a new serial number for a new DynamicMethod instance
    
    Returns:
    
    a new serial number
  - getNextModuleGeneration
```
public int getNextModuleGeneration()
```
    Get a new generation number for a module or class.
    
    Returns:
    
    a new generation number
  - getHierarchyLock
```
public java.lang.Object getHierarchyLock()
```
    Get the global object used to synchronize class-hierarchy modifications like cache invalidation, subclass sets, and included hierarchy sets.
    
    Returns:
    
    The object to use for locking when modifying the hierarchy
  - getSelectorPool
```
public SelectorPool getSelectorPool()
```
    Get the runtime-global selector pool
    
    Returns:
    
    a SelectorPool from which to getService Selector instances
  - getRuntimeCache
```
public RuntimeCache getRuntimeCache()
```
    Get the core class RuntimeCache instance, for doing dynamic calls from core class methods.
  - getProfiledMethods
```
@Deprecated
public ProfiledMethods getProfiledMethods()
```
    Deprecated. This should be an implementation detail of the ProfilingService and should remove from the Ruby class.
    
    Get the list of method holders for methods being profiled.
    
    Returns:
    
    all known profiled methods
  - addProfiledMethod
```
@Deprecated
void addProfiledMethod(java.lang.String name,
                                   DynamicMethod method)
```
    Deprecated. This should be an implementation detail of the ProfilingService and should remove from the Ruby class.
    
    Add a method, so it can be printed out later.
    
    Parameters:
    
    name - the name of the method
    
    method -
  - incrementExceptionCount
```
public void incrementExceptionCount()
```
    Increment the count of exceptions generated by code in this runtime.
  - getExceptionCount
```
public int getExceptionCount()
```
    Get the current exception count.
    
    Returns:
    
    he current exception count
  - incrementBacktraceCount
```
public void incrementBacktraceCount()
```
    Increment the count of backtraces generated by code in this runtime.
  - getBacktraceCount
```
public int getBacktraceCount()
```
    Get the current backtrace count.
    
    Returns:
    
    the current backtrace count
  - incrementWarningCount
```
public void incrementWarningCount()
```
    Increment the count of backtraces generated for warnings in this runtime.
  - getWarningCount
```
public int getWarningCount()
```
    Get the current backtrace count.
    
    Returns:
    
    the current backtrace count
  - incrementCallerCount
```
public void incrementCallerCount()
```
    Increment the count of backtraces generated by code in this runtime.
  - getCallerCount
```
public int getCallerCount()
```
    Get the current backtrace count.
    
    Returns:
    
    the current backtrace count
  - reopenFixnum
```
public void reopenFixnum()
```
    Mark Fixnum as reopened
  - getFixnumInvalidator
```
public Invalidator getFixnumInvalidator()
```
    Retrieve the invalidator for Fixnum reopening
  - isFixnumReopened
```
public boolean isFixnumReopened()
```
    Whether the Float class has been reopened and modified
  - reopenFloat
```
public void reopenFloat()
```
    Mark Float as reopened
  - getFloatInvalidator
```
public Invalidator getFloatInvalidator()
```
    Retrieve the invalidator for Float reopening
  - isFloatReopened
```
public boolean isFloatReopened()
```
    Whether the Float class has been reopened and modified
  - isBooting
```
public boolean isBooting()
```
  - getCoverageData
```
public CoverageData getCoverageData()
```
  - getRandom
```
public java.util.Random getRandom()
```
  - getHashSeedK0
```
public long getHashSeedK0()
```
  - getHashSeedK1
```
public long getHashSeedK1()
```
  - getStaticScopeFactory
```
public StaticScopeFactory getStaticScopeFactory()
```
  - getFFI
```
public FFI getFFI()
```
  - setFFI
```
public void setFFI(FFI ffi)
```
  - getDefinedMessage
```
public RubyString getDefinedMessage(DefinedMessage definedMessage)
```
  - getThreadStatus
```
public RubyString getThreadStatus(RubyThread.Status status)
```
  - getRuntimeNumber
```
public int getRuntimeNumber()
```
  - setNetworkStack
```
private void setNetworkStack()
```
  - getSafeLevel
```
@Deprecated
public int getSafeLevel()
```
    Deprecated.
  - setSafeLevel
```
@Deprecated
public void setSafeLevel(int safeLevel)
```
    Deprecated.
  - checkSafeString
```
@Deprecated
public void checkSafeString(IRubyObject object)
```
    Deprecated.
  - secure
```
@Deprecated
public void secure(int level)
```
    Deprecated.
  - callbackFactory
```
@Deprecated
public CallbackFactory callbackFactory(java.lang.Class<?> type)
```
    Deprecated.
  - addToObjectSpace
```
public void addToObjectSpace(boolean useObjectSpace,
                             IRubyObject object)
```

Class Ruby

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

NIL_PREFILLED_ARRAY_SIZE

nilPrefilledArray

errnos

defaultRand

charsetMap

EVENTS2_0

callTraceFuncHook

ADDR_NOT_AVAIL_PATTERN

filenoExtIntMap

filenoIntExtMap

inspect

constantNameInvalidators

checkpointInvalidator

threadService

posix

objectSpace

symbolTable

EMPTY_HOOKS

eventHooks

hasEventHooks

globalAbortOnExceptionEnabled

doNotReverseLookupEnabled

objectSpaceEnabled

siphashEnabled

jittedMethods

globalState

topSelf

rootFiber

nilObject

singleNilArray

trueObject

falseObject

fixnumCache

verbose

warningsEnabled

debug

verboseValue

defaultThreadGroup

basicObjectClass

objectClass

moduleClass

classClass

nilClass

trueClass

falseClass

numericClass

floatClass

integerClass

fixnumClass

complexClass

rationalClass

enumeratorClass

yielderClass

arrayClass

hashClass

rangeClass

stringClass

encodingClass

converterClass

symbolClass

procClass

bindingClass

methodClass

unboundMethodClass

matchDataClass

regexpClass

timeClass

bignumClass

dirClass

fileClass

fileStatClass

ioClass