BaseBodyCompiler (JRuby Core 1.7.26 API)

java.lang.Object
- org.jruby.compiler.impl.BaseBodyCompiler

All Implemented Interfaces:

BodyCompiler

Direct Known Subclasses:

ChildScopedBodyCompiler, RootScopedBodyCompiler
```
public abstract class BaseBodyCompiler
extends Object
implements BodyCompiler
```
BaseBodyCompiler encapsulates all common behavior between BodyCompiler implementations.

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`argParamCount`
`protected org.objectweb.asm.Label[]`	`currentLoopLabels`
`protected boolean`	`inNestedMethod`
`protected boolean`	`inRescue`
`protected ASTInspector`	`inspector`
`protected InvocationCompiler`	`invocationCompiler`
`protected SkinnyMethodAdapter`	`method`
`protected String`	`methodName`
`protected org.objectweb.asm.Label`	`redoJump`
`protected String`	`rubyName`
`protected StaticScope`	`scope`
`protected org.objectweb.asm.Label`	`scopeEnd`
`protected int`	`scopeIndex`
`protected org.objectweb.asm.Label`	`scopeStart`
`protected StandardASMCompiler`	`script`
`protected VariableCompiler`	`variableCompiler`

Constructor Summary

Constructors
Constructor and Description
`BaseBodyCompiler(StandardASMCompiler scriptCompiler, String methodName, String rubyName, ASTInspector inspector, StaticScope scope, int scopeIndex)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`aliasGlobal(String newName, String oldName)`
`void`	`appendByteList(org.jruby.util.ByteList value, int codeRange, boolean is19)` Append the given bytelist + coderange to the string currently on the stack.
`void`	`appendObject(boolean is19)` Append the object on stack to the string below it.
`void`	`appendToArray()`
`void`	`appendToObjectArray()`
`void`	`aprintln()` For logging, println the object reference currently atop the stack
`void`	`argsCat()` Pass two stack elements, converting the first to an array, to the "argsCat" utility method.
`void`	`argsCatToArguments()`
`void`	`argsCatToArguments19()`
`void`	`argsPush()` Pass two stack elements, the first an array, to the "argsPush" utility method.
`void`	`aryToAry()`
`void`	`assignClassVariable(String name)`
`void`	`assignClassVariable(String name, CompilerCallback value)`
`void`	`assignConstantInCurrent(String name, CompilerCallback value)` Assign a constant on the class or module currently in scope.
`void`	`assignConstantInModule(String name, CompilerCallback valueAndModule)` Assign a constant on a specific class or module.
`void`	`assignConstantInObject(String name, CompilerCallback value)` Assign a constant on the Object class.
`void`	`assignGlobalVariable(String name)` Assign the top of the stack to the global variable with the specified name.
`void`	`assignGlobalVariable(String name, CompilerCallback value)` Assign the top of the stack to the global variable with the specified name.
`void`	`assignInstanceVariable(String name)` Assign the value on top of the stack to the instance variable with the specified name on the current "self".
`void`	`assignInstanceVariable(String name, CompilerCallback value)` Assign the value on top of the stack to the instance variable with the specified name on the current "self".
`void`	`asString()`
`void`	`attached()`
`void`	`backref()` Push the current back reference
`void`	`backrefMethod(String methodName)` Call a static helper method on RubyRegexp with the current backref
`void`	`beginChainedMethod()`
`abstract void`	`beginMethod(CompilerCallback args, StaticScope scope)`
`void`	`buildNewString(ArrayCallback callback, int count, org.jcodings.Encoding encoding)` Build a string using the given callback.
`void`	`callZSuper(CompilerCallback closure)`
`BodyCompiler`	`chainToMethod(String methodName)`
`void`	`checkIsExceptionHandled(ArgumentsCallback rescueArgs)`
`void`	`checkWhenWithSplat()`
`void`	`clearErrorInfo()`
`void`	`compileSequencedConditional(CompilerCallback inputValue, FastSwitchType fastSwitchType, Map<CompilerCallback,int[]> switchCases, List<ArgumentsCallback> conditionals, List<CompilerCallback> bodies, CompilerCallback fallback, boolean outline)` Compile a "sequenced conditional", known as a case/when in Ruby or a switch in Java.
`void`	`concatArrays()`
`void`	`concatObjectArrays()`
`void`	`consumeCurrentValue()` As code executes, values are assumed to be "generated", often by being pushed on to some execution stack.
`void`	`convertToJavaArray()`
`void`	`createDRegexp19(ArrayCallback arrayCallback, Object[] sourceArray, int options)`
`void`	`createEmptyArray()` Create an empty Ruby array
`void`	`createEmptyHash()` Create an empty Ruby Hash object and put a reference on top of the stack.
`void`	`createNewArray(boolean lightweight)` Given an aggregated set of objects (likely created through a call to createObjectArray) create a Ruby array object.
`void`	`createNewArray(Object[] sourceArray, ArrayCallback callback, boolean lightweight)` Construct a Ruby array given an array of objects to feed to an ArrayCallback to construct the elements of the array.
`void`	`createNewBignum(BigInteger value)` Generate a new "Bignum" value.
`void`	`createNewClosure(String file, int line, StaticScope scope, int arity, CompilerCallback body, CompilerCallback args, boolean hasMultipleArgsHead, NodeType argsNodeId, ASTInspector inspector)` Create a new closure (block) using the given lexical scope information, call arity, and body generated by the body callback.
`void`	`createNewClosure19(String file, int line, StaticScope scope, int arity, CompilerCallback body, CompilerCallback args, boolean hasMultipleArgsHead, NodeType argsNodeId, String parameterList, ASTInspector inspector)` Create a new closure (block) using the given lexical scope information, call arity, and body generated by the body callback.
`void`	`createNewEndBlock(CompilerCallback body)`
`void`	`createNewFixnum(long value)` Generate a new "Fixnum" value.
`void`	`createNewFloat(double value)` Generate a new "Float" value.
`void`	`createNewForLoop(int arity, CompilerCallback body, CompilerCallback args, boolean hasMultipleArgsHead, NodeType argsNodeId, ASTInspector inspector)` Create a new closure (block) for a for loop with the given call arity and body generated by the body callback.
`void`	`createNewHash(Object elements, ArrayCallback callback, int keyCount)` Create a new hash by calling back to the specified ArrayCallback.
`void`	`createNewHash19(Object elements, ArrayCallback callback, int keyCount)` Create new hash running in ruby 1.9 compat version.
`void`	`createNewLambda(CompilerCallback closure)` Create a new literal lambda.
`void`	`createNewLiteralArray(Object[] sourceArray, ArrayCallback callback, boolean lightweight)` Construct a Ruby array given an array of objects to feed to an ArrayCallback to construct the elements of the array.
`void`	`createNewLiteralHash(Object elements, ArrayCallback callback, int keyCount)` Create a new hash by calling back to the specified ArrayCallback.
`void`	`createNewRange(CompilerCallback beginEndCallback, boolean isExclusive)` Create a new range.
`void`	`createNewRegexp(org.jruby.util.ByteList value, int options)`
`void`	`createNewRegexp(CompilerCallback createStringCallback, int options)`
`void`	`createNewString(ArrayCallback callback, int count, org.jcodings.Encoding encoding)` Generate a new dynamic "String" value.
`void`	`createNewString(org.jruby.util.ByteList value, int codeRange)` Generate a new "String" value.
`void`	`createNewSymbol(ArrayCallback callback, int count, org.jcodings.Encoding encoding)`
`void`	`createNewSymbol(String name, org.jcodings.Encoding encoding)` Generate a new "Symbol" value (or fetch the existing one).
`void`	`createObjectArray(Object[] sourceArray, ArrayCallback callback)`
`protected abstract void`	`createVariableCompiler()`
`void`	`declareClassVariable(String name)`
`void`	`declareClassVariable(String name, CompilerCallback value)`
`void`	`defineAlias(CompilerCallback args)` Define an alias for a new name to an existing oldName'd method.
`void`	`defineClass(String name, StaticScope staticScope, CompilerCallback superCallback, CompilerCallback pathCallback, CompilerCallback bodyCallback, CompilerCallback receiverCallback, ASTInspector inspector, ISourcePosition startPosition)`
`void`	`definedCall(String name)` Check defined?() for a Call
`void`	`definedNot()` Check defined?() for a Not.
`void`	`defineModule(String name, StaticScope staticScope, CompilerCallback pathCallback, CompilerCallback bodyCallback, ASTInspector inspector, ISourcePosition startPosition)`
`void`	`defineNewMethod(String name, int methodArity, StaticScope scope, CompilerCallback body, CompilerCallback args, CompilerCallback receiver, ASTInspector inspector, boolean root, String filename, int line, String parameterDesc)` Define a new method with the given name, arity, local variable count, and body callback.
`void`	`duplicateCurrentValue()` Push a copy the topmost value on the stack.
`abstract void`	`endBody()` End compilation for the method associated with the specified token.
`void`	`ensureMultipleAssignableRubyArray(boolean masgnHasHead)` Ensures that the present value is an IRubyObject[] by wrapping it with one or coercing it if it is not.
`void`	`ensureRubyArray()` Ensures that the present value is an IRubyObject[] by wrapping it with one if it is not.
`void`	`forEachInValueArray(int start, int count, Object source, ArrayCallback callback, CompilerCallback argsCallback)` Given an IRubyObject[] on the stack (or otherwise available as the present object) call back to the provided ArrayCallback 'callback' for 'count' elements, starting with 'start'.
`void`	`forEachInValueArray(int start, int preCount, Object preSource, int postCount, Object postSource, ArrayCallback callback, CompilerCallback argsCallback)` Given an IRubyObject[] on the stack (or otherwise available as the present object) call back to the provided ArrayCallback 'callback' for 'count' elements, starting with 'start'.
`protected int`	`getActualArgsCount(StaticScope scope)`
`protected int`	`getClosureIndex()`
`void`	`getCompiledClass()`
`protected int`	`getDynamicScopeIndex()`
`protected int`	`getExceptionIndex()`
`protected int`	`getFirstTempIndex()`
`void`	`getFrameKlazz()`
`void`	`getFrameName()`
`void`	`getInstanceVariable(String name)`
`InvocationCompiler`	`getInvocationCompiler()`
`int`	`getLastLine()`
`String`	`getNativeMethodName()`
`Object`	`getNewEnding()`
`protected String`	`getNewEnsureName()`
`protected String`	`getNewRescueName()`
`protected int`	`getPreviousExceptionIndex()`
`String`	`getRubyName()`
`int`	`getScopeIndex()`
`StandardASMCompiler`	`getScriptCompiler()`
`protected abstract String`	`getSignature()`
`VariableCompiler`	`getVariableCompiler()`
`protected int`	`getVarsArrayIndex()`
`void`	`getVisibilityFor(String name)`
`void`	`go(Object gotoToken)`
`void`	`hasBlock(BranchCallback trueBranch, BranchCallback falseBranch)`
`void`	`ifNotNull(Object gotoToken)`
`void`	`ifNotSuperMethodBound(Object token)`
`void`	`ifNull(Object gotoToken)`
`void`	`ifSingleton(Object gotoToken)`
`void`	`invokeIRubyObject(String methodName, String signature)`
`void`	`invokeRuby(String methodName, String signature)`
`void`	`invokeThreadContext(String methodName, String signature)`
`void`	`invokeUtilityMethod(String methodName, String signature)` This is for utility methods used by the compiler, to reduce the amount of code generation necessary.
`void`	`isCaptured(int number, BranchCallback trueBranch, BranchCallback falseBranch)`
`void`	`isClassVarDefined(String name, BranchCallback trueBranch, BranchCallback falseBranch)`
`void`	`isConstantBranch(BranchCallback setup, String name)`
`void`	`isConstantDefined(String name)`
`void`	`isGlobalDefined(String name, BranchCallback trueBranch, BranchCallback falseBranch)`
`void`	`isInstanceOf(Class clazz, BranchCallback trueBranch, BranchCallback falseBranch)`
`void`	`isInstanceVariableDefined(String name)`
`void`	`isMethodBound(String name, BranchCallback trueBranch, BranchCallback falseBranch)`
`void`	`isNil(BranchCallback trueBranch, BranchCallback falseBranch)`
`void`	`isNotProtected(Object gotoToken, int toConsume)`
`void`	`isNull(BranchCallback trueBranch, BranchCallback falseBranch)`
`void`	`isPrivate(Object gotoToken, int toConsume)`
`void`	`issueLoopBreak()`
`void`	`issueLoopNext()`
`void`	`issueLoopRedo()`
`void`	`issueRetryEvent()`
`void`	`isTrue()` Invoke IRubyObject.isTrue
`void`	`lineNumber(ISourcePosition position)` This method provides a way to specify a line number for the current piece of code being compiled.
`void`	`literal(String value)`
`void`	`literalSwitch(int[] cases, Object[] bodies, ArrayCallback arrayCallback, CompilerCallback defaultCallback)`
`void`	`loadBlock()`
`void`	`loadClass(String name)`
`void`	`loadCurrentModule()`
`void`	`loadEncoding(org.jcodings.Encoding encoding)` Load the specified encoding.
`void`	`loadException()`
`void`	`loadFalse()` Load a Ruby "false" value on top of the stack.
`void`	`loadFilename()`
`void`	`loadNil()` Load a Ruby "nil" value on top of the stack.
`void`	`loadNull()`
`void`	`loadObject()` Load the Object class
`void`	`loadRuntime()`
`void`	`loadSelf()`
`void`	`loadStandardError()`
`protected void`	`loadStaticScope()`
`void`	`loadThis()`
`void`	`loadThreadContext()`
`void`	`loadTrue()` Load a Ruby "true" value on top of the stack.
`void`	`mAssignConstantInCurrent(String name)` Assign a constant on the class or module currently in scope.
`void`	`mAssignConstantInModule(String name)` Assign a constant on a specific class or module.
`void`	`mAssignConstantInObject(String name)` Assign a constant on the Object class.
`void`	`match(boolean is19)`
`void`	`match2(CompilerCallback value, boolean is19)`
`void`	`match2Capture(CompilerCallback value, int[] scopeOffsets, boolean is19)`
`void`	`match3(boolean is19)`
`void`	`metaclass()`
`void`	`negateCurrentValue()` Perform a logical Ruby "not" operation on the value on top of the stack, leaving the negated result.
`void`	`notIsModuleAndClassVarDefined(String name, Object gotoToken)`
`void`	`nthRef(int match)`
`void`	`nullToNil()`
`abstract BaseBodyCompiler`	`outline(String methodName)`
`void`	`performBackref(char type)`
`void`	`performBooleanBranch(BranchCallback trueBranch, BranchCallback falseBranch)` Perform a boolean branch operation based on the Ruby "true" value of the top value on the stack.
`void`	`performBooleanBranch2(BranchCallback trueBranch, BranchCallback falseBranch)` Perform a boolean branch operation based on the boolean top value on the stack.
`void`	`performBooleanConstantBranch(String globalName, BranchCallback trueBranch, BranchCallback falseBranch)` Perform a boolean branch operation based on the boolean constant value on the stack.
`void`	`performBooleanGlobalBranch(String globalName, BranchCallback trueBranch, BranchCallback falseBranch)` Perform a boolean branch operation based on the boolean global value on the stack.
`void`	`performBooleanLoop(BranchCallback condition, BranchCallback body, boolean checkFirst)` Perform a boolean loop using the given condition-calculating branch and body branch.
`void`	`performBooleanLoopLight(BranchCallback condition, BranchCallback body, boolean checkFirst)` Perform a boolean loop using the given condition-calculating branch and body branch.
`void`	`performBooleanLoopSafe(BranchCallback condition, BranchCallback body, boolean checkFirst)` Perform a boolean loop using the given condition-calculating branch and body branch.
`void`	`performEnsure(BranchCallback regularCode, BranchCallback protectedCode)`
`void`	`performLogicalAnd(BranchCallback longBranch)` Perform a logical short-circuited Ruby "and" operation, using Ruby notions of true and false.
`void`	`performLogicalOr(BranchCallback longBranch)` Perform a logical short-circuited Ruby "or" operation, using Ruby notions of true and false.
`void`	`performRescue(BranchCallback regularCode, BranchCallback rubyCatchCode, BranchCallback rubyElseCode, boolean needsRetry)`
`void`	`performRescueInternal(BranchCallback regularCode, BranchCallback rubyCatchCode, BranchCallback rubyElseCode, boolean needsRetry, boolean light)`
`void`	`performRescueLight(BranchCallback regularCode, BranchCallback rubyCatchCode, BranchCallback rubyElseCode, boolean needsRetry)`
`void`	`pollThreadEvents()`
`void`	`preMultiAssign(int head, boolean args)`
`void`	`println()`
`void`	`protect(BranchCallback regularCode, BranchCallback protectedCode, Class ret)` Makes sure that the code in protectedCode will always run after regularCode.
`void`	`pushByteList(org.jruby.util.ByteList byteList)`
`void`	`pushDefinedMessage(DefinedMessage definedMessage)`
`void`	`pushNull()`
`void`	`pushString(String str)`
`void`	`raiseTypeError(String msg)`
`void`	`rescue(BranchCallback regularCode, Class exception, BranchCallback catchCode, Class ret)`
`void`	`rethrowException()`
`void`	`rethrowIfSystemExit()`
`void`	`retrieveClassVariable(String name)`
`void`	`retrieveConstant(String name)` Retrieve the constant with the specified name available at the current point in the program's execution.
`void`	`retrieveConstantFromModule(String name)` Retreive a named constant from the RubyModule/RubyClass that's just been pushed.
`void`	`retrieveConstantFromObject(String name)` Retreive a named constant from the RubyModule/RubyClass that's just been pushed.
`void`	`retrieveGlobalVariable(String name)` Retrieve the global variable with the specified name to the top of the stack.
`void`	`retrieveInstanceVariable(String name)` Retrieve the instance variable with the given name, based on the current "self".
`void`	`retrieveSelf()` Retrieve the current "self" and put a reference on top of the stack.
`void`	`retrieveSelfClass()` Retrieve the current "self" object's metaclass and put a reference on top of the stack
`void`	`reverseValues(int count)` Reverse the top n values on the stack.
`void`	`runBeginBlock(StaticScope scope, CompilerCallback body)`
`void`	`selfIsKindOf(Object gotoToken)`
`void`	`setEnding(Object endingToken)`
`void`	`setLinePosition(ISourcePosition position)`
`void`	`shortcutAppend(boolean is19)` A "shortcut" append that skips conversions to String where possible.
`protected boolean`	`shouldUseBoxedArgs(StaticScope scope)`
`void`	`singlifySplattedValue()` Given a splatted value, extract a single value.
`void`	`singlifySplattedValue19()` 1.9 version of singlifySplattedValue.
`void`	`splatCurrentValue(String methodName)` Convert the current value into a "splatted value" suitable for passing as method arguments or disassembling into multiple variables.
`void`	`splatToArguments()`
`void`	`splatToArguments19()`
`void`	`storeExceptionInErrorInfo()` Store the current live exception object in the $! thread-global.
`void`	`storeNativeExceptionInErrorInfo()` Store the current exception in $!, wrapping in NativeException if necessary.
`void`	`stringOrNil()`
`void`	`stringToSymbol(boolean is19)` Convert a String on stack to a Symbol
`void`	`superClass()`
`void`	`swapValues()` Swap the top and second values on the stack.
`void`	`toJavaString()`
`void`	`traceClass(ISourcePosition position)`
`void`	`traceEnd(int line)`
`void`	`traceLine(ISourcePosition position)`
`void`	`typeCheckBranch(Class type, BranchCallback trueCallback, BranchCallback falseCallback)`
`void`	`undefMethod(CompilerCallback nameArg)`
`void`	`unwrapPassedBlock()`
`void`	`unwrapRaiseException()`
`void`	`wrapJavaException()`
`void`	`wrapJavaObject()`

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

Methods inherited from interface org.jruby.compiler.BodyCompiler
isSimpleRoot, issueBreakEvent, issueNextEvent, issueRedoEvent, performReturn

- Field Detail
  - method
```
protected SkinnyMethodAdapter method
```
  - variableCompiler
```
protected VariableCompiler variableCompiler
```
  - invocationCompiler
```
protected InvocationCompiler invocationCompiler
```
  - argParamCount
```
protected int argParamCount
```
  - currentLoopLabels
```
protected org.objectweb.asm.Label[] currentLoopLabels
```
  - scopeStart
```
protected org.objectweb.asm.Label scopeStart
```
  - scopeEnd
```
protected org.objectweb.asm.Label scopeEnd
```
  - redoJump
```
protected org.objectweb.asm.Label redoJump
```
  - inNestedMethod
```
protected boolean inNestedMethod
```
  - inRescue
```
protected boolean inRescue
```
  - scope
```
protected StaticScope scope
```
  - inspector
```
protected ASTInspector inspector
```
  - methodName
```
protected String methodName
```
  - rubyName
```
protected String rubyName
```
  - script
```
protected StandardASMCompiler script
```
  - scopeIndex
```
protected int scopeIndex
```
- Constructor Detail
  - BaseBodyCompiler
```
public BaseBodyCompiler(StandardASMCompiler scriptCompiler,
                String methodName,
                String rubyName,
                ASTInspector inspector,
                StaticScope scope,
                int scopeIndex)
```
- Method Detail
  - getNativeMethodName
```
public String getNativeMethodName()
```
    Specified by:
    
    getNativeMethodName in interface BodyCompiler
  - getRubyName
```
public String getRubyName()
```
  - shouldUseBoxedArgs
```
protected boolean shouldUseBoxedArgs(StaticScope scope)
```
  - getActualArgsCount
```
protected int getActualArgsCount(StaticScope scope)
```
  - getSignature
```
protected abstract String getSignature()
```
  - createVariableCompiler
```
protected abstract void createVariableCompiler()
```
  - beginMethod
```
public abstract void beginMethod(CompilerCallback args,
               StaticScope scope)
```
  - endBody
```
public abstract void endBody()
```
    Description copied from interface: BodyCompiler
    
    End compilation for the method associated with the specified token. This should close out all structures created for compilation of the method.
    
    Specified by:
    
    endBody in interface BodyCompiler
  - chainToMethod
```
public BodyCompiler chainToMethod(String methodName)
```
    Specified by:
    
    chainToMethod in interface BodyCompiler
  - beginChainedMethod
```
public void beginChainedMethod()
```
  - outline
```
public abstract BaseBodyCompiler outline(String methodName)
```
    Specified by:
    
    outline in interface BodyCompiler
  - getScriptCompiler
```
public StandardASMCompiler getScriptCompiler()
```
  - lineNumber
```
public void lineNumber(ISourcePosition position)
```
    Description copied from interface: BodyCompiler
    
    This method provides a way to specify a line number for the current piece of code being compiled. The compiler may use this information to create debugging information in a bytecode-format-dependent way.
    
    Specified by:
    
    lineNumber in interface BodyCompiler
    
    Parameters:
    position - The ISourcePosition information to use.
  - getLastLine
```
public int getLastLine()
```
  - loadThreadContext
```
public void loadThreadContext()
```
  - loadSelf
```
public void loadSelf()
```
    Specified by:
    
    loadSelf in interface BodyCompiler
  - getClosureIndex
```
protected int getClosureIndex()
```
  - getPreviousExceptionIndex
```
protected int getPreviousExceptionIndex()
```
  - getDynamicScopeIndex
```
protected int getDynamicScopeIndex()
```
  - getVarsArrayIndex
```
protected int getVarsArrayIndex()
```
  - getFirstTempIndex
```
protected int getFirstTempIndex()
```
  - getExceptionIndex
```
protected int getExceptionIndex()
```
  - loadStaticScope
```
protected void loadStaticScope()
```
  - loadThis
```
public void loadThis()
```
  - loadRuntime
```
public void loadRuntime()
```
  - loadBlock
```
public void loadBlock()
```
  - loadNil
```
public void loadNil()
```
    Description copied from interface: BodyCompiler
    
    Load a Ruby "nil" value on top of the stack.
    
    Specified by:
    
    loadNil in interface BodyCompiler
  - loadNull
```
public void loadNull()
```
    Specified by:
    
    loadNull in interface BodyCompiler
  - loadObject
```
public void loadObject()
```
    Description copied from interface: BodyCompiler
    
    Load the Object class
    
    Specified by:
    
    loadObject in interface BodyCompiler
  - invokeUtilityMethod
```
public void invokeUtilityMethod(String methodName,
                       String signature)
```
    This is for utility methods used by the compiler, to reduce the amount of code generation necessary. All of these live in CompilerHelpers.
  - invokeThreadContext
```
public void invokeThreadContext(String methodName,
                       String signature)
```
  - invokeRuby
```
public void invokeRuby(String methodName,
              String signature)
```
  - invokeIRubyObject
```
public void invokeIRubyObject(String methodName,
                     String signature)
```
  - consumeCurrentValue
```
public void consumeCurrentValue()
```
    Description copied from interface: BodyCompiler
    
    As code executes, values are assumed to be "generated", often by being pushed on to some execution stack. Generally, these values are consumed by other methods on the context, but occasionally a value must be "thrown out". This method provides a way to discard the previous value generated by some other call(s).
    
    Specified by:
    
    consumeCurrentValue in interface BodyCompiler
  - duplicateCurrentValue
```
public void duplicateCurrentValue()
```
    Description copied from interface: BodyCompiler
    
    Push a copy the topmost value on the stack.
    
    Specified by:
    
    duplicateCurrentValue in interface BodyCompiler
  - swapValues
```
public void swapValues()
```
    Description copied from interface: BodyCompiler
    
    Swap the top and second values on the stack.
    
    Specified by:
    
    swapValues in interface BodyCompiler
  - reverseValues
```
public void reverseValues(int count)
```
    Description copied from interface: BodyCompiler
    
    Reverse the top n values on the stack.
    
    Specified by:
    
    reverseValues in interface BodyCompiler
    
    Parameters:
    count - The number of values to reverse.
  - retrieveSelf
```
public void retrieveSelf()
```
    Description copied from interface: BodyCompiler
    
    Retrieve the current "self" and put a reference on top of the stack.
    
    Specified by:
    
    retrieveSelf in interface BodyCompiler
  - retrieveSelfClass
```
public void retrieveSelfClass()
```
    Description copied from interface: BodyCompiler
    
    Retrieve the current "self" object's metaclass and put a reference on top of the stack
    
    Specified by:
    
    retrieveSelfClass in interface BodyCompiler
  - getVariableCompiler
```
public VariableCompiler getVariableCompiler()
```
    Specified by:
    
    getVariableCompiler in interface BodyCompiler
  - getInvocationCompiler
```
public InvocationCompiler getInvocationCompiler()
```
    Specified by:
    
    getInvocationCompiler in interface BodyCompiler
  - assignConstantInCurrent
```
public void assignConstantInCurrent(String name,
                           CompilerCallback value)
```
    Description copied from interface: BodyCompiler
    
    Assign a constant on the class or module currently in scope.
    
    Specified by:
    
    assignConstantInCurrent in interface BodyCompiler
    
    Parameters:
    name - name of the constant
    value - callback to load the value
  - assignConstantInModule
```
public void assignConstantInModule(String name,
                          CompilerCallback valueAndModule)
```
    Description copied from interface: BodyCompiler
    
    Assign a constant on a specific class or module.
    
    Specified by:
    
    assignConstantInModule in interface BodyCompiler
    
    Parameters:
    name - name of the constant
    valueAndModule - callback to load the class/module and value
  - assignConstantInObject
```
public void assignConstantInObject(String name,
                          CompilerCallback value)
```
    Description copied from interface: BodyCompiler
    
    Assign a constant on the Object class.
    
    Specified by:
    
    assignConstantInObject in interface BodyCompiler
    
    Parameters:
    name - name of the constant
    value - callback to load the value
  - mAssignConstantInCurrent
```
public void mAssignConstantInCurrent(String name)
```
    Description copied from interface: BodyCompiler
    
    Assign a constant on the class or module currently in scope. The value is expected to be on the top of the stack.
    
    Specified by:
    
    mAssignConstantInCurrent in interface BodyCompiler
    
    Parameters:
    name - name of the constant
  - mAssignConstantInModule
```
public void mAssignConstantInModule(String name)
```
    Description copied from interface: BodyCompiler
    
    Assign a constant on a specific class or module. The class/module and value are expected to be on the top of the stack.
    
    Specified by:
    
    mAssignConstantInModule in interface BodyCompiler
    
    Parameters:
    name - name of the constant
  - mAssignConstantInObject
```
public void mAssignConstantInObject(String name)
```
    Description copied from interface: BodyCompiler
    
    Assign a constant on the Object class. The value is expected to be on the top of the stack.
    
    Specified by:
    
    mAssignConstantInObject in interface BodyCompiler
    
    Parameters:
    name - name of the constant
  - retrieveConstant
```
public void retrieveConstant(String name)
```
    Description copied from interface: BodyCompiler
    
    Retrieve the constant with the specified name available at the current point in the program's execution.
    
    Specified by:
    
    retrieveConstant in interface BodyCompiler
    
    Parameters:
    name - The name of the constant
  - retrieveConstantFromModule
```
public void retrieveConstantFromModule(String name)
```
    Description copied from interface: BodyCompiler
    
    Retreive a named constant from the RubyModule/RubyClass that's just been pushed.
    
    Specified by:
    
    retrieveConstantFromModule in interface BodyCompiler
    
    Parameters:
    name - The name of the constant
  - retrieveConstantFromObject
```
public void retrieveConstantFromObject(String name)
```
    Description copied from interface: BodyCompiler
    
    Retreive a named constant from the RubyModule/RubyClass that's just been pushed.
    
    Specified by:
    
    retrieveConstantFromObject in interface BodyCompiler
    
    Parameters:
    name - The name of the constant
  - retrieveClassVariable
```
public void retrieveClassVariable(String name)
```
    Specified by:
    
    retrieveClassVariable in interface BodyCompiler
  - assignClassVariable
```
public void assignClassVariable(String name)
```
    Specified by:
    
    assignClassVariable in interface BodyCompiler
  - assignClassVariable
```
public void assignClassVariable(String name,
                       CompilerCallback value)
```
    Specified by:
    
    assignClassVariable in interface BodyCompiler
  - declareClassVariable
```
public void declareClassVariable(String name)
```
    Specified by:
    
    declareClassVariable in interface BodyCompiler
  - declareClassVariable
```
public void declareClassVariable(String name,
                        CompilerCallback value)
```
    Specified by:
    
    declareClassVariable in interface BodyCompiler
  - createNewFloat
```
public void createNewFloat(double value)
```
    Description copied from interface: BodyCompiler
    
    Generate a new "Float" value.
    
    Specified by:
    
    createNewFloat in interface BodyCompiler
  - createNewFixnum
```
public void createNewFixnum(long value)
```
    Description copied from interface: BodyCompiler
    
    Generate a new "Fixnum" value.
    
    Specified by:
    
    createNewFixnum in interface BodyCompiler
  - createNewBignum
```
public void createNewBignum(BigInteger value)
```
    Description copied from interface: BodyCompiler
    
    Generate a new "Bignum" value.
    
    Specified by:
    
    createNewBignum in interface BodyCompiler
  - createNewString
```
public void createNewString(ArrayCallback callback,
                   int count,
                   org.jcodings.Encoding encoding)
```
    Description copied from interface: BodyCompiler
    
    Generate a new dynamic "String" value.
    
    Specified by:
    
    createNewString in interface BodyCompiler
  - buildNewString
```
public void buildNewString(ArrayCallback callback,
                  int count,
                  org.jcodings.Encoding encoding)
```
    Description copied from interface: BodyCompiler
    
    Build a string using the given callback. A String will be create at the start, and each iteration is expected to leave a String on the stack.
    
    Specified by:
    
    buildNewString in interface BodyCompiler
  - appendByteList
```
public void appendByteList(org.jruby.util.ByteList value,
                  int codeRange,
                  boolean is19)
```
    Description copied from interface: BodyCompiler
    
    Append the given bytelist + coderange to the string currently on the stack.
    
    Specified by:
    
    appendByteList in interface BodyCompiler
  - appendObject
```
public void appendObject(boolean is19)
```
    Description copied from interface: BodyCompiler
    
    Append the object on stack to the string below it.
    
    Specified by:
    
    appendObject in interface BodyCompiler
  - shortcutAppend
```
public void shortcutAppend(boolean is19)
```
    Description copied from interface: BodyCompiler
    
    A "shortcut" append that skips conversions to String where possible. Same stack requirements as appendObject.
    
    Specified by:
    
    shortcutAppend in interface BodyCompiler
  - stringToSymbol
```
public void stringToSymbol(boolean is19)
```
    Description copied from interface: BodyCompiler
    
    Convert a String on stack to a Symbol
    
    Specified by:
    
    stringToSymbol in interface BodyCompiler
  - createNewSymbol
```
public void createNewSymbol(ArrayCallback callback,
                   int count,
                   org.jcodings.Encoding encoding)
```
    Specified by:
    
    createNewSymbol in interface BodyCompiler
  - createNewString
```
public void createNewString(org.jruby.util.ByteList value,
                   int codeRange)
```
    Description copied from interface: BodyCompiler
    
    Generate a new "String" value.
    
    Specified by:
    
    createNewString in interface BodyCompiler
  - createNewSymbol
```
public void createNewSymbol(String name,
                   org.jcodings.Encoding encoding)
```
    Description copied from interface: BodyCompiler
    
    Generate a new "Symbol" value (or fetch the existing one).
    
    Specified by:
    
    createNewSymbol in interface BodyCompiler
  - createNewArray
```
public void createNewArray(boolean lightweight)
```
    Description copied from interface: BodyCompiler
    
    Given an aggregated set of objects (likely created through a call to createObjectArray) create a Ruby array object.
    
    Specified by:
    
    createNewArray in interface BodyCompiler
  - createNewArray
```
public void createNewArray(Object[] sourceArray,
                  ArrayCallback callback,
                  boolean lightweight)
```
    Description copied from interface: BodyCompiler
    
    Construct a Ruby array given an array of objects to feed to an ArrayCallback to construct the elements of the array.
    
    Specified by:
    
    createNewArray in interface BodyCompiler
    
    Parameters:
    sourceArray - The objects that will be used to construct elements
    callback - The callback to which to pass the objects
    lightweight - Whether the array should be lightweight
  - createNewLiteralArray
```
public void createNewLiteralArray(Object[] sourceArray,
                         ArrayCallback callback,
                         boolean lightweight)
```
    Description copied from interface: BodyCompiler
    
    Construct a Ruby array given an array of objects to feed to an ArrayCallback to construct the elements of the array. All the elements are guaranteed to be literals, so the contents can safely be chunked if too large.
    
    Specified by:
    
    createNewLiteralArray in interface BodyCompiler
    
    Parameters:
    sourceArray - The objects that will be used to construct elements
    callback - The callback to which to pass the objects
    lightweight - Whether the array should be lightweight
  - createEmptyArray
```
public void createEmptyArray()
```
    Description copied from interface: BodyCompiler
    
    Create an empty Ruby array
    
    Specified by:
    
    createEmptyArray in interface BodyCompiler
  - createObjectArray
```
public void createObjectArray(Object[] sourceArray,
                     ArrayCallback callback)
```
    Specified by:
    
    createObjectArray in interface BodyCompiler
  - createEmptyHash
```
public void createEmptyHash()
```
    Description copied from interface: BodyCompiler
    
    Create an empty Ruby Hash object and put a reference on top of the stack.
    
    Specified by:
    
    createEmptyHash in interface BodyCompiler
  - createNewHash
```
public void createNewHash(Object elements,
                 ArrayCallback callback,
                 int keyCount)
```
    Description copied from interface: BodyCompiler
    
    Create a new hash by calling back to the specified ArrayCallback. It is expected that the keyCount will be the actual count of key/value pairs, and the caller will handle passing an appropriate elements collection in and dealing with the sequential indices passed to the callback.
    
    Specified by:
    
    createNewHash in interface BodyCompiler
    
    Parameters:
    elements - An object holding the elements from which to create the Hash.
    callback - An ArrayCallback implementation to which the elements array and iteration counts are passed in sequence.
    keyCount - the total count of key-value pairs to be constructed from the elements collection.
  - createNewLiteralHash
```
public void createNewLiteralHash(Object elements,
                        ArrayCallback callback,
                        int keyCount)
```
    Description copied from interface: BodyCompiler
    
    Create a new hash by calling back to the specified ArrayCallback. It is expected that the keyCount will be the actual count of key/value pairs, and the caller will handle passing an appropriate elements collection in and dealing with the sequential indices passed to the callback. This version expects that all elements will be literals, and will break up the hash construction if it is too large.
    
    Specified by:
    
    createNewLiteralHash in interface BodyCompiler
    
    Parameters:
    elements - An object holding the elements from which to create the Hash.
    callback - An ArrayCallback implementation to which the elements array and iteration counts are passed in sequence.
    keyCount - the total count of key-value pairs to be constructed from the elements collection.
  - createNewHash19
```
public void createNewHash19(Object elements,
                   ArrayCallback callback,
                   int keyCount)
```
    Description copied from interface: BodyCompiler
    
    Create new hash running in ruby 1.9 compat version.
    
    Specified by:
    
    createNewHash19 in interface BodyCompiler
  - createNewRange
```
public void createNewRange(CompilerCallback beginEndCallback,
                  boolean isExclusive)
```
    Description copied from interface: BodyCompiler
    
    Create a new range. It is expected that the stack will contain the end and begin values for the range as its topmost and second topmost elements.
    
    Specified by:
    
    createNewRange in interface BodyCompiler
    
    isExclusive - Whether the range is exclusive or not (inclusive)
  - createNewLambda
```
public void createNewLambda(CompilerCallback closure)
```
    Description copied from interface: BodyCompiler
    
    Create a new literal lambda. The stack should contain a reference to the closure object.
    
    Specified by:
    
    createNewLambda in interface BodyCompiler
  - isTrue
```
public void isTrue()
```
    Invoke IRubyObject.isTrue
    
    Specified by:
    
    isTrue in interface BodyCompiler
  - performBooleanBranch
```
public void performBooleanBranch(BranchCallback trueBranch,
                        BranchCallback falseBranch)
```
    Description copied from interface: BodyCompiler
    
    Perform a boolean branch operation based on the Ruby "true" value of the top value on the stack. If Ruby "true", invoke the true branch callback. Otherwise, invoke the false branch callback.
    
    Specified by:
    
    performBooleanBranch in interface BodyCompiler
    
    Parameters:
    trueBranch - The callback for generating code for the "true" condition
    falseBranch - The callback for generating code for the "false" condition
  - performBooleanBranch2
```
public void performBooleanBranch2(BranchCallback trueBranch,
                         BranchCallback falseBranch)
```
    Description copied from interface: BodyCompiler
    
    Perform a boolean branch operation based on the boolean top value on the stack. If true, invoke the true branch callback. Otherwise, invoke the false branch callback.
    
    Specified by:
    
    performBooleanBranch2 in interface BodyCompiler
    
    Parameters:
    trueBranch - The callback for generating code for the "true" condition
    falseBranch - The callback for generating code for the "false" condition
  - performBooleanGlobalBranch
```
public void performBooleanGlobalBranch(String globalName,
                              BranchCallback trueBranch,
                              BranchCallback falseBranch)
```
    Description copied from interface: BodyCompiler
    
    Perform a boolean branch operation based on the boolean global value on the stack. If true, invoke the true branch callback. Otherwise, invoke the false branch callback.
    
    Specified by:
    
    performBooleanGlobalBranch in interface BodyCompiler
    
    trueBranch - The callback for generating code for the "true" condition
    falseBranch - The callback for generating code for the "false" condition
  - performBooleanConstantBranch
```
public void performBooleanConstantBranch(String globalName,
                                BranchCallback trueBranch,
                                BranchCallback falseBranch)
```
    Description copied from interface: BodyCompiler
    
    Perform a boolean branch operation based on the boolean constant value on the stack. If true, invoke the true branch callback. Otherwise, invoke the false branch callback.
    
    Specified by:
    
    performBooleanConstantBranch in interface BodyCompiler
    
    trueBranch - The callback for generating code for the "true" condition
    falseBranch - The callback for generating code for the "false" condition
  - performLogicalAnd
```
public void performLogicalAnd(BranchCallback longBranch)
```
    Description copied from interface: BodyCompiler
    
    Perform a logical short-circuited Ruby "and" operation, using Ruby notions of true and false. If the value on top of the stack is false, it remains and the branch is not executed. If it is true, the top of the stack is replaced with the result of the branch.
    
    Specified by:
    
    performLogicalAnd in interface BodyCompiler
    
    Parameters:
    longBranch - The branch to execute if the "and" operation does not short-circuit.
  - performLogicalOr
```
public void performLogicalOr(BranchCallback longBranch)
```
    Description copied from interface: BodyCompiler
    
    Perform a logical short-circuited Ruby "or" operation, using Ruby notions of true and false. If the value on top of the stack is true, it remains and the branch is not executed. If it is false, the top of the stack is replaced with the result of the branch.
    
    Specified by:
    
    performLogicalOr in interface BodyCompiler
    
    Parameters:
    longBranch - The branch to execute if the "or" operation does not short-circuit.
  - performBooleanLoopSafe
```
public void performBooleanLoopSafe(BranchCallback condition,
                          BranchCallback body,
                          boolean checkFirst)
```
    Description copied from interface: BodyCompiler
    
    Perform a boolean loop using the given condition-calculating branch and body branch. For while loops, pass true for checkFirst. For statement-modifier while loops, pass false. For unless loops, reverse the result of the condition after calculating it. This version ensures the stack is maintained so while results can be used in any context.
    
    Specified by:
    
    performBooleanLoopSafe in interface BodyCompiler
    
    Parameters:
    condition - The code to execute for calculating the loop condition. A Ruby true result will cause the body to be executed again.
    body - The body to executed for the loop.
    checkFirst - whether to check the condition the first time through or not.
  - performBooleanLoop
```
public void performBooleanLoop(BranchCallback condition,
                      BranchCallback body,
                      boolean checkFirst)
```
    Description copied from interface: BodyCompiler
    
    Perform a boolean loop using the given condition-calculating branch and body branch. For while loops, pass true for checkFirst. For statement-modifier while loops, pass false. For unless loops, reverse the result of the condition after calculating it.
    
    Specified by:
    
    performBooleanLoop in interface BodyCompiler
    
    Parameters:
    condition - The code to execute for calculating the loop condition. A Ruby true result will cause the body to be executed again.
    body - The body to executed for the loop.
    checkFirst - whether to check the condition the first time through or not.
  - performBooleanLoopLight
```
public void performBooleanLoopLight(BranchCallback condition,
                           BranchCallback body,
                           boolean checkFirst)
```
    Description copied from interface: BodyCompiler
    
    Perform a boolean loop using the given condition-calculating branch and body branch. For while loops, pass true for checkFirst. For statement-modifier while loops, pass false. For unless loops, reverse the result of the condition after calculating it. This version does not handle non-local flow control which can bubble out of eval or closures, and only expects normal flow control to be used within its body.
    
    Specified by:
    
    performBooleanLoopLight in interface BodyCompiler
    
    Parameters:
    condition - The code to execute for calculating the loop condition. A Ruby true result will cause the body to be executed again.
    body - The body to executed for the loop.
    checkFirst - whether to check the condition the first time through or not.
  - createNewClosure
```
public void createNewClosure(String file,
                    int line,
                    StaticScope scope,
                    int arity,
                    CompilerCallback body,
                    CompilerCallback args,
                    boolean hasMultipleArgsHead,
                    NodeType argsNodeId,
                    ASTInspector inspector)
```
    Description copied from interface: BodyCompiler
    
    Create a new closure (block) using the given lexical scope information, call arity, and body generated by the body callback. The closure will capture containing scopes and related information.
    
    Specified by:
    
    createNewClosure in interface BodyCompiler
  - createNewClosure19
```
public void createNewClosure19(String file,
                      int line,
                      StaticScope scope,
                      int arity,
                      CompilerCallback body,
                      CompilerCallback args,
                      boolean hasMultipleArgsHead,
                      NodeType argsNodeId,
                      String parameterList,
                      ASTInspector inspector)
```
    Description copied from interface: BodyCompiler
    
    Create a new closure (block) using the given lexical scope information, call arity, and body generated by the body callback. The closure will capture containing scopes and related information.
    
    Specified by:
    
    createNewClosure19 in interface BodyCompiler
  - runBeginBlock
```
public void runBeginBlock(StaticScope scope,
                 CompilerCallback body)
```
    Specified by:
    
    runBeginBlock in interface BodyCompiler
  - createNewForLoop
```
public void createNewForLoop(int arity,
                    CompilerCallback body,
                    CompilerCallback args,
                    boolean hasMultipleArgsHead,
                    NodeType argsNodeId,
                    ASTInspector inspector)
```
    Description copied from interface: BodyCompiler
    
    Create a new closure (block) for a for loop with the given call arity and body generated by the body callback.
    
    Specified by:
    
    createNewForLoop in interface BodyCompiler
  - createNewEndBlock
```
public void createNewEndBlock(CompilerCallback body)
```
    Specified by:
    
    createNewEndBlock in interface BodyCompiler
  - getCompiledClass
```
public void getCompiledClass()
```
  - println
```
public void println()
```
  - defineAlias
```
public void defineAlias(CompilerCallback args)
```
    Description copied from interface: BodyCompiler
    
    Define an alias for a new name to an existing oldName'd method.
    
    Specified by:
    
    defineAlias in interface BodyCompiler
  - literal
```
public void literal(String value)
```
    Specified by:
    
    literal in interface BodyCompiler
  - loadFalse
```
public void loadFalse()
```
    Description copied from interface: BodyCompiler
    
    Load a Ruby "false" value on top of the stack.
    
    Specified by:
    
    loadFalse in interface BodyCompiler
  - loadTrue
```
public void loadTrue()
```
    Description copied from interface: BodyCompiler
    
    Load a Ruby "true" value on top of the stack.
    
    Specified by:
    
    loadTrue in interface BodyCompiler
  - loadCurrentModule
```
public void loadCurrentModule()
```
    Specified by:
    
    loadCurrentModule in interface BodyCompiler
  - retrieveInstanceVariable
```
public void retrieveInstanceVariable(String name)
```
    Description copied from interface: BodyCompiler
    
    Retrieve the instance variable with the given name, based on the current "self".
    
    Specified by:
    
    retrieveInstanceVariable in interface BodyCompiler
    
    Parameters:
    name - The name of the instance variable to retrieve.
  - assignInstanceVariable
```
public void assignInstanceVariable(String name)
```
    Description copied from interface: BodyCompiler
    
    Assign the value on top of the stack to the instance variable with the specified name on the current "self". The value is consumed.
    
    Specified by:
    
    assignInstanceVariable in interface BodyCompiler
    
    Parameters:
    name - The name of the value to assign.
  - assignInstanceVariable
```
public void assignInstanceVariable(String name,
                          CompilerCallback value)
```
    Description copied from interface: BodyCompiler
    
    Assign the value on top of the stack to the instance variable with the specified name on the current "self". The value is consumed.
    
    Specified by:
    
    assignInstanceVariable in interface BodyCompiler
    
    Parameters:
    name - The name of the value to assign.
    value - A callback for compiling the value to assign
  - retrieveGlobalVariable
```
public void retrieveGlobalVariable(String name)
```
    Description copied from interface: BodyCompiler
    
    Retrieve the global variable with the specified name to the top of the stack.
    
    Specified by:
    
    retrieveGlobalVariable in interface BodyCompiler
    
    Parameters:
    name - The name of the global variable.
  - assignGlobalVariable
```
public void assignGlobalVariable(String name)
```
    Description copied from interface: BodyCompiler
    
    Assign the top of the stack to the global variable with the specified name.
    
    Specified by:
    
    assignGlobalVariable in interface BodyCompiler
    
    Parameters:
    name - The name of the global variable.
  - assignGlobalVariable
```
public void assignGlobalVariable(String name,
                        CompilerCallback value)
```
    Description copied from interface: BodyCompiler
    
    Assign the top of the stack to the global variable with the specified name.
    
    Specified by:
    
    assignGlobalVariable in interface BodyCompiler
    
    Parameters:
    name - The name of the global variable.
    value - The callback to compile the value to assign
  - negateCurrentValue
```
public void negateCurrentValue()
```
    Description copied from interface: BodyCompiler
    
    Perform a logical Ruby "not" operation on the value on top of the stack, leaving the negated result.
    
    Specified by:
    
    negateCurrentValue in interface BodyCompiler
  - splatCurrentValue
```
public void splatCurrentValue(String methodName)
```
    Description copied from interface: BodyCompiler
    
    Convert the current value into a "splatted value" suitable for passing as method arguments or disassembling into multiple variables.
    
    Specified by:
    
    splatCurrentValue in interface BodyCompiler
  - singlifySplattedValue
```
public void singlifySplattedValue()
```
    Description copied from interface: BodyCompiler
    
    Given a splatted value, extract a single value. If no splat or length is zero, use nil
    
    Specified by:
    
    singlifySplattedValue in interface BodyCompiler
  - singlifySplattedValue19
```
public void singlifySplattedValue19()
```
    Description copied from interface: BodyCompiler
    
    1.9 version of singlifySplattedValue.
    
    Specified by:
    
    singlifySplattedValue19 in interface BodyCompiler
  - aryToAry
```
public void aryToAry()
```
    Specified by:
    
    aryToAry in interface BodyCompiler
  - ensureRubyArray
```
public void ensureRubyArray()
```
    Description copied from interface: BodyCompiler
    
    Ensures that the present value is an IRubyObject[] by wrapping it with one if it is not.
    
    Specified by:
    
    ensureRubyArray in interface BodyCompiler
  - ensureMultipleAssignableRubyArray
```
public void ensureMultipleAssignableRubyArray(boolean masgnHasHead)
```
    Description copied from interface: BodyCompiler
    
    Ensures that the present value is an IRubyObject[] by wrapping it with one or coercing it if it is not.
    
    Specified by:
    
    ensureMultipleAssignableRubyArray in interface BodyCompiler
  - forEachInValueArray
```
public void forEachInValueArray(int start,
                       int count,
                       Object source,
                       ArrayCallback callback,
                       CompilerCallback argsCallback)
```
    Description copied from interface: BodyCompiler
    
    Given an IRubyObject[] on the stack (or otherwise available as the present object) call back to the provided ArrayCallback 'callback' for 'count' elements, starting with 'start'. Each call to callback will have a value from the input array on the stack; once the items are exhausted, the code in nilCallback will be invoked *with no value on the stack*.
    
    Specified by:
    
    forEachInValueArray in interface BodyCompiler
  - forEachInValueArray
```
public void forEachInValueArray(int start,
                       int preCount,
                       Object preSource,
                       int postCount,
                       Object postSource,
                       ArrayCallback callback,
                       CompilerCallback argsCallback)
```
    Description copied from interface: BodyCompiler
    
    Given an IRubyObject[] on the stack (or otherwise available as the present object) call back to the provided ArrayCallback 'callback' for 'count' elements, starting with 'start'. Each call to callback will have a value from the input array on the stack; once the items are exhausted, the code in nilCallback will be invoked *with no value on the stack*.
    
    Specified by:
    
    forEachInValueArray in interface BodyCompiler
  - asString
```
public void asString()
```
    Specified by:
    
    asString in interface BodyCompiler
  - toJavaString
```
public void toJavaString()
```
    Specified by:
    
    toJavaString in interface BodyCompiler
  - nthRef
```
public void nthRef(int match)
```
    Specified by:
    
    nthRef in interface BodyCompiler
  - match
```
public void match(boolean is19)
```
    Specified by:
    
    match in interface BodyCompiler
  - match2
```
public void match2(CompilerCallback value,
          boolean is19)
```
    Specified by:
    
    match2 in interface BodyCompiler
  - match2Capture
```
public void match2Capture(CompilerCallback value,
                 int[] scopeOffsets,
                 boolean is19)
```
    Specified by:
    
    match2Capture in interface BodyCompiler
  - match3
```
public void match3(boolean is19)
```
    Specified by:
    
    match3 in interface BodyCompiler
  - createNewRegexp
```
public void createNewRegexp(org.jruby.util.ByteList value,
                   int options)
```
    Specified by:
    
    createNewRegexp in interface BodyCompiler
  - createNewRegexp
```
public void createNewRegexp(CompilerCallback createStringCallback,
                   int options)
```
    Specified by:
    
    createNewRegexp in interface BodyCompiler
  - createDRegexp19
```
public void createDRegexp19(ArrayCallback arrayCallback,
                   Object[] sourceArray,
                   int options)
```
    Specified by:
    
    createDRegexp19 in interface BodyCompiler
  - pollThreadEvents
```
public void pollThreadEvents()
```
    Specified by:
    
    pollThreadEvents in interface BodyCompiler
  - nullToNil
```
public void nullToNil()
```
    Specified by:
    
    nullToNil in interface BodyCompiler
  - isInstanceOf
```
public void isInstanceOf(Class clazz,
                BranchCallback trueBranch,
                BranchCallback falseBranch)
```
    Specified by:
    
    isInstanceOf in interface BodyCompiler
  - isCaptured
```
public void isCaptured(int number,
              BranchCallback trueBranch,
              BranchCallback falseBranch)
```
    Specified by:
    
    isCaptured in interface BodyCompiler
  - backref
```
public void backref()
```
    Description copied from interface: BodyCompiler
    
    Push the current back reference
    
    Specified by:
    
    backref in interface BodyCompiler
  - backrefMethod
```
public void backrefMethod(String methodName)
```
    Description copied from interface: BodyCompiler
    
    Call a static helper method on RubyRegexp with the current backref
    
    Specified by:
    
    backrefMethod in interface BodyCompiler
  - issueLoopBreak
```
public void issueLoopBreak()
```
  - issueLoopNext
```
public void issueLoopNext()
```
  - issueLoopRedo
```
public void issueLoopRedo()
```
  - getNewEnsureName
```
protected String getNewEnsureName()
```
  - protect
```
public void protect(BranchCallback regularCode,
           BranchCallback protectedCode,
           Class ret)
```
    Description copied from interface: BodyCompiler
    
    Makes sure that the code in protectedCode will always run after regularCode.
    
    Specified by:
    
    protect in interface BodyCompiler
  - performEnsure
```
public void performEnsure(BranchCallback regularCode,
                 BranchCallback protectedCode)
```
    Specified by:
    
    performEnsure in interface BodyCompiler
  - getNewRescueName
```
protected String getNewRescueName()
```
  - storeExceptionInErrorInfo
```
public void storeExceptionInErrorInfo()
```
    Description copied from interface: BodyCompiler
    
    Store the current live exception object in the $! thread-global.
    
    Specified by:
    
    storeExceptionInErrorInfo in interface BodyCompiler
  - storeNativeExceptionInErrorInfo
```
public void storeNativeExceptionInErrorInfo()
```
    Description copied from interface: BodyCompiler
    
    Store the current exception in $!, wrapping in NativeException if necessary.
    
    Specified by:
    
    storeNativeExceptionInErrorInfo in interface BodyCompiler
  - clearErrorInfo
```
public void clearErrorInfo()
```
    Specified by:
    
    clearErrorInfo in interface BodyCompiler
  - rescue
```
public void rescue(BranchCallback regularCode,
          Class exception,
          BranchCallback catchCode,
          Class ret)
```
    Specified by:
    
    rescue in interface BodyCompiler
  - performRescue
```
public void performRescue(BranchCallback regularCode,
                 BranchCallback rubyCatchCode,
                 BranchCallback rubyElseCode,
                 boolean needsRetry)
```
    Specified by:
    
    performRescue in interface BodyCompiler
  - performRescueLight
```
public void performRescueLight(BranchCallback regularCode,
                      BranchCallback rubyCatchCode,
                      BranchCallback rubyElseCode,
                      boolean needsRetry)
```
    Specified by:
    
    performRescueLight in interface BodyCompiler
  - performRescueInternal
```
public void performRescueInternal(BranchCallback regularCode,
                         BranchCallback rubyCatchCode,
                         BranchCallback rubyElseCode,
                         boolean needsRetry,
                         boolean light)
```
  - wrapJavaException
```
public void wrapJavaException()
```
    Specified by:
    
    wrapJavaException in interface BodyCompiler
  - wrapJavaObject
```
public void wrapJavaObject()
```
  - stringOrNil
```
public void stringOrNil()
```
    Specified by:
    
    stringOrNil in interface BodyCompiler
  - pushNull
```
public void pushNull()
```
    Specified by:
    
    pushNull in interface BodyCompiler
  - pushString
```
public void pushString(String str)
```
    Specified by:
    
    pushString in interface BodyCompiler
  - pushByteList
```
public void pushByteList(org.jruby.util.ByteList byteList)
```
    Specified by:
    
    pushByteList in interface BodyCompiler
  - pushDefinedMessage
```
public void pushDefinedMessage(DefinedMessage definedMessage)
```
    Specified by:
    
    pushDefinedMessage in interface BodyCompiler
  - isMethodBound
```
public void isMethodBound(String name,
                 BranchCallback trueBranch,
                 BranchCallback falseBranch)
```
    Specified by:
    
    isMethodBound in interface BodyCompiler
  - hasBlock
```
public void hasBlock(BranchCallback trueBranch,
            BranchCallback falseBranch)
```
    Specified by:
    
    hasBlock in interface BodyCompiler
  - isGlobalDefined
```
public void isGlobalDefined(String name,
                   BranchCallback trueBranch,
                   BranchCallback falseBranch)
```
    Specified by:
    
    isGlobalDefined in interface BodyCompiler
  - isConstantDefined
```
public void isConstantDefined(String name)
```
    Specified by:
    
    isConstantDefined in interface BodyCompiler
  - isInstanceVariableDefined
```
public void isInstanceVariableDefined(String name)
```
    Specified by:
    
    isInstanceVariableDefined in interface BodyCompiler
  - isClassVarDefined
```
public void isClassVarDefined(String name,
                     BranchCallback trueBranch,
                     BranchCallback falseBranch)
```
    Specified by:
    
    isClassVarDefined in interface BodyCompiler
  - getNewEnding
```
public Object getNewEnding()
```
    Specified by:
    
    getNewEnding in interface BodyCompiler
  - isNil
```
public void isNil(BranchCallback trueBranch,
         BranchCallback falseBranch)
```
    Specified by:
    
    isNil in interface BodyCompiler
  - isNull
```
public void isNull(BranchCallback trueBranch,
          BranchCallback falseBranch)
```
    Specified by:
    
    isNull in interface BodyCompiler
  - ifNull
```
public void ifNull(Object gotoToken)
```
    Specified by:
    
    ifNull in interface BodyCompiler
  - ifNotNull
```
public void ifNotNull(Object gotoToken)
```
    Specified by:
    
    ifNotNull in interface BodyCompiler
  - setEnding
```
public void setEnding(Object endingToken)
```
    Specified by:
    
    setEnding in interface BodyCompiler
  - go
```
public void go(Object gotoToken)
```
    Specified by:
    
    go in interface BodyCompiler
  - isConstantBranch
```
public void isConstantBranch(BranchCallback setup,
                    String name)
```
    Specified by:
    
    isConstantBranch in interface BodyCompiler
  - metaclass
```
public void metaclass()
```
    Specified by:
    
    metaclass in interface BodyCompiler
  - aprintln
```
public void aprintln()
```
    Description copied from interface: BodyCompiler
    
    For logging, println the object reference currently atop the stack
    
    Specified by:
    
    aprintln in interface BodyCompiler
  - getVisibilityFor
```
public void getVisibilityFor(String name)
```
    Specified by:
    
    getVisibilityFor in interface BodyCompiler
  - isPrivate
```
public void isPrivate(Object gotoToken,
             int toConsume)
```
    Specified by:
    
    isPrivate in interface BodyCompiler
  - isNotProtected
```
public void isNotProtected(Object gotoToken,
                  int toConsume)
```
    Specified by:
    
    isNotProtected in interface BodyCompiler
  - selfIsKindOf
```
public void selfIsKindOf(Object gotoToken)
```
    Specified by:
    
    selfIsKindOf in interface BodyCompiler
  - notIsModuleAndClassVarDefined
```
public void notIsModuleAndClassVarDefined(String name,
                                 Object gotoToken)
```
    Specified by:
    
    notIsModuleAndClassVarDefined in interface BodyCompiler
  - ifSingleton
```
public void ifSingleton(Object gotoToken)
```
    Specified by:
    
    ifSingleton in interface BodyCompiler
  - getInstanceVariable
```
public void getInstanceVariable(String name)
```
    Specified by:
    
    getInstanceVariable in interface BodyCompiler
  - getFrameName
```
public void getFrameName()
```
    Specified by:
    
    getFrameName in interface BodyCompiler
  - getFrameKlazz
```
public void getFrameKlazz()
```
    Specified by:
    
    getFrameKlazz in interface BodyCompiler
  - superClass
```
public void superClass()
```
    Specified by:
    
    superClass in interface BodyCompiler
  - attached
```
public void attached()
```
    Specified by:
    
    attached in interface BodyCompiler
  - ifNotSuperMethodBound
```
public void ifNotSuperMethodBound(Object token)
```
    Specified by:
    
    ifNotSuperMethodBound in interface BodyCompiler
  - concatArrays
```
public void concatArrays()
```
    Specified by:
    
    concatArrays in interface BodyCompiler
  - concatObjectArrays
```
public void concatObjectArrays()
```
  - appendToArray
```
public void appendToArray()
```
    Specified by:
    
    appendToArray in interface BodyCompiler
  - appendToObjectArray
```
public void appendToObjectArray()
```
    Specified by:
    
    appendToObjectArray in interface BodyCompiler
  - splatToArguments
```
public void splatToArguments()
```
    Specified by:
    
    splatToArguments in interface BodyCompiler
  - splatToArguments19
```
public void splatToArguments19()
```
    Specified by:
    
    splatToArguments19 in interface BodyCompiler
  - argsCatToArguments
```
public void argsCatToArguments()
```
    Specified by:
    
    argsCatToArguments in interface BodyCompiler
  - argsCatToArguments19
```
public void argsCatToArguments19()
```
    Specified by:
    
    argsCatToArguments19 in interface BodyCompiler
  - convertToJavaArray
```
public void convertToJavaArray()
```
    Specified by:
    
    convertToJavaArray in interface BodyCompiler
  - aliasGlobal
```
public void aliasGlobal(String newName,
               String oldName)
```
    Specified by:
    
    aliasGlobal in interface BodyCompiler
  - raiseTypeError
```
public void raiseTypeError(String msg)
```
    Specified by:
    
    raiseTypeError in interface BodyCompiler
  - undefMethod
```
public void undefMethod(CompilerCallback nameArg)
```
    Specified by:
    
    undefMethod in interface BodyCompiler
  - defineClass
```
public void defineClass(String name,
               StaticScope staticScope,
               CompilerCallback superCallback,
               CompilerCallback pathCallback,
               CompilerCallback bodyCallback,
               CompilerCallback receiverCallback,
               ASTInspector inspector,
               ISourcePosition startPosition)
```
    Specified by:
    
    defineClass in interface BodyCompiler
  - defineModule
```
public void defineModule(String name,
                StaticScope staticScope,
                CompilerCallback pathCallback,
                CompilerCallback bodyCallback,
                ASTInspector inspector,
                ISourcePosition startPosition)
```
    Specified by:
    
    defineModule in interface BodyCompiler
  - unwrapPassedBlock
```
public void unwrapPassedBlock()
```
    Specified by:
    
    unwrapPassedBlock in interface BodyCompiler
  - performBackref
```
public void performBackref(char type)
```
    Specified by:
    
    performBackref in interface BodyCompiler
  - callZSuper
```
public void callZSuper(CompilerCallback closure)
```
    Specified by:
    
    callZSuper in interface BodyCompiler
  - checkIsExceptionHandled
```
public void checkIsExceptionHandled(ArgumentsCallback rescueArgs)
```
    Specified by:
    
    checkIsExceptionHandled in interface BodyCompiler
  - rethrowException
```
public void rethrowException()
```
    Specified by:
    
    rethrowException in interface BodyCompiler
  - loadClass
```
public void loadClass(String name)
```
    Specified by:
    
    loadClass in interface BodyCompiler
  - loadStandardError
```
public void loadStandardError()
```
    Specified by:
    
    loadStandardError in interface BodyCompiler
  - unwrapRaiseException
```
public void unwrapRaiseException()
```
    Specified by:
    
    unwrapRaiseException in interface BodyCompiler
  - loadException
```
public void loadException()
```
    Specified by:
    
    loadException in interface BodyCompiler
  - setLinePosition
```
public void setLinePosition(ISourcePosition position)
```
    Specified by:
    
    setLinePosition in interface BodyCompiler
  - checkWhenWithSplat
```
public void checkWhenWithSplat()
```
    Specified by:
    
    checkWhenWithSplat in interface BodyCompiler
  - issueRetryEvent
```
public void issueRetryEvent()
```
    Specified by:
    
    issueRetryEvent in interface BodyCompiler
  - defineNewMethod
```
public void defineNewMethod(String name,
                   int methodArity,
                   StaticScope scope,
                   CompilerCallback body,
                   CompilerCallback args,
                   CompilerCallback receiver,
                   ASTInspector inspector,
                   boolean root,
                   String filename,
                   int line,
                   String parameterDesc)
```
    Description copied from interface: BodyCompiler
    
    Define a new method with the given name, arity, local variable count, and body callback. This will create a new compiled method and bind it to the given name at this point in the program's execution.
    
    Specified by:
    
    defineNewMethod in interface BodyCompiler
  - rethrowIfSystemExit
```
public void rethrowIfSystemExit()
```
    Specified by:
    
    rethrowIfSystemExit in interface BodyCompiler
  - literalSwitch
```
public void literalSwitch(int[] cases,
                 Object[] bodies,
                 ArrayCallback arrayCallback,
                 CompilerCallback defaultCallback)
```
    Specified by:
    
    literalSwitch in interface BodyCompiler
  - typeCheckBranch
```
public void typeCheckBranch(Class type,
                   BranchCallback trueCallback,
                   BranchCallback falseCallback)
```
    Specified by:
    
    typeCheckBranch in interface BodyCompiler
  - loadFilename
```
public void loadFilename()
```
    Specified by:
    
    loadFilename in interface BodyCompiler
  - compileSequencedConditional
```
public void compileSequencedConditional(CompilerCallback inputValue,
                               FastSwitchType fastSwitchType,
                               Map<CompilerCallback,int[]> switchCases,
                               List<ArgumentsCallback> conditionals,
                               List<CompilerCallback> bodies,
                               CompilerCallback fallback,
                               boolean outline)
```
    Description copied from interface: BodyCompiler
    
    Compile a "sequenced conditional", known as a case/when in Ruby or a switch in Java.
    
    Specified by:
    
    compileSequencedConditional in interface BodyCompiler
    
    Parameters:
    inputValue - callback to create the case/switch value
    fastSwitchType - type of fast-switching to use, if any
    switchCases - callbacks and array of Java case values for fast switching
    conditionals - callbacks for eqq switching
    bodies - case bodies
    fallback - else body
    outline - whether the case bodies should be generated into their own JVM methods
  - traceLine
```
public void traceLine(ISourcePosition position)
```
    Specified by:
    
    traceLine in interface BodyCompiler
  - traceClass
```
public void traceClass(ISourcePosition position)
```
    Specified by:
    
    traceClass in interface BodyCompiler
  - traceEnd
```
public void traceEnd(int line)
```
    Specified by:
    
    traceEnd in interface BodyCompiler
  - preMultiAssign
```
public void preMultiAssign(int head,
                  boolean args)
```
    Specified by:
    
    preMultiAssign in interface BodyCompiler
  - argsPush
```
public void argsPush()
```
    Description copied from interface: BodyCompiler
    
    Pass two stack elements, the first an array, to the "argsPush" utility method.
    
    Specified by:
    
    argsPush in interface BodyCompiler
  - argsCat
```
public void argsCat()
```
    Description copied from interface: BodyCompiler
    
    Pass two stack elements, converting the first to an array, to the "argsCat" utility method.
    
    Specified by:
    
    argsCat in interface BodyCompiler
  - loadEncoding
```
public void loadEncoding(org.jcodings.Encoding encoding)
```
    Description copied from interface: BodyCompiler
    
    Load the specified encoding.
    
    Specified by:
    
    loadEncoding in interface BodyCompiler
  - definedCall
```
public void definedCall(String name)
```
    Description copied from interface: BodyCompiler
    
    Check defined?() for a Call
    
    Specified by:
    
    definedCall in interface BodyCompiler
  - definedNot
```
public void definedNot()
```
    Description copied from interface: BodyCompiler
    
    Check defined?() for a Not. Under 1.9, returns "method" if the contained logic evaluates ok.
    
    Specified by:
    
    definedNot in interface BodyCompiler
  - getScopeIndex
```
public int getScopeIndex()
```

Class BaseBodyCompiler

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.jruby.compiler.BodyCompiler

Field Detail

method

variableCompiler

invocationCompiler

argParamCount

currentLoopLabels

scopeStart

scopeEnd

redoJump

inNestedMethod

inRescue

scope

inspector

methodName

rubyName

script

scopeIndex

Constructor Detail

BaseBodyCompiler

Method Detail

getNativeMethodName

getRubyName

shouldUseBoxedArgs

getActualArgsCount

getSignature

createVariableCompiler

beginMethod

endBody

chainToMethod

beginChainedMethod

outline

getScriptCompiler

lineNumber

getLastLine

loadThreadContext

loadSelf

getClosureIndex

getPreviousExceptionIndex

getDynamicScopeIndex

getVarsArrayIndex

getFirstTempIndex

getExceptionIndex

loadStaticScope

loadThis

loadRuntime

loadBlock

loadNil

loadNull

loadObject

invokeUtilityMethod

invokeThreadContext

invokeRuby

invokeIRubyObject

consumeCurrentValue

duplicateCurrentValue

swapValues

reverseValues

retrieveSelf

retrieveSelfClass

getVariableCompiler

getInvocationCompiler

assignConstantInCurrent

assignConstantInModule

assignConstantInObject

mAssignConstantInCurrent

mAssignConstantInModule

mAssignConstantInObject

retrieveConstant

retrieveConstantFromModule

retrieveConstantFromObject

retrieveClassVariable

assignClassVariable

assignClassVariable

declareClassVariable