IRRuntimeHelpers (JRuby Core 9.1.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 IRubyObject`	`callOptimizedAref(ThreadContext context, IRubyObject caller, IRubyObject target, RubyString keyStr, CallSite site)`
`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 RubyString`	`freezeLiteralString(ThreadContext context, RubyString string, String file, int line)`
`static void`	`frobnicateKwargsArgument(ThreadContext context, IRubyObject[] args, int requiredArgsCount)`
`static RubyFixnum`	`getArgScopeDepth(ThreadContext context, StaticScope currScope)`
`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 DynamicMethod`	`getRefinedMethodForClass(StaticScope refinedScope, RubyModule target, String methodName)`
`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, CallSite callSite)`
`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 RubyRegexp`	`newDynamicRegexp(ThreadContext context, IRubyObject arg0, int embeddedOptions)`
`static RubyRegexp`	`newDynamicRegexp(ThreadContext context, IRubyObject arg0, IRubyObject arg1, int embeddedOptions)`
`static RubyRegexp`	`newDynamicRegexp(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, int embeddedOptions)`
`static RubyRegexp`	`newDynamicRegexp(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, IRubyObject arg3, int embeddedOptions)`
`static RubyRegexp`	`newDynamicRegexp(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, IRubyObject arg3, IRubyObject arg4, int embeddedOptions)`
`static RubyString`	`newFrozenString(ThreadContext context, org.jruby.util.ByteList bytelist, int coderange, String file, int line)`
`static RubyString`	`newFrozenStringFromRaw(ThreadContext context, String str, String encoding, int cr, String file, int line)`
`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 RubyProc`	`newSymbolProc(ThreadContext context, String symbol, org.jcodings.Encoding encoding)` Create a new Symbol.to_proc for the given symbol name and encoding.
`static RubyProc`	`newSymbolProc(ThreadContext context, String symbol, String encoding)` Create a new Symbol.to_proc for the given symbol name and encoding.
`static VariableCachingCallSite`	`newVariableCachingCallSite(String name)`
`static IRubyObject`	`nthMatch(ThreadContext context, int matchNumber)`
`static Block`	`prepareBlock(ThreadContext context, IRubyObject self, DynamicScope scope, BlockBody body)`
`static IRubyObject[]`	`prepareBlockArgs(ThreadContext context, Block block, IRubyObject[] args, boolean usesKwArgs)`
`static IRubyObject[]`	`prepareFixedBlockArgs(ThreadContext context, Block block, IRubyObject[] args)`
`static IRubyObject[]`	`prepareNoBlockArgs(ThreadContext context, Block block, IRubyObject[] args)` Check whether incoming args are zero length for a lambda, and no-op for non-lambda.
`static IRubyObject[]`	`prepareSingleBlockArgs(ThreadContext context, Block block, IRubyObject[] args)`
`static DynamicScope`	`pushBlockDynamicScopeIfNeeded(ThreadContext context, Block block, boolean pushNewDynScope, boolean reuseParentDynScope)`
`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, IRubyObject[] args, int required, int argIndex, boolean acceptsKeywordArguments)`
`static IRubyObject`	`receiveRestArg(ThreadContext context, Object[] args, int required, int argIndex, boolean acceptsKeywordArguments)`
`static IRubyObject`	`restoreExceptionVar(ThreadContext context, IRubyObject exc, IRubyObject savedExc)`
`static RubyEncoding`	`retrieveEncoding(ThreadContext context, String name)`
`static org.jcodings.Encoding`	`retrieveJCodingsEncoding(ThreadContext context, String name)`
`static IRubyObject`	`returnOrRethrowSavedException(ThreadContext context, IRubyObject value)`
`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[]`	`singleBlockArgToArray(IRubyObject value)`
`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`	`updateBlockState(Block block, IRubyObject self)`
`static IRubyObject`	`useBindingSelf(Binding binding)`
`static IRubyObject`	`yield(ThreadContext context, Block b, IRubyObject yieldArg, boolean unwrapArray)`
`static IRubyObject`	`yieldSpecific(ThreadContext context, Block b)`
`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

returnOrRethrowSavedException

public static IRubyObject returnOrRethrowSavedException(ThreadContext context,
                                        IRubyObject value)

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,
                CallSite callSite)

newProc

public static IRubyObject newProc(Ruby runtime,
                  Block block)

yield

public static IRubyObject yield(ThreadContext context,
                Block b,
                IRubyObject yieldArg,
                boolean unwrapArray)

yieldSpecific

public static IRubyObject yieldSpecific(ThreadContext context,
                        Block b)

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,
                            IRubyObject[] args,
                            int requiredArgsCount)

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)

restoreExceptionVar

public static IRubyObject restoreExceptionVar(ThreadContext context,
                              IRubyObject exc,
                              IRubyObject savedExc)

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)

receiveRestArg

public static IRubyObject receiveRestArg(ThreadContext context,
                         IRubyObject[] 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(ThreadContext context,
                                String str,
                                String encoding,
                                int cr,
                                String file,
                                int line)

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)

defCompiledClassMethod

public static void defCompiledClassMethod(ThreadContext context,
                          java.lang.invoke.MethodHandle variable,
                          java.lang.invoke.MethodHandle specific,
                          int specificArity,
                          IRScope method,
                          IRubyObject obj)

defInterpretedInstanceMethod

public static void defInterpretedInstanceMethod(ThreadContext context,
                                IRScope method,
                                DynamicScope currDynScope,
                                IRubyObject self)

defCompiledInstanceMethod

public static void defCompiledInstanceMethod(ThreadContext context,
                             java.lang.invoke.MethodHandle handle,
                             IRScope method,
                             DynamicScope currDynScope,
                             IRubyObject self)

defCompiledInstanceMethod

public static void defCompiledInstanceMethod(ThreadContext context,
                             java.lang.invoke.MethodHandle variable,
                             java.lang.invoke.MethodHandle specific,
                             int specificArity,
                             IRScope method,
                             DynamicScope currDynScope,
                             IRubyObject self)

invokeModuleBody

public static IRubyObject invokeModuleBody(ThreadContext context,
                           DynamicMethod method,
                           Block block)

newDynamicRegexp

public static RubyRegexp newDynamicRegexp(ThreadContext context,
                          IRubyObject[] pieces,
                          int embeddedOptions)

newDynamicRegexp

public static RubyRegexp newDynamicRegexp(ThreadContext context,
                          IRubyObject arg0,
                          int embeddedOptions)

newDynamicRegexp

public static RubyRegexp newDynamicRegexp(ThreadContext context,
                          IRubyObject arg0,
                          IRubyObject arg1,
                          int embeddedOptions)

newDynamicRegexp

public static RubyRegexp newDynamicRegexp(ThreadContext context,
                          IRubyObject arg0,
                          IRubyObject arg1,
                          IRubyObject arg2,
                          int embeddedOptions)

newDynamicRegexp

public static RubyRegexp newDynamicRegexp(ThreadContext context,
                          IRubyObject arg0,
                          IRubyObject arg1,
                          IRubyObject arg2,
                          IRubyObject arg3,
                          int embeddedOptions)

newDynamicRegexp

public static RubyRegexp newDynamicRegexp(ThreadContext context,
                          IRubyObject arg0,
                          IRubyObject arg1,
                          IRubyObject arg2,
                          IRubyObject arg3,
                          IRubyObject arg4,
                          int embeddedOptions)

newLiteralRegexp

public static RubyRegexp newLiteralRegexp(ThreadContext context,
                          org.jruby.util.ByteList source,
                          RegexpOptions options)

newLiteralRegexp

public static RubyRegexp newLiteralRegexp(ThreadContext context,
                          org.jruby.util.ByteList source,
                          int embeddedOptions)

irSplat

public static RubyArray irSplat(ThreadContext context,
                IRubyObject ary)

irToAry

public static IRubyObject irToAry(ThreadContext context,
                  IRubyObject value)

irReqdArgMultipleAsgnIndex

public static int irReqdArgMultipleAsgnIndex(int n,
                             int preArgsCount,
                             int index,
                             int postArgsCount)

irReqdArgMultipleAsgn

public static IRubyObject irReqdArgMultipleAsgn(ThreadContext context,
                                RubyArray rubyArray,
                                int preArgsCount,
                                int index,
                                int postArgsCount)

irNot

public static IRubyObject irNot(ThreadContext context,
                IRubyObject obj)

newRequiredKeywordArgumentError

public static RaiseException newRequiredKeywordArgumentError(ThreadContext context,
                                             String name)

pushExitBlock

public static void pushExitBlock(ThreadContext context,
                 Block blk)

newFunctionalCachingCallSite

public static FunctionalCachingCallSite newFunctionalCachingCallSite(String name)

newNormalCachingCallSite

public static NormalCachingCallSite newNormalCachingCallSite(String name)

newVariableCachingCallSite

public static VariableCachingCallSite newVariableCachingCallSite(String name)

newRefinedCachingCallSite

public static RefinedCachingCallSite newRefinedCachingCallSite(String name,
                                               String callType)

decodeScopeFromBytes

public static IRScope decodeScopeFromBytes(Ruby runtime,
                           byte[] scopeBytes,
                           String filename)

getVariableAccessorForRead

public static VariableAccessor getVariableAccessorForRead(IRubyObject object,
                                          String name)

getVariableAccessorForWrite

public static VariableAccessor getVariableAccessorForWrite(IRubyObject object,
                                           String name)

getVariableWithAccessor

public static IRubyObject getVariableWithAccessor(IRubyObject self,
                                  VariableAccessor accessor,
                                  ThreadContext context,
                                  String name)

setVariableWithAccessor

public static void setVariableWithAccessor(IRubyObject self,
                           IRubyObject value,
                           VariableAccessor accessor)

getArgScopeDepth

public static RubyFixnum getArgScopeDepth(ThreadContext context,
                          StaticScope currScope)

prepareNoBlockArgs
```
public static IRubyObject[] prepareNoBlockArgs(ThreadContext context,
                               Block block,
                               IRubyObject[] args)
```
Check whether incoming args are zero length for a lambda, and no-op for non-lambda. This could probably be simplified to just an arity check with no return value, but returns the incoming args currently for consistency with the other prepares.

Parameters:
context -
block -
args -

Returns:

prepareSingleBlockArgs

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

prepareFixedBlockArgs

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

prepareBlockArgs

public static IRubyObject[] prepareBlockArgs(ThreadContext context,
                             Block block,
                             IRubyObject[] args,
                             boolean usesKwArgs)

pushBlockDynamicScopeIfNeeded

public static DynamicScope pushBlockDynamicScopeIfNeeded(ThreadContext context,
                                         Block block,
                                         boolean pushNewDynScope,
                                         boolean reuseParentDynScope)

updateBlockState

public static IRubyObject updateBlockState(Block block,
                           IRubyObject self)

useBindingSelf

public static IRubyObject useBindingSelf(Binding binding)

newSymbolProc

public static RubyProc newSymbolProc(ThreadContext context,
                     String symbol,
                     org.jcodings.Encoding encoding)

Create a new Symbol.to_proc for the given symbol name and encoding.

Parameters:: context -; symbol -
Returns:

newSymbolProc

public static RubyProc newSymbolProc(ThreadContext context,
                     String symbol,
                     String encoding)

Create a new Symbol.to_proc for the given symbol name and encoding.

Parameters:: context -; symbol -
Returns:

singleBlockArgToArray

public static IRubyObject[] singleBlockArgToArray(IRubyObject value)

prepareBlock

public static Block prepareBlock(ThreadContext context,
                 IRubyObject self,
                 DynamicScope scope,
                 BlockBody body)

newFrozenString

public static RubyString newFrozenString(ThreadContext context,
                         org.jruby.util.ByteList bytelist,
                         int coderange,
                         String file,
                         int line)

freezeLiteralString

public static RubyString freezeLiteralString(ThreadContext context,
                             RubyString string,
                             String file,
                             int line)

callOptimizedAref

public static IRubyObject callOptimizedAref(ThreadContext context,
                            IRubyObject caller,
                            IRubyObject target,
                            RubyString keyStr,
                            CallSite site)

getRefinedMethodForClass

public static DynamicMethod getRefinedMethodForClass(StaticScope refinedScope,
                                     RubyModule target,
                                     String methodName)

Class IRRuntimeHelpers

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

IRRuntimeHelpers

Method Detail

inProfileMode

isDebug

inNonMethodBodyLambda

inLambda

inProc

checkForLJE

initiateNonLocalReturn

handleNonlocalReturn

initiateBreak

handleBreakAndReturnsInLambdas

returnOrRethrowSavedException

handlePropagatedBreak

defCompiledIRMethod

defCompiledIRClassMethod

undefMethod

unboxFloat

unboxFixnum

flt

fgt

feq

ilt

igt

ieq

unwrapRubyException

isExceptionHandled

isEQQ

newProc

yield

yieldSpecific

convertValueIntoArgArray

getBlockFromObject

checkArity

frobnicateKwargsArgument

extractKwargsHash

checkForExtraUnwantedKeywordArgs

match3

extractOptionalArgument

isDefinedBackref

isDefinedGlobal

isDefinedNthRef

isDefinedClassVar

isDefinedInstanceVar

isDefinedCall

isDefinedConstantOrMethod

isDefinedMethod

isDefinedSuper

checkSuperDisabledOrOutOfMethod

nthMatch

defineAlias

getModuleFromScope

mergeKeywordArguments

restoreExceptionVar

findInstanceMethodContainer

isBlockGiven

receiveRestArg

receiveRestArg

constructRestArg

receivePostReqdArg

receiveOptArg

getPreArgSafe

receiveKeywordArg

receiveKeywordRestArg

setCapturedVar

instanceSuperSplatArgs

instanceSuper

classSuperSplatArgs

classSuper

unresolvedSuperSplatArgs

unresolvedSuper

zSuperSplatArgs

splatArguments

encodeSplatmap

decodeSplatmap