Ruby (JRuby Core 9.0.5.0 API)

java.lang.Object
- org.jruby.Ruby

All Implemented Interfaces:

Constantizable
```
public final class Ruby
extends Object
implements Constantizable
```
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

static interface Ruby.ObjectSpacer

static interface Ruby.RecursiveFunction

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

Field Summary

Fields
Modifier and Type Field and Description

static String ERRNO_BACKTRACE_MESSAGE

static int NIL_PREFILLED_ARRAY_SIZE

static String STOPIERATION_BACKTRACE_MESSAGE

Fields
Modifier and Type	Field and Description
`static String`	`ERRNO_BACKTRACE_MESSAGE`
`static int`	`NIL_PREFILLED_ARRAY_SIZE`
`static String`	`STOPIERATION_BACKTRACE_MESSAGE`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addBoundMethod(String className, String methodName, String rubyName)`
`void`	`addEventHook(EventHook hook)`
`void`	`addFinalizer(Finalizable finalizer)`
`void`	`addInternalFinalizer(Finalizable finalizer)`
`void`	`addModule(RubyModule module)`
`void`	`addToObjectSpace(boolean useObjectSpace, IRubyObject object)`
`int`	`allocModuleId()`
`int`	`allocSymbolId()`
`void`	`callEventHooks(ThreadContext context, RubyEvent event, String file, int line, String name, IRubyObject type)`
`void`	`checkSafeString(IRubyObject object)` Deprecated.
`static void`	`clearGlobalRuntime()` Clear the global runtime.
`void`	`compileAndLoadFile(String filename, InputStream in, boolean wrap)`
`Object`	`constant()`
`RubyClass`	`defineClass(String name, RubyClass superClass, ObjectAllocator allocator)` Define a new class under the Object namespace.
`RubyClass`	`defineClass(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.
`RubyClass`	`defineClassUnder(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(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(String name, IRubyObject value)` rb_define_global_const Define a constant on the global namespace (i.e.
`RubyModule`	`defineModule(String name)` Define a new module under the Object namespace.
`RubyModule`	`defineModuleUnder(String name, RubyModule parent)` Define a new module with the given name under the given module or class namespace.
`void`	`defineReadonlyVariable(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<Object,IRubyObject> func)`
`IRubyObject`	`evalScriptlet(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(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.
`IRubyObject`	`execRecursiveOuter(Ruby.RecursiveFunction func, IRubyObject obj)` Perform a recursive walk on the given object using the given function.
`IRubyObject`	`executeScript(String script, 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.
`RubyClass`	`fastGetClass(String internedName)` Deprecated.
`RubyModule`	`fastGetModule(String internedName)` Deprecated.
`RubySymbol`	`fastNewSymbol(String internedName)` Faster than `newSymbol(String)` if you already have an interned name String.
`IRubyObject`	`fetchGlobalConstant(String name)` Fetch a constant from the global namespace (i.e.
`RubyString`	`freezeAndDedupString(RubyString string)` Given a Ruby string, cache a frozen, duplicated copy of it, or find an existing copy already prepared.
`IRubyObject`	`getArgsFile()`
`RubyClass`	`getArgumentError()`
`RubyClass`	`getArray()`
`int`	`getBacktraceCount()` Get the current backtrace count.
`RubyClass`	`getBasicObject()`
`BeanManager`	`getBeanManager()`
`RubyClass`	`getBignum()`
`RubyClass`	`getBinding()`
`Map<String,Map<String,String>>`	`getBoundMethods()`
`int`	`getCallerCount()` Get the current backtrace count.
`RubyHash`	`getCharsetMap()`
`Invalidator`	`getCheckpointInvalidator()`
`RubyClass`	`getClass(String name)` Retrieve the class with the given name from the Object namespace.
`RubyClass`	`getClassClass()`
`RubyModule`	`getClassFromPath(String path)`
`static ClassLoader`	`getClassLoader()`
`RubyModule`	`getComparable()`
`RubyClass`	`getComplex()`
`RubyClass`	`getConcurrencyError()`
`int`	`getConstantGeneration()` Deprecated.
`Invalidator`	`getConstantInvalidator(String constantName)`
`RubyClass`	`getContinuation()`
`RubyClass`	`getConverter()`
`RubyClass`	`getConverterNotFoundError()`
`CoverageData`	`getCoverageData()`
`ThreadContext`	`getCurrentContext()`
`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)`
`RubyClass`	`getDir()`
`RubyClass`	`getDummy()`
`RubyArray`	`getEmptyFrozenArray()`
`RubyClass`	`getEncoding()`
`RubyClass`	`getEncodingCompatibilityError()`
`RubyClass`	`getEncodingError()`
`EncodingService`	`getEncodingService()`
`RubyModule`	`getEnumerable()`
`RubyClass`	`getEnumerator()`
`RubyHash`	`getENV()`
`RubyClass`	`getEOFError()`
`PrintStream`	`getErr()`
`RubyModule`	`getErrno()`
`RubyClass`	`getErrno(int n)`
`PrintStream`	`getErrorStream()`
`RubyModule`	`getEtc()`
`RubyClass`	`getException()`
`int`	`getExceptionCount()` Get the current exception count.
`ExecutorService`	`getExecutor()`
`RubyBoolean`	`getFalse()` Returns the "false" instance from the instance pool.
`RubyClass`	`getFalseClass()`
`RubyClass`	`getFatal()`
`FFI`	`getFFI()`
`RubyClass`	`getFiber()`
`RubyClass`	`getFiberError()`
`ExecutorService`	`getFiberExecutor()`
`RubyClass`	`getFile()`
`FilenoUtil`	`getFilenoUtil()`
`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()`
`RubyClass`	`getGenerator()`
`static Ruby`	`getGlobalRuntime()` Get the global runtime.
`long`	`getGlobalState()` GET_VM_STATE_VERSION
`GlobalVariables`	`getGlobalVariables()`
`IRubyObject`	`getGroupStruct()`
`RubyClass`	`getHash()`
`long`	`getHashSeedK0()`
`long`	`getHashSeedK1()`
`Object`	`getHierarchyLock()` Get the global object used to synchronize class-hierarchy modifications like cache invalidation, subclass sets, and included hierarchy sets.
`InputStream`	`getIn()`
`RubyClass`	`getIndexError()`
`InputStream`	`getInputStream()`
`RubyInstanceConfig`	`getInstanceConfig()`
`RubyClass`	`getInteger()`
`RubyClass`	`getInterrupt()`
`RubyClass`	`getInterruptedRegexpError()`
`RubyClass`	`getInvalidByteSequenceError()`
`RubyClass`	`getIO()`
`RubyClass`	`getIOError()`
`IRManager`	`getIRManager()`
`JavaProxyClassFactory`	`getJavaProxyClassFactory()`
`JavaSupport`	`getJavaSupport()`
`JITCompiler`	`getJITCompiler()`
`JRubyClassLoader`	`getJRubyClassLoader()` TODO the property `jrubyClassLoader` will only be set in constructor.
`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(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(String name)` From Object, retrieve the named module.
`PrintStream`	`getOut()`
`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()`
`DynamicMethod`	`getProtectedMethodMissing()`
`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()`
`Map<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()`
`JRubyTruffleInterface`	`getTruffleContext()`
`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()`
`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.
`boolean`	`is1_8()` Deprecated.
`boolean`	`is1_9()` Deprecated.
`boolean`	`is2_0()`
`boolean`	`isBooting()`
`boolean`	`isBootingCore()`
`boolean`	`isClassDefined(String name)`
`boolean`	`isDebug()`
`boolean`	`isDefaultMethodMissing(DynamicMethod method)`
`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(Object obj)`
`boolean`	`isObjectSpaceEnabled()`
`static boolean`	`isSecurityRestricted()`
`boolean`	`isSiphashEnabled()`
`boolean`	`isVerbose()`
`<E extends Enum<E>> void`	`loadConstantSet(RubyModule module, Class<E> enumClass)`
`void`	`loadConstantSet(RubyModule module, String constantSetName)`
`void`	`loadExtension(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(String scriptName, InputStream in, boolean wrap)`
`JavaSupport`	`loadJavaSupport()`
`void`	`loadScope(IRScope scope, boolean wrap)`
`void`	`loadScript(Script script)`
`void`	`loadScript(Script script, boolean wrap)`
`RaiseException`	`newArgumentError(int got, int expected)`
`RaiseException`	`newArgumentError(String message)`
`RaiseException`	`newArgumentError(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(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(String message)`
`RaiseException`	`newConverterNotFoundError(String message)`
`RubyObject.Data`	`newData(RubyClass objectClass, Object sval)`
`RubyArray`	`newEmptyArray()`
`RaiseException`	`newEncodingCompatibilityError(String message)`
`RaiseException`	`newEncodingError(String message)`
`RaiseException`	`newEOFError()`
`RaiseException`	`newEOFError(String message)`
`RaiseException`	`newErrnoEACCESError(String message)`
`RaiseException`	`newErrnoEADDRFromBindException(BindException be)`
`RaiseException`	`newErrnoEADDRFromBindException(BindException be, String contextMessage)`
`RaiseException`	`newErrnoEADDRINUSEError()`
`RaiseException`	`newErrnoEADDRINUSEError(String message)`
`RaiseException`	`newErrnoEADDRNOTAVAILError(String message)`
`RaiseException`	`newErrnoEAGAINError(String message)`
`RaiseException`	`newErrnoEAGAINReadableError(String message)`
`RaiseException`	`newErrnoEAGAINWritableError(String message)`
`RaiseException`	`newErrnoEBADFError()`
`RaiseException`	`newErrnoEBADFError(String message)`
`RaiseException`	`newErrnoECHILDError()`
`RaiseException`	`newErrnoECONNABORTEDError()`
`RaiseException`	`newErrnoECONNREFUSEDError()`
`RaiseException`	`newErrnoECONNREFUSEDError(String message)`
`RaiseException`	`newErrnoECONNRESETError()`
`RaiseException`	`newErrnoEDESTADDRREQError(String func)`
`RaiseException`	`newErrnoEDOMError(String message)`
`RaiseException`	`newErrnoEEXISTError(String message)`
`RaiseException`	`newErrnoEHOSTUNREACHError(String message)`
`RaiseException`	`newErrnoEINPROGRESSError()`
`RaiseException`	`newErrnoEINPROGRESSError(String message)`
`RaiseException`	`newErrnoEINPROGRESSWritableError()`
`RaiseException`	`newErrnoEINPROGRESSWritableError(String message)`
`RaiseException`	`newErrnoEINTRError()`
`RaiseException`	`newErrnoEINVALError()`
`RaiseException`	`newErrnoEINVALError(String message)`
`RaiseException`	`newErrnoEISCONNError()`
`RaiseException`	`newErrnoEISCONNError(String message)`
`RaiseException`	`newErrnoEISDirError()`
`RaiseException`	`newErrnoEISDirError(String message)`
`RaiseException`	`newErrnoELOOPError()`
`RaiseException`	`newErrnoEMFILEError()`
`RaiseException`	`newErrnoENETUNREACHError()`
`RaiseException`	`newErrnoENFILEError()`
`RaiseException`	`newErrnoENOENTError()`
`RaiseException`	`newErrnoENOENTError(String message)`
`RaiseException`	`newErrnoENOPROTOOPTError()`
`RaiseException`	`newErrnoENOTCONNError()`
`RaiseException`	`newErrnoENOTCONNError(String message)`
`RaiseException`	`newErrnoENOTDIRError(String message)`
`RaiseException`	`newErrnoENOTEMPTYError(String message)`
`RaiseException`	`newErrnoENOTSOCKError(String message)`
`RaiseException`	`newErrnoEOPNOTSUPPError(String message)`
`RaiseException`	`newErrnoEPERMError(String name)`
`RaiseException`	`newErrnoEPIPEError()`
`RaiseException`	`newErrnoESPIPEError()`
`RaiseException`	`newErrnoESPIPEError(String message)`
`RaiseException`	`newErrnoESRCHError()`
`RaiseException`	`newErrnoEWOULDBLOCKError()`
`RaiseException`	`newErrnoFromErrno(jnr.constants.platform.Errno errno, String message)`
`RaiseException`	`newErrnoFromInt(int errno)`
`RaiseException`	`newErrnoFromInt(int errno, String message)`
`RaiseException`	`newErrnoFromInt(int errno, String methodName, String message)`
`RaiseException`	`newErrnoFromLastPOSIXErrno()`
`RaiseException`	`newFiberError(String message)`
`RubyFileStat`	`newFileStat(FileDescriptor descriptor)`
`RubyFileStat`	`newFileStat(String filename, boolean lstat)`
`RubyFixnum`	`newFixnum(jnr.constants.Constant value)`
`RubyFixnum`	`newFixnum(int value)`
`RubyFixnum`	`newFixnum(long value)`
`RubyFloat`	`newFloat(double value)`
`RaiseException`	`newFloatDomainError(String message)`
`RaiseException`	`newFrozenError(String objectType)`
`RaiseException`	`newFrozenError(String objectType, boolean runtimeError)`
`RaiseException`	`newIllegalSequence(String message)`
`RaiseException`	`newIndexError(String message)`
`static Ruby`	`newInstance()` Returns a new instance of the JRuby runtime configured with defaults.
`static Ruby`	`newInstance(InputStream in, PrintStream out, 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(String message)`
`RaiseException`	`newInvalidByteSequenceError(String message)`
`RaiseException`	`newInvalidEncoding(String message)`
`RaiseException`	`newIOError(String message)`
`RaiseException`	`newIOErrorFromException(IOException ex)` Java does not give us enough information for specific error conditions so we are reduced to divining them through string matches...
`RaiseException`	`newKeyError(String message)`
`RaiseException`	`newLightweightStopIterationError(String message)` Deprecated.
`RaiseException`	`newLoadError(String message)`
`RaiseException`	`newLoadError(String message, String path)`
`RaiseException`	`newLocalJumpError(RubyLocalJumpError.Reason reason, IRubyObject exitValue, String message)`
`RaiseException`	`newLocalJumpErrorNoBlock()`
`RaiseException`	`newMathDomainError(String message)`
`RaiseException`	`newNameError(String message, String name)`
`RaiseException`	`newNameError(String message, String name, Throwable origException)`
`RaiseException`	`newNameError(String message, String name, Throwable origException, boolean printWhenVerbose)`
`RaiseException`	`newNameErrorObject(String message, IRubyObject name)`
`RaiseException`	`newNoMethodError(String message, String name, IRubyObject args)`
`RaiseException`	`newNotImplementedError(String message)`
`RubyNumeric`	`newNumeric()`
`RubyProc`	`newProc(Block.Type type, Block block)`
`RaiseException`	`newRaiseException(RubyClass exceptionClass, String message)`
`RaiseException`	`newRangeError(String message)`
`RubyRational`	`newRational(long num, long den)`
`RubyRational`	`newRationalReduced(long num, long den)`
`RaiseException`	`newRedoLocalJumpError()`
`RaiseException`	`newRegexpError(String message)`
`RaiseException`	`newRuntimeError(String message)`
`RaiseException`	`newSecurityError(String message)`
`RaiseException`	`newStandardError(String message)`
`RaiseException`	`newStopIteration(IRubyObject result, String message)` Generate a StopIteration exception.
`RubyString`	`newString()`
`RubyString`	`newString(org.jruby.util.ByteList byteList)`
`RubyString`	`newString(String string)`
`RubyString`	`newStringShared(org.jruby.util.ByteList byteList)` Deprecated.
`RubySymbol`	`newSymbol(org.jruby.util.ByteList name)`
`RubySymbol`	`newSymbol(String name)`
`RubySymbol`	`newSymbol(String name, org.jcodings.Encoding encoding)`
`RaiseException`	`newSyntaxError(String message)`
`RaiseException`	`newSystemCallError(String message)`
`RaiseException`	`newSystemExit(int status)`
`RaiseException`	`newSystemExit(int status, String message)`
`RaiseException`	`newSystemStackError(String message)`
`RaiseException`	`newSystemStackError(String message, StackOverflowError soe)`
`RaiseException`	`newThreadError(String message)`
`RubyTime`	`newTime(long milliseconds)`
`RaiseException`	`newTypeError(IRubyObject receivedObject, RubyClass expectedType)`
`RaiseException`	`newTypeError(IRubyObject receivedObject, RubyModule expectedType)`
`RaiseException`	`newTypeError(IRubyObject receivedObject, String expectedType)`
`RaiseException`	`newTypeError(String message)`
`RaiseException`	`newUndefinedConversionError(String message)`
`RaiseException`	`newZeroDivisionError()`
`Node`	`parse(org.jruby.util.ByteList content, String file, DynamicScope scope, int lineNumber, boolean extraPositionInformation)`
`Node`	`parse(String content, String file, DynamicScope scope, int lineNumber, boolean extraPositionInformation)` Deprecated.
`Node`	`parseEval(org.jruby.util.ByteList content, String file, DynamicScope scope, int lineNumber)`
`Node`	`parseEval(String content, String file, DynamicScope scope, int lineNumber)`
`Node`	`parseFile(InputStream in, String file, DynamicScope scope)`
`Node`	`parseFile(InputStream in, String file, DynamicScope scope, int lineNumber)`
`ParseResult`	`parseFile(String file, InputStream in, DynamicScope scope)`
`ParseResult`	`parseFile(String file, InputStream in, DynamicScope scope, int lineNumber)`
`Node`	`parseFileFromMain(InputStream in, String file, DynamicScope scope)`
`ParseResult`	`parseFileFromMain(String file, InputStream in, DynamicScope scope)`
`Node`	`parseFromMain(InputStream inputStream, 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.
`ParseResult`	`parseFromMain(String fileName, InputStream in)`
`Node`	`parseInline(InputStream in, 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.
`<T extends IRubyObject> T`	`recursiveListOperation(Callable<T> body)` Begin a recursive walk that may make one or more calls to `execRecursive`.
`void`	`registerInspecting(Object obj)`
`void`	`registerMBeans()`
`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`	`removeFinalizer(Finalizable finalizer)`
`void`	`removeInternalFinalizer(Finalizable finalizer)`
`void`	`reopenFixnum()` Mark Fixnum as reopened
`void`	`reopenFloat()` Mark Float as reopened
`void`	`runFromMain(InputStream inputStream, 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(ParseResult parseResult)`
`IRubyObject`	`runInterpreter(ThreadContext context, Node rootNode, IRubyObject self)`
`IRubyObject`	`runInterpreter(ThreadContext context, ParseResult parseResult, 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, boolean unused)` Deprecated.
`IRubyObject`	`runWithGetsLoop(RootNode scriptNode, boolean printing, boolean processLineEnds, boolean split)` Run the given script with a "while gets; end" loop wrapped around it.
`void`	`secure(int level)` Deprecated.
`void`	`setArgsFile(IRubyObject argsFile)`
`void`	`setCurrentDirectory(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, DynamicMethod moduleMethod)`
`void`	`setDefaultRand(RubyRandom.RandomType defaultRand)`
`void`	`setDoNotReverseLookupEnabled(boolean b)`
`void`	`setENV(RubyHash env)`
`void`	`setEtc(RubyModule etcModule)`
`void`	`setFFI(FFI ffi)`
`void`	`setFiber(RubyClass fiberClass)`
`void`	`setGenerator(RubyClass generatorClass)`
`void`	`setGlobalAbortOnExceptionEnabled(boolean enable)`
`void`	`setGlobalVariables(GlobalVariables globalVariables)`
`void`	`setGroupStruct(RubyClass groupStruct)`
`void`	`setJavaProxyClassFactory(JavaProxyClassFactory factory)`
`void`	`setJRubyHome(String home)`
`void`	`setKCode(KCode kcode)`
`void`	`setLocation(RubyClass location)`
`void`	`setNormalMethodMissing(DynamicMethod method)`
`void`	`setObjectSpaceEnabled(boolean objectSpaceEnabled)`
`void`	`setPasswdStruct(RubyClass passwdStruct)`
`void`	`setPrivateMethodMissing(DynamicMethod method)`
`void`	`setProtectedMethodMissing(DynamicMethod method)`
`void`	`setRecordSeparatorVar(GlobalVariable recordSeparatorVar)`
`void`	`setRespondToMethod(DynamicMethod rtm)`
`void`	`setRespondToMissingMethod(DynamicMethod rtmm)`
`void`	`setRootFiber(IRubyObject fiber)`
`void`	`setSafeLevel(int safeLevel)` Deprecated.
`static void`	`setSecurityRestricted(boolean restricted)`
`void`	`setSuperMethodMissing(DynamicMethod method)`
`static void`	`setThreadLocalRuntime(Ruby ruby)` Set the thread-local runtime to the given runtime.
`void`	`setTraceFunction(RubyProc traceFunction)`
`void`	`setVariableMethodMissing(DynamicMethod method)`
`void`	`setVerbose(IRubyObject verbose)` Setter for property isVerbose.
`void`	`shutdownTruffleContextIfRunning()`
`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.
`void`	`unregisterInspecting(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
- NIL_PREFILLED_ARRAY_SIZE
```
public static final int NIL_PREFILLED_ARRAY_SIZE
```
  See Also:
  Constant Field Values
- ERRNO_BACKTRACE_MESSAGE
```
public static final String ERRNO_BACKTRACE_MESSAGE
```
  See Also:
  Constant Field Values
- STOPIERATION_BACKTRACE_MESSAGE
```
public static final String STOPIERATION_BACKTRACE_MESSAGE
```
  See Also:
  Constant Field Values

Method Detail

registerMBeans
```
public void registerMBeans()
```

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(InputStream in,
               PrintStream out,
               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.

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(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(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(String script,
                        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(InputStream inputStream,
               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(InputStream inputStream,
                 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

parseFromMain

public ParseResult parseFromMain(String fileName,
                        InputStream in)

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(RootNode 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.

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,
                         ParseResult parseResult,
                         IRubyObject self)

runInterpreter

public IRubyObject runInterpreter(ThreadContext context,
                         Node rootNode,
                         IRubyObject self)

runInterpreter

public IRubyObject runInterpreter(Node scriptNode)

runInterpreter

public IRubyObject runInterpreter(ParseResult parseResult)

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()
```

getTruffleContext

public JRubyTruffleInterface getTruffleContext()

shutdownTruffleContextIfRunning

public void shutdownTruffleContextIfRunning()

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<Object,IRubyObject> func)

getModule
```
public RubyModule getModule(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(String internedName)

Deprecated.

getClass
```
public RubyClass getClass(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(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(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(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(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(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(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(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(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(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(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(String name)

loadJavaSupport
```
public JavaSupport loadJavaSupport()
```

getNilPrefilledArray

public IRubyObject[] getNilPrefilledArray()

getErrno
```
public RubyClass getErrno(int n)
```

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(String dir)

getCurrentDirectory
```
public 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()
```

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()

isDefaultMethodMissing

public boolean isDefaultMethodMissing(DynamicMethod method)

setDefaultMethodMissing

public void setDefaultMethodMissing(DynamicMethod method,
                           DynamicMethod moduleMethod)

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()
```

getNumeric
```
public RubyClass getNumeric()
```

getFloat
```
public RubyClass getFloat()
```

getInteger
```
public RubyClass getInteger()
```

getFixnum
```
public RubyClass getFixnum()
```

getComplex
```
public RubyClass getComplex()
```

getRational
```
public RubyClass getRational()
```

getEnumerable
```
public RubyModule getEnumerable()
```

getEnumerator
```
public RubyClass getEnumerator()
```

getYielder
```
public RubyClass getYielder()
```

getGenerator
```
public RubyClass getGenerator()
```

setGenerator

public void setGenerator(RubyClass generatorClass)

getFiber
```
public RubyClass getFiber()
```

setFiber

public void setFiber(RubyClass fiberClass)

getString
```
public RubyClass getString()
```

getEncoding
```
public RubyClass getEncoding()
```

getConverter
```
public RubyClass getConverter()
```

getSymbol
```
public RubyClass getSymbol()
```

getArray
```
public RubyClass getArray()
```

getHash
```
public RubyClass getHash()
```

getRange
```
public RubyClass getRange()
```

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()
```

getTrueClass
```
public RubyClass getTrueClass()
```

getFalseClass
```
public RubyClass getFalseClass()
```

getProc
```
public RubyClass getProc()
```

getBinding
```
public RubyClass getBinding()
```

getMethod
```
public RubyClass getMethod()
```

getUnboundMethod
```
public RubyClass getUnboundMethod()
```

getMatchData
```
public RubyClass getMatchData()
```

getRegexp
```
public RubyClass getRegexp()
```

getTime
```
public RubyClass getTime()
```

getMath
```
public RubyModule getMath()
```

getMarshal
```
public RubyModule getMarshal()
```

getBignum
```
public RubyClass getBignum()
```

getDir
```
public RubyClass getDir()
```

getFile
```
public RubyClass getFile()
```

getFileStat
```
public RubyClass getFileStat()
```

getFileTest
```
public RubyModule getFileTest()
```

getIO
```
public RubyClass getIO()
```

getThread
```
public RubyClass getThread()
```

getThreadGroup
```
public RubyClass getThreadGroup()
```

getDefaultThreadGroup

public RubyThreadGroup getDefaultThreadGroup()

getContinuation
```
public RubyClass getContinuation()
```

getStructClass
```
public RubyClass getStructClass()
```

getRandomClass
```
public RubyClass getRandomClass()
```

getTmsStruct
```
public IRubyObject getTmsStruct()
```

getPasswdStruct
```
public IRubyObject getPasswdStruct()
```

setPasswdStruct

public void setPasswdStruct(RubyClass passwdStruct)

getGroupStruct
```
public IRubyObject getGroupStruct()
```

setGroupStruct

public void setGroupStruct(RubyClass groupStruct)

getGC
```
public RubyModule getGC()
```

getObjectSpaceModule

public RubyModule getObjectSpaceModule()

getProcess
```
public RubyModule getProcess()
```

getProcStatus
```
public RubyClass getProcStatus()
```

getProcUID
```
public RubyModule getProcUID()
```

getProcGID
```
public RubyModule getProcGID()
```

getProcSysModule
```
public RubyModule getProcSysModule()
```

getPrecision
```
public RubyModule getPrecision()
```

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()
```

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 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(String name,
                          IRubyObject value,
                          GlobalVariable.Scope scope)

defines a readonly global variable

parseFile

public Node parseFile(InputStream in,
             String file,
             DynamicScope scope)

parseFile

public ParseResult parseFile(String file,
                    InputStream in,
                    DynamicScope scope)

parseFile

public Node parseFile(InputStream in,
             String file,
             DynamicScope scope,
             int lineNumber)

parseFile

public ParseResult parseFile(String file,
                    InputStream in,
                    DynamicScope scope,
                    int lineNumber)

parseFileFromMain

public Node parseFileFromMain(InputStream in,
                     String file,
                     DynamicScope scope)

parseFileFromMain

public ParseResult parseFileFromMain(String file,
                            InputStream in,
                            DynamicScope scope)

parseInline

public Node parseInline(InputStream in,
               String file,
               DynamicScope scope)

parseEval

public Node parseEval(String content,
             String file,
             DynamicScope scope,
             int lineNumber)

parse

@Deprecated
public Node parse(String content,
                    String file,
                    DynamicScope scope,
                    int lineNumber,
                    boolean extraPositionInformation)

Deprecated.

parseEval

public Node parseEval(org.jruby.util.ByteList content,
             String file,
             DynamicScope scope,
             int lineNumber)

parse

public Node parse(org.jruby.util.ByteList content,
         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 PrintStream getErrorStream()
```

getInputStream
```
public InputStream getInputStream()
```

getOutputStream
```
public PrintStream getOutputStream()
```

getClassFromPath

public RubyModule getClassFromPath(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(String scriptName,
            InputStream in,
            boolean wrap)

loadScope

public void loadScope(IRScope scope,
             boolean wrap)

compileAndLoadFile

public void compileAndLoadFile(String filename,
                      InputStream in,
                      boolean wrap)

loadScript

public void loadScript(Script script)

loadScript

public void loadScript(Script script,
              boolean wrap)

loadExtension
```
public void loadExtension(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(String className,
                  String methodName,
                  String rubyName)

getBoundMethods

public Map<String,Map<String,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,
                  String file,
                  int line,
                  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 -

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(List<IRubyObject> list)

newArray
```
public RubyArray newArray(int size)
```

getEmptyFrozenArray

public RubyArray getEmptyFrozenArray()

newBoolean

public RubyBoolean newBoolean(boolean value)

newFileStat

public RubyFileStat newFileStat(String filename,
                       boolean lstat)

newFileStat

public RubyFileStat newFileStat(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(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(String name)

newSymbol

public RubySymbol newSymbol(String name,
                   org.jcodings.Encoding encoding)

newSymbol

public RubySymbol newSymbol(org.jruby.util.ByteList name)

fastNewSymbol
```
public RubySymbol fastNewSymbol(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(String message)

newArgumentError

public RaiseException newArgumentError(String message)

newArgumentError

public RaiseException newArgumentError(int got,
                              int expected)

newArgumentError

public RaiseException newArgumentError(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()

newErrnoECONNREFUSEDError

public RaiseException newErrnoECONNREFUSEDError(String message)

newErrnoECONNRESETError

public RaiseException newErrnoECONNRESETError()

newErrnoEADDRINUSEError

public RaiseException newErrnoEADDRINUSEError()

newErrnoEADDRINUSEError

public RaiseException newErrnoEADDRINUSEError(String message)

newErrnoEHOSTUNREACHError

public RaiseException newErrnoEHOSTUNREACHError(String message)

newErrnoEINVALError

public RaiseException newErrnoEINVALError()

newErrnoELOOPError

public RaiseException newErrnoELOOPError()

newErrnoEMFILEError

public RaiseException newErrnoEMFILEError()

newErrnoENFILEError

public RaiseException newErrnoENFILEError()

newErrnoENOENTError

public RaiseException newErrnoENOENTError()

newErrnoEACCESError

public RaiseException newErrnoEACCESError(String message)

newErrnoEAGAINError

public RaiseException newErrnoEAGAINError(String message)

newErrnoEAGAINReadableError

public RaiseException newErrnoEAGAINReadableError(String message)

newErrnoEAGAINWritableError

public RaiseException newErrnoEAGAINWritableError(String message)

newErrnoEISDirError

public RaiseException newErrnoEISDirError(String message)

newErrnoEPERMError

public RaiseException newErrnoEPERMError(String name)

newErrnoEISDirError

public RaiseException newErrnoEISDirError()

newErrnoESPIPEError

public RaiseException newErrnoESPIPEError()

newErrnoEBADFError

public RaiseException newErrnoEBADFError(String message)

newErrnoEINPROGRESSError

public RaiseException newErrnoEINPROGRESSError(String message)

newErrnoEINPROGRESSWritableError

public RaiseException newErrnoEINPROGRESSWritableError(String message)

newErrnoEISCONNError

public RaiseException newErrnoEISCONNError(String message)

newErrnoEINVALError

public RaiseException newErrnoEINVALError(String message)

newErrnoENOTDIRError

public RaiseException newErrnoENOTDIRError(String message)

newErrnoENOTEMPTYError

public RaiseException newErrnoENOTEMPTYError(String message)

newErrnoENOTSOCKError

public RaiseException newErrnoENOTSOCKError(String message)

newErrnoENOTCONNError

public RaiseException newErrnoENOTCONNError(String message)

newErrnoENOTCONNError

public RaiseException newErrnoENOTCONNError()

newErrnoENOENTError

public RaiseException newErrnoENOENTError(String message)

newErrnoEOPNOTSUPPError

public RaiseException newErrnoEOPNOTSUPPError(String message)

newErrnoESPIPEError

public RaiseException newErrnoESPIPEError(String message)

newErrnoEEXISTError

public RaiseException newErrnoEEXISTError(String message)

newErrnoEDOMError

public RaiseException newErrnoEDOMError(String message)

newErrnoECHILDError

public RaiseException newErrnoECHILDError()

newErrnoEADDRNOTAVAILError

public RaiseException newErrnoEADDRNOTAVAILError(String message)

newErrnoESRCHError

public RaiseException newErrnoESRCHError()

newErrnoEWOULDBLOCKError

public RaiseException newErrnoEWOULDBLOCKError()

newErrnoEDESTADDRREQError

public RaiseException newErrnoEDESTADDRREQError(String func)

newErrnoENETUNREACHError

public RaiseException newErrnoENETUNREACHError()

newIndexError

public RaiseException newIndexError(String message)

newSecurityError

public RaiseException newSecurityError(String message)

newSystemCallError

public RaiseException newSystemCallError(String message)

newKeyError

public RaiseException newKeyError(String message)

newErrnoEINTRError

public RaiseException newErrnoEINTRError()

newErrnoFromLastPOSIXErrno

public RaiseException newErrnoFromLastPOSIXErrno()

newErrnoFromInt

public RaiseException newErrnoFromInt(int errno,
                             String methodName,
                             String message)

newErrnoFromInt

public RaiseException newErrnoFromInt(int errno,
                             String message)

newErrnoFromErrno

public RaiseException newErrnoFromErrno(jnr.constants.platform.Errno errno,
                               String message)

newErrnoFromInt

public RaiseException newErrnoFromInt(int errno)

newErrnoEADDRFromBindException

public RaiseException newErrnoEADDRFromBindException(BindException be)

newErrnoEADDRFromBindException

public RaiseException newErrnoEADDRFromBindException(BindException be,
                                            String contextMessage)

newTypeError

public RaiseException newTypeError(String message)

newThreadError

public RaiseException newThreadError(String message)

newConcurrencyError

public RaiseException newConcurrencyError(String message)

newSyntaxError

public RaiseException newSyntaxError(String message)

newRegexpError

public RaiseException newRegexpError(String message)

newInterruptedRegexpError

public RaiseException newInterruptedRegexpError(String message)

newRangeError

public RaiseException newRangeError(String message)

newNotImplementedError

public RaiseException newNotImplementedError(String message)

newInvalidEncoding

public RaiseException newInvalidEncoding(String message)

newIllegalSequence

public RaiseException newIllegalSequence(String message)

newNoMethodError

public RaiseException newNoMethodError(String message,
                              String name,
                              IRubyObject args)

newNameError

public RaiseException newNameError(String message,
                          String name)

newNameErrorObject

public RaiseException newNameErrorObject(String message,
                                IRubyObject name)

newNameError

public RaiseException newNameError(String message,
                          String name,
                          Throwable origException)

newNameError

public RaiseException newNameError(String message,
                          String name,
                          Throwable origException,
                          boolean printWhenVerbose)

newLocalJumpError

public RaiseException newLocalJumpError(RubyLocalJumpError.Reason reason,
                               IRubyObject exitValue,
                               String message)

newLocalJumpErrorNoBlock

public RaiseException newLocalJumpErrorNoBlock()

newRedoLocalJumpError

public RaiseException newRedoLocalJumpError()

newLoadError

public RaiseException newLoadError(String message)

newLoadError

public RaiseException newLoadError(String message,
                          String path)

newFrozenError

public RaiseException newFrozenError(String objectType)

newFrozenError

public RaiseException newFrozenError(String objectType,
                            boolean runtimeError)

newSystemStackError

public RaiseException newSystemStackError(String message)

newSystemStackError

public RaiseException newSystemStackError(String message,
                                 StackOverflowError soe)

newSystemExit

public RaiseException newSystemExit(int status)

newSystemExit

public RaiseException newSystemExit(int status,
                           String message)

newIOError

public RaiseException newIOError(String message)

newStandardError

public RaiseException newStandardError(String message)

newIOErrorFromException
```
public RaiseException newIOErrorFromException(IOException ex)
```
Java does not give us enough information for specific error conditions so we are reduced to divining them through string matches... TODO: Should ECONNABORTED get thrown earlier in the descriptor itself or is it ok to handle this late? TODO: Should we include this into Errno code somewhere do we can use this from other places as well?

newTypeError

public RaiseException newTypeError(IRubyObject receivedObject,
                          RubyClass expectedType)

newTypeError

public RaiseException newTypeError(IRubyObject receivedObject,
                          RubyModule expectedType)

newTypeError

public RaiseException newTypeError(IRubyObject receivedObject,
                          String expectedType)

newEOFError
```
public RaiseException newEOFError()
```

newEOFError

public RaiseException newEOFError(String message)

newZeroDivisionError

public RaiseException newZeroDivisionError()

newFloatDomainError

public RaiseException newFloatDomainError(String message)

newMathDomainError

public RaiseException newMathDomainError(String message)

newEncodingError

public RaiseException newEncodingError(String message)

newEncodingCompatibilityError

public RaiseException newEncodingCompatibilityError(String message)

newConverterNotFoundError

public RaiseException newConverterNotFoundError(String message)

newFiberError

public RaiseException newFiberError(String message)

newUndefinedConversionError

public RaiseException newUndefinedConversionError(String message)

newInvalidByteSequenceError

public RaiseException newInvalidByteSequenceError(String message)

newRaiseException

public RaiseException newRaiseException(RubyClass exceptionClass,
                               String message)

Parameters:: exceptionClass -; message -
Returns:

newStopIteration
```
public RaiseException newStopIteration(IRubyObject result,
                              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

newLightweightStopIterationError

@Deprecated
public RaiseException newLightweightStopIterationError(String message)

Deprecated.

newData

public RubyObject.Data newData(RubyClass objectClass,
                      Object sval)

getSymbolTable

public RubySymbol.SymbolTable getSymbolTable()

getObjectSpace
```
public ObjectSpace getObjectSpace()
```

getIn
```
public InputStream getIn()
```

getOut
```
public PrintStream getOut()
```

getErr
```
public 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(Object obj)

isInspecting

public boolean isInspecting(Object obj)

unregisterInspecting

public void unregisterInspecting(Object obj)

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(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 String getJRubyHome()
```

setJRubyHome

public void setJRubyHome(String home)

getInstanceConfig

public RubyInstanceConfig getInstanceConfig()

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()

getExecutor
```
public ExecutorService getExecutor()
```

getFiberExecutor

public ExecutorService getFiberExecutor()

getTimezoneCache

public Map<String,org.joda.time.DateTimeZone> getTimezoneCache()

getConstantGeneration

@Deprecated
public int getConstantGeneration()

Deprecated.

getConstantInvalidator

public Invalidator getConstantInvalidator(String constantName)

getCheckpointInvalidator

public Invalidator getCheckpointInvalidator()

loadConstantSet

public <E extends Enum<E>> void loadConstantSet(RubyModule module,
                                       Class<E> enumClass)

loadConstantSet

public void loadConstantSet(RubyModule module,
                   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 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

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

isBootingCore
```
public boolean isBootingCore()
```

isBooting
```
public boolean isBooting()
```

getCoverageData
```
public CoverageData getCoverageData()
```

getRandom
```
public 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)

freezeAndDedupString
```
public RubyString freezeAndDedupString(RubyString string)
```
Given a Ruby string, cache a frozen, duplicated copy of it, or find an existing copy already prepared. This is used to reduce in-memory duplication of pre-frozen or known-frozen strings. Note that this cache does some sync against the Ruby instance. This could cause contention under heavy concurrent load, so a reexamination of this design might be warranted.

Parameters:
string - the string to freeze-dup if an equivalent does not already exist

Returns:
the freeze-duped version of the string

getRuntimeNumber
```
public int getRuntimeNumber()
```

constant
```
public Object constant()
```
Specified by:

constant in interface Constantizable

See Also:
Constantizable

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.

is1_8
```
@Deprecated
public boolean is1_8()
```
Deprecated.

is1_9
```
@Deprecated
public boolean is1_9()
```
Deprecated.

getFilenoUtil
```
public FilenoUtil getFilenoUtil()
```

addToObjectSpace

public void addToObjectSpace(boolean useObjectSpace,
                    IRubyObject object)

Class Ruby

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NIL_PREFILLED_ARRAY_SIZE

ERRNO_BACKTRACE_MESSAGE

STOPIERATION_BACKTRACE_MESSAGE

Method Detail

registerMBeans

newInstance

newInstance

newInstance

isGlobalRuntimeReady

getGlobalRuntime

useAsGlobalRuntime

clearGlobalRuntime

getThreadLocalRuntime

setThreadLocalRuntime

evalScriptlet

evalScriptlet

executeScript

runFromMain

parseFromMain

parseFromMain

runWithGetsLoop

runWithGetsLoop

runNormally

runNormally

tryCompile

runScript

runScript

runScriptBody

runInterpreter

runInterpreter

runInterpreter

runInterpreter

runInterpreterBody

getParser

getBeanManager

getJITCompiler

getTruffleContext

shutdownTruffleContextIfRunning

getDefaultInstance

getCurrentInstance

setCurrentInstance

allocSymbolId

allocModuleId

addModule

eachModule

getModule

fastGetModule

getClass

fastGetClass

defineClass

defineClass

defineClassUnder

defineClassUnder

defineModule

defineModuleUnder

getOrCreateModule

getKCode

setKCode

defineGlobalConstant

fetchGlobalConstant

isClassDefined

loadJavaSupport

getNilPrefilledArray

getErrno

getIRManager

getTopSelf

getRootFiber

setRootFiber

setCurrentDirectory

getCurrentDirectory

setCurrentLine

getCurrentLine

setArgsFile

getArgsFile