IRRuntimeHelpers (JRuby Core 9.0.0.0 API)

java.lang.Object
- org.jruby.ir.runtime.IRRuntimeHelpers

public class IRRuntimeHelpers
extends Object

Constructor Summary

Constructors
Constructor and Description

IRRuntimeHelpers()

Constructors
Constructor and Description
`IRRuntimeHelpers()`

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean[]`	`buildSplatMap(Operand[] args, boolean containsArgSplat)`
`static void`	`checkArity(ThreadContext context, Object[] args, int required, int opt, boolean rest, boolean receivesKwargs, int restKey, Block.Type blockType)`
`static void`	`checkForExtraUnwantedKeywordArgs(ThreadContext context, RubyHash keywordArgs)`
`static void`	`checkForLJE(ThreadContext context, DynamicScope dynScope, boolean maybeLambda, Block.Type blockType)`
`protected static void`	`checkSuperDisabledOrOutOfMethod(ThreadContext context, RubyModule frameClass, String methodName)`
`static IRubyObject`	`classSuper(ThreadContext context, IRubyObject self, String methodName, RubyModule definingModule, IRubyObject[] args, Block block)`
`static IRubyObject`	`classSuperSplatArgs(ThreadContext context, IRubyObject self, String methodName, RubyModule definingModule, IRubyObject[] args, Block block, boolean[] splatMap)`
`static RubyHash`	`constructHashFromArray(Ruby runtime, IRubyObject[] pairs)`
`static IRubyObject`	`constructRestArg(ThreadContext context, Object[] args, RubyHash keywordArguments, int required, int argIndex)`
`static IRubyObject[]`	`convertValueIntoArgArray(ThreadContext context, IRubyObject value, int blockArity, boolean argIsArray)`
`static IRScope`	`decodeScopeFromBytes(Ruby runtime, byte[] scopeBytes, String filename)`
`static boolean[]`	`decodeSplatmap(String splatmapString)`
`static void`	`defCompiledClassMethod(ThreadContext context, java.lang.invoke.MethodHandle handle, IRScope method, IRubyObject obj)`
`static void`	`defCompiledClassMethod(ThreadContext context, java.lang.invoke.MethodHandle variable, java.lang.invoke.MethodHandle specific, int specificArity, IRScope method, IRubyObject obj)`
`static void`	`defCompiledInstanceMethod(ThreadContext context, java.lang.invoke.MethodHandle handle, IRScope method, DynamicScope currDynScope, IRubyObject self)`
`static void`	`defCompiledInstanceMethod(ThreadContext context, java.lang.invoke.MethodHandle variable, java.lang.invoke.MethodHandle specific, int specificArity, IRScope method, DynamicScope currDynScope, IRubyObject self)`
`static void`	`defCompiledIRClassMethod(ThreadContext context, IRubyObject obj, java.lang.invoke.MethodHandle handle, String rubyName, IRScope irScope)`
`static void`	`defCompiledIRMethod(ThreadContext context, java.lang.invoke.MethodHandle handle, String rubyName, DynamicScope currDynScope, IRubyObject self, IRScope irScope)`
`static void`	`defineAlias(ThreadContext context, IRubyObject self, DynamicScope currDynScope, String newNameString, String oldNameString)`
`static void`	`defInterpretedClassMethod(ThreadContext context, IRScope method, IRubyObject obj)`
`static void`	`defInterpretedInstanceMethod(ThreadContext context, IRScope method, DynamicScope currDynScope, IRubyObject self)`
`static RubyHash`	`dupKwargsHashAndPopulateFromArray(ThreadContext context, RubyHash dupHash, IRubyObject[] pairs)`
`static String`	`encodeSplatmap(boolean[] splatmap)`
`static RubyHash`	`extractKwargsHash(Object[] args, int requiredArgsCount, boolean receivesKwargs)`
`static IRubyObject`	`extractOptionalArgument(RubyArray rubyArray, int minArgsLength, int index)`
`static boolean`	`feq(double v1, double v2)`
`static boolean`	`fgt(double v1, double v2)`
`static RubyModule`	`findInstanceMethodContainer(ThreadContext context, DynamicScope currDynScope, IRubyObject self)`
`static boolean`	`flt(double v1, double v2)`
`static void`	`frobnicateKwargsArgument(ThreadContext context, int requiredArguments, IRubyObject[] args)`
`static Block`	`getBlockFromObject(ThreadContext context, Object value)`
`static RubyModule`	`getModuleFromScope(ThreadContext context, StaticScope scope, IRubyObject arg)`
`static IRubyObject`	`getPreArgSafe(ThreadContext context, IRubyObject[] args, int argIndex)`
`static VariableAccessor`	`getVariableAccessorForRead(IRubyObject object, String name)`
`static VariableAccessor`	`getVariableAccessorForWrite(IRubyObject object, String name)`
`static IRubyObject`	`getVariableWithAccessor(IRubyObject self, VariableAccessor accessor, ThreadContext context, String name)`
`static IRubyObject`	`handleBreakAndReturnsInLambdas(ThreadContext context, StaticScope scope, DynamicScope dynScope, Object exc, Block.Type blockType)`
`static IRubyObject`	`handleNonlocalReturn(StaticScope scope, DynamicScope dynScope, Object rjExc, Block.Type blockType)`
`static IRubyObject`	`handlePropagatedBreak(ThreadContext context, DynamicScope dynScope, Object bjExc, Block.Type blockType)`
`static boolean`	`ieq(long v1, long v2)`
`static boolean`	`igt(long v1, long v2)`
`static boolean`	`ilt(long v1, long v2)`
`static IRubyObject`	`inheritedSearchConst(ThreadContext context, IRubyObject cmVal, String constName, boolean noPrivateConsts)`
`static IRubyObject`	`initiateBreak(ThreadContext context, DynamicScope dynScope, IRubyObject breakValue, Block.Type blockType)`
`static IRubyObject`	`initiateNonLocalReturn(ThreadContext context, DynamicScope dynScope, Block.Type blockType, IRubyObject returnValue)`
`static boolean`	`inLambda(Block.Type blockType)`
`static boolean`	`inNonMethodBodyLambda(StaticScope scope, Block.Type blockType)`
`static boolean`	`inProc(Block.Type blockType)`
`static boolean`	`inProfileMode()`
`static IRubyObject`	`instanceSuper(ThreadContext context, IRubyObject self, String methodName, RubyModule definingModule, IRubyObject[] args, Block block)`
`static IRubyObject`	`instanceSuperSplatArgs(ThreadContext context, IRubyObject self, String methodName, RubyModule definingModule, IRubyObject[] args, Block block, boolean[] splatMap)`
`static IRubyObject`	`invokeModuleBody(ThreadContext context, DynamicMethod method, Block block)`
`static IRubyObject`	`irNot(ThreadContext context, IRubyObject obj)`
`static IRubyObject`	`irReqdArgMultipleAsgn(ThreadContext context, RubyArray rubyArray, int preArgsCount, int index, int postArgsCount)`
`static int`	`irReqdArgMultipleAsgnIndex(int n, int preArgsCount, int index, int postArgsCount)`
`static RubyArray`	`irSplat(ThreadContext context, IRubyObject ary)`
`static IRubyObject`	`irToAry(ThreadContext context, IRubyObject value)`
`static RubyBoolean`	`isBlockGiven(ThreadContext context, Object blk)`
`static boolean`	`isDebug()`
`static IRubyObject`	`isDefinedBackref(ThreadContext context)`
`static IRubyObject`	`isDefinedCall(ThreadContext context, IRubyObject self, IRubyObject receiver, String name)`
`static IRubyObject`	`isDefinedClassVar(ThreadContext context, RubyModule receiver, String name)`
`static IRubyObject`	`isDefinedConstantOrMethod(ThreadContext context, IRubyObject receiver, String name)`
`static IRubyObject`	`isDefinedGlobal(ThreadContext context, String name)`
`static IRubyObject`	`isDefinedInstanceVar(ThreadContext context, IRubyObject receiver, String name)`
`static IRubyObject`	`isDefinedMethod(ThreadContext context, IRubyObject receiver, String name, boolean checkIfPublic)`
`static IRubyObject`	`isDefinedNthRef(ThreadContext context, int matchNumber)`
`static IRubyObject`	`isDefinedSuper(ThreadContext context, IRubyObject receiver)`
`static IRubyObject`	`isEQQ(ThreadContext context, IRubyObject receiver, IRubyObject value)`
`static IRubyObject`	`isExceptionHandled(ThreadContext context, IRubyObject excType, Object excObj)`
`static IRubyObject`	`lexicalSearchConst(ThreadContext context, StaticScope staticScope, String constName)`
`static IRubyObject`	`match3(ThreadContext context, RubyRegexp regexp, IRubyObject argValue)`
`static IRubyObject`	`mergeKeywordArguments(ThreadContext context, IRubyObject restKwarg, IRubyObject explcitKwarg)`
`static org.jruby.util.ByteList`	`newByteListFromRaw(Ruby runtime, String str, String encoding)`
`static DynamicMethod`	`newCompiledClassBody(ThreadContext context, java.lang.invoke.MethodHandle handle, IRScope irClassBody, Object container, Object superClass)`
`static DynamicMethod`	`newCompiledMetaClass(ThreadContext context, java.lang.invoke.MethodHandle handle, IRScope metaClassBody, IRubyObject obj)` Construct a new DynamicMethod to wrap the given IRModuleBody and singletonizable object.
`static DynamicMethod`	`newCompiledModuleBody(ThreadContext context, java.lang.invoke.MethodHandle handle, IRScope irModule, Object rubyContainer)`
`static RubyRegexp`	`newDynamicRegexp(ThreadContext context, IRubyObject[] pieces, int embeddedOptions)`
`static RubyString`	`newFrozenStringFromRaw(Ruby runtime, String str, String encoding, int cr)`
`static FunctionalCachingCallSite`	`newFunctionalCachingCallSite(String name)`
`static DynamicMethod`	`newInterpretedClassBody(ThreadContext context, IRScope irClassBody, Object container, Object superClass)`
`static DynamicMethod`	`newInterpretedMetaClass(Ruby runtime, IRScope metaClassBody, IRubyObject obj)` Construct a new DynamicMethod to wrap the given IRModuleBody and singletonizable object.
`static DynamicMethod`	`newInterpretedModuleBody(ThreadContext context, IRScope irModule, Object rubyContainer)` Construct a new DynamicMethod to wrap the given IRModuleBody and singletonizable object.
`static RubyRegexp`	`newLiteralRegexp(ThreadContext context, org.jruby.util.ByteList source, int embeddedOptions)`
`static RubyRegexp`	`newLiteralRegexp(ThreadContext context, org.jruby.util.ByteList source, RegexpOptions options)`
`static NormalCachingCallSite`	`newNormalCachingCallSite(String name)`
`static IRubyObject`	`newProc(Ruby runtime, Block block)`
`static RefinedCachingCallSite`	`newRefinedCachingCallSite(String name, String callType)`
`static RaiseException`	`newRequiredKeywordArgumentError(ThreadContext context, String name)`
`static RubyModule`	`newRubyClassFromIR(Ruby runtime, IRScope irClassBody, Object superClass, Object container)`
`static VariableCachingCallSite`	`newVariableCachingCallSite(String name)`
`static IRubyObject`	`nthMatch(ThreadContext context, int matchNumber)`
`static void`	`pushExitBlock(ThreadContext context, Block blk)`
`static IRubyObject`	`receiveKeywordArg(ThreadContext context, IRubyObject[] args, int required, String argName, boolean acceptsKeywordArgument)`
`static IRubyObject`	`receiveKeywordRestArg(ThreadContext context, IRubyObject[] args, int required, boolean keywordArgumentSupplied)`
`static IRubyObject`	`receiveOptArg(IRubyObject[] args, int requiredArgs, int preArgs, int argIndex, boolean acceptsKeywordArgument)`
`static IRubyObject`	`receivePostReqdArg(ThreadContext context, IRubyObject[] args, int preReqdArgsCount, int postReqdArgsCount, int argIndex, boolean acceptsKeywordArgument)`
`static IRubyObject`	`receiveRestArg(ThreadContext context, Object[] args, int required, int argIndex, boolean acceptsKeywordArguments)`
`static RubyEncoding`	`retrieveEncoding(ThreadContext context, String name)`
`static org.jcodings.Encoding`	`retrieveJCodingsEncoding(ThreadContext context, String name)`
`static IRubyObject`	`searchConst(ThreadContext context, StaticScope staticScope, String constName, boolean noPrivateConsts)`
`static IRubyObject`	`setCapturedVar(ThreadContext context, IRubyObject matchRes, String varName)`
`static IRubyObject`	`setInstanceVariable(IRubyObject self, IRubyObject value, String name)`
`static void`	`setVariableWithAccessor(IRubyObject self, IRubyObject value, VariableAccessor accessor)`
`static IRubyObject[]`	`splatArguments(IRubyObject[] args, boolean[] splatMap)`
`static org.objectweb.asm.Type[]`	`typesFromSignature(com.headius.invokebinder.Signature signature)`
`static long`	`unboxFixnum(IRubyObject val)`
`static double`	`unboxFloat(IRubyObject val)`
`static IRubyObject`	`undefMethod(ThreadContext context, Object nameArg, DynamicScope currDynScope, IRubyObject self)`
`static IRubyObject`	`unresolvedSuper(ThreadContext context, IRubyObject self, IRubyObject[] args, Block block)`
`static IRubyObject`	`unresolvedSuperSplatArgs(ThreadContext context, IRubyObject self, IRubyObject[] args, Block block, boolean[] splatMap)`
`static Object`	`unwrapRubyException(Object excObj)`
`static IRubyObject`	`yield(ThreadContext context, Object blk, Object yieldArg, boolean unwrapArray)`
`static IRubyObject`	`yieldSpecific(ThreadContext context, Object blk)`
`static IRubyObject`	`zSuperSplatArgs(ThreadContext context, IRubyObject self, IRubyObject[] args, Block block, boolean[] splatMap)`

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

Constructor Detail
- IRRuntimeHelpers
```
public IRRuntimeHelpers()
```

Method Detail

inProfileMode
```
public static boolean inProfileMode()
```

isDebug
```
public static boolean isDebug()
```

inNonMethodBodyLambda

public static boolean inNonMethodBodyLambda(StaticScope scope,
                            Block.Type blockType)

inLambda

public static boolean inLambda(Block.Type blockType)

inProc

public static boolean inProc(Block.Type blockType)

checkForLJE

public static void checkForLJE(ThreadContext context,
               DynamicScope dynScope,
               boolean maybeLambda,
               Block.Type blockType)

initiateNonLocalReturn

public static IRubyObject initiateNonLocalReturn(ThreadContext context,
                                 DynamicScope dynScope,
                                 Block.Type blockType,
                                 IRubyObject returnValue)

handleNonlocalReturn

public static IRubyObject handleNonlocalReturn(StaticScope scope,
                               DynamicScope dynScope,
                               Object rjExc,
                               Block.Type blockType)
                                        throws RuntimeException

Throws:: RuntimeException

initiateBreak

public static IRubyObject initiateBreak(ThreadContext context,
                        DynamicScope dynScope,
                        IRubyObject breakValue,
                        Block.Type blockType)
                                 throws RuntimeException

Throws:: RuntimeException

handleBreakAndReturnsInLambdas

public static IRubyObject handleBreakAndReturnsInLambdas(ThreadContext context,
                                         StaticScope scope,
                                         DynamicScope dynScope,
                                         Object exc,
                                         Block.Type blockType)
                                                  throws RuntimeException

Throws:: RuntimeException

handlePropagatedBreak

public static IRubyObject handlePropagatedBreak(ThreadContext context,
                                DynamicScope dynScope,
                                Object bjExc,
                                Block.Type blockType)

defCompiledIRMethod

public static void defCompiledIRMethod(ThreadContext context,
                       java.lang.invoke.MethodHandle handle,
                       String rubyName,
                       DynamicScope currDynScope,
                       IRubyObject self,
                       IRScope irScope)

defCompiledIRClassMethod

public static void defCompiledIRClassMethod(ThreadContext context,
                            IRubyObject obj,
                            java.lang.invoke.MethodHandle handle,
                            String rubyName,
                            IRScope irScope)

undefMethod

public static IRubyObject undefMethod(ThreadContext context,
                      Object nameArg,
                      DynamicScope currDynScope,
                      IRubyObject self)

unboxFloat

public static double unboxFloat(IRubyObject val)

unboxFixnum

public static long unboxFixnum(IRubyObject val)

flt

public static boolean flt(double v1,
          double v2)

fgt

public static boolean fgt(double v1,
          double v2)

feq

public static boolean feq(double v1,
          double v2)

ilt

public static boolean ilt(long v1,
          long v2)

igt

public static boolean igt(long v1,
          long v2)

ieq

public static boolean ieq(long v1,
          long v2)

unwrapRubyException

public static Object unwrapRubyException(Object excObj)

isExceptionHandled

public static IRubyObject isExceptionHandled(ThreadContext context,
                             IRubyObject excType,
                             Object excObj)

isEQQ

public static IRubyObject isEQQ(ThreadContext context,
                IRubyObject receiver,
                IRubyObject value)

newProc

public static IRubyObject newProc(Ruby runtime,
                  Block block)

yield

public static IRubyObject yield(ThreadContext context,
                Object blk,
                Object yieldArg,
                boolean unwrapArray)

yieldSpecific

public static IRubyObject yieldSpecific(ThreadContext context,
                        Object blk)

convertValueIntoArgArray

public static IRubyObject[] convertValueIntoArgArray(ThreadContext context,
                                     IRubyObject value,
                                     int blockArity,
                                     boolean argIsArray)

getBlockFromObject

public static Block getBlockFromObject(ThreadContext context,
                       Object value)

checkArity

public static void checkArity(ThreadContext context,
              Object[] args,
              int required,
              int opt,
              boolean rest,
              boolean receivesKwargs,
              int restKey,
              Block.Type blockType)

frobnicateKwargsArgument

public static void frobnicateKwargsArgument(ThreadContext context,
                            int requiredArguments,
                            IRubyObject[] args)

extractKwargsHash

public static RubyHash extractKwargsHash(Object[] args,
                         int requiredArgsCount,
                         boolean receivesKwargs)

checkForExtraUnwantedKeywordArgs

public static void checkForExtraUnwantedKeywordArgs(ThreadContext context,
                                    RubyHash keywordArgs)

match3

public static IRubyObject match3(ThreadContext context,
                 RubyRegexp regexp,
                 IRubyObject argValue)

extractOptionalArgument

public static IRubyObject extractOptionalArgument(RubyArray rubyArray,
                                  int minArgsLength,
                                  int index)

isDefinedBackref

public static IRubyObject isDefinedBackref(ThreadContext context)

isDefinedGlobal

public static IRubyObject isDefinedGlobal(ThreadContext context,
                          String name)

isDefinedNthRef

public static IRubyObject isDefinedNthRef(ThreadContext context,
                          int matchNumber)

isDefinedClassVar

public static IRubyObject isDefinedClassVar(ThreadContext context,
                            RubyModule receiver,
                            String name)

isDefinedInstanceVar

public static IRubyObject isDefinedInstanceVar(ThreadContext context,
                               IRubyObject receiver,
                               String name)

isDefinedCall

public static IRubyObject isDefinedCall(ThreadContext context,
                        IRubyObject self,
                        IRubyObject receiver,
                        String name)

isDefinedConstantOrMethod

public static IRubyObject isDefinedConstantOrMethod(ThreadContext context,
                                    IRubyObject receiver,
                                    String name)

isDefinedMethod

public static IRubyObject isDefinedMethod(ThreadContext context,
                          IRubyObject receiver,
                          String name,
                          boolean checkIfPublic)

isDefinedSuper

public static IRubyObject isDefinedSuper(ThreadContext context,
                         IRubyObject receiver)

checkSuperDisabledOrOutOfMethod

protected static void checkSuperDisabledOrOutOfMethod(ThreadContext context,
                                   RubyModule frameClass,
                                   String methodName)

nthMatch

public static IRubyObject nthMatch(ThreadContext context,
                   int matchNumber)

defineAlias

public static void defineAlias(ThreadContext context,
               IRubyObject self,
               DynamicScope currDynScope,
               String newNameString,
               String oldNameString)

getModuleFromScope

public static RubyModule getModuleFromScope(ThreadContext context,
                            StaticScope scope,
                            IRubyObject arg)

mergeKeywordArguments

public static IRubyObject mergeKeywordArguments(ThreadContext context,
                                IRubyObject restKwarg,
                                IRubyObject explcitKwarg)

findInstanceMethodContainer

public static RubyModule findInstanceMethodContainer(ThreadContext context,
                                     DynamicScope currDynScope,
                                     IRubyObject self)

isBlockGiven

public static RubyBoolean isBlockGiven(ThreadContext context,
                       Object blk)

receiveRestArg

public static IRubyObject receiveRestArg(ThreadContext context,
                         Object[] args,
                         int required,
                         int argIndex,
                         boolean acceptsKeywordArguments)

constructRestArg

public static IRubyObject constructRestArg(ThreadContext context,
                           Object[] args,
                           RubyHash keywordArguments,
                           int required,
                           int argIndex)

receivePostReqdArg

public static IRubyObject receivePostReqdArg(ThreadContext context,
                             IRubyObject[] args,
                             int preReqdArgsCount,
                             int postReqdArgsCount,
                             int argIndex,
                             boolean acceptsKeywordArgument)

receiveOptArg

public static IRubyObject receiveOptArg(IRubyObject[] args,
                        int requiredArgs,
                        int preArgs,
                        int argIndex,
                        boolean acceptsKeywordArgument)

getPreArgSafe

public static IRubyObject getPreArgSafe(ThreadContext context,
                        IRubyObject[] args,
                        int argIndex)

receiveKeywordArg

public static IRubyObject receiveKeywordArg(ThreadContext context,
                            IRubyObject[] args,
                            int required,
                            String argName,
                            boolean acceptsKeywordArgument)

receiveKeywordRestArg

public static IRubyObject receiveKeywordRestArg(ThreadContext context,
                                IRubyObject[] args,
                                int required,
                                boolean keywordArgumentSupplied)

setCapturedVar

public static IRubyObject setCapturedVar(ThreadContext context,
                         IRubyObject matchRes,
                         String varName)

instanceSuperSplatArgs

public static IRubyObject instanceSuperSplatArgs(ThreadContext context,
                                 IRubyObject self,
                                 String methodName,
                                 RubyModule definingModule,
                                 IRubyObject[] args,
                                 Block block,
                                 boolean[] splatMap)

instanceSuper

public static IRubyObject instanceSuper(ThreadContext context,
                        IRubyObject self,
                        String methodName,
                        RubyModule definingModule,
                        IRubyObject[] args,
                        Block block)

classSuperSplatArgs

public static IRubyObject classSuperSplatArgs(ThreadContext context,
                              IRubyObject self,
                              String methodName,
                              RubyModule definingModule,
                              IRubyObject[] args,
                              Block block,
                              boolean[] splatMap)

classSuper

public static IRubyObject classSuper(ThreadContext context,
                     IRubyObject self,
                     String methodName,
                     RubyModule definingModule,
                     IRubyObject[] args,
                     Block block)

unresolvedSuperSplatArgs

public static IRubyObject unresolvedSuperSplatArgs(ThreadContext context,
                                   IRubyObject self,
                                   IRubyObject[] args,
                                   Block block,
                                   boolean[] splatMap)

unresolvedSuper

public static IRubyObject unresolvedSuper(ThreadContext context,
                          IRubyObject self,
                          IRubyObject[] args,
                          Block block)

zSuperSplatArgs

public static IRubyObject zSuperSplatArgs(ThreadContext context,
                          IRubyObject self,
                          IRubyObject[] args,
                          Block block,
                          boolean[] splatMap)

splatArguments

public static IRubyObject[] splatArguments(IRubyObject[] args,
                           boolean[] splatMap)

encodeSplatmap

public static String encodeSplatmap(boolean[] splatmap)

decodeSplatmap

public static boolean[] decodeSplatmap(String splatmapString)

buildSplatMap

public static boolean[] buildSplatMap(Operand[] args,
                      boolean containsArgSplat)

typesFromSignature

public static final org.objectweb.asm.Type[] typesFromSignature(com.headius.invokebinder.Signature signature)

newFrozenStringFromRaw

public static RubyString newFrozenStringFromRaw(Ruby runtime,
                                String str,
                                String encoding,
                                int cr)

newByteListFromRaw

public static final org.jruby.util.ByteList newByteListFromRaw(Ruby runtime,
                                         String str,
                                         String encoding)

retrieveEncoding

public static RubyEncoding retrieveEncoding(ThreadContext context,
                            String name)

retrieveJCodingsEncoding

public static org.jcodings.Encoding retrieveJCodingsEncoding(ThreadContext context,
                                             String name)

constructHashFromArray

public static RubyHash constructHashFromArray(Ruby runtime,
                              IRubyObject[] pairs)

dupKwargsHashAndPopulateFromArray

public static RubyHash dupKwargsHashAndPopulateFromArray(ThreadContext context,
                                         RubyHash dupHash,
                                         IRubyObject[] pairs)

searchConst

public static IRubyObject searchConst(ThreadContext context,
                      StaticScope staticScope,
                      String constName,
                      boolean noPrivateConsts)

inheritedSearchConst

public static IRubyObject inheritedSearchConst(ThreadContext context,
                               IRubyObject cmVal,
                               String constName,
                               boolean noPrivateConsts)

lexicalSearchConst

public static IRubyObject lexicalSearchConst(ThreadContext context,
                             StaticScope staticScope,
                             String constName)

setInstanceVariable

public static IRubyObject setInstanceVariable(IRubyObject self,
                              IRubyObject value,
                              String name)

newInterpretedMetaClass

public static DynamicMethod newInterpretedMetaClass(Ruby runtime,
                                    IRScope metaClassBody,
                                    IRubyObject obj)

Construct a new DynamicMethod to wrap the given IRModuleBody and singletonizable object. Used by interpreter.

newCompiledMetaClass

public static DynamicMethod newCompiledMetaClass(ThreadContext context,
                                 java.lang.invoke.MethodHandle handle,
                                 IRScope metaClassBody,
                                 IRubyObject obj)

Construct a new DynamicMethod to wrap the given IRModuleBody and singletonizable object. Used by JIT.

newInterpretedModuleBody

public static DynamicMethod newInterpretedModuleBody(ThreadContext context,
                                     IRScope irModule,
                                     Object rubyContainer)

Construct a new DynamicMethod to wrap the given IRModuleBody and singletonizable object. Used by interpreter.

newCompiledModuleBody

public static DynamicMethod newCompiledModuleBody(ThreadContext context,
                                  java.lang.invoke.MethodHandle handle,
                                  IRScope irModule,
                                  Object rubyContainer)

newInterpretedClassBody

public static DynamicMethod newInterpretedClassBody(ThreadContext context,
                                    IRScope irClassBody,
                                    Object container,
                                    Object superClass)

newCompiledClassBody

public static DynamicMethod newCompiledClassBody(ThreadContext context,
                                 java.lang.invoke.MethodHandle handle,
                                 IRScope irClassBody,
                                 Object container,
                                 Object superClass)

newRubyClassFromIR

public static RubyModule newRubyClassFromIR(Ruby runtime,
                            IRScope irClassBody,
                            Object superClass,
                            Object container)

defInterpretedClassMethod

public static void defInterpretedClassMethod(ThreadContext context,
                             IRScope method,
                             IRubyObject obj)

defCompiledClassMethod

public static void defCompiledClassMethod(ThreadContext context,
                          java.lang.invoke.MethodHandle handle,
                          IRScope method,
                          IRubyObject obj)