BodyCompiler (JRuby Core 1.7.26 API)

All Known Implementing Classes:

BaseBodyCompiler, ChainedChildBodyCompiler, ChainedChildBodyCompiler19, ChainedRootBodyCompiler, ChildScopedBodyCompiler, ChildScopedBodyCompiler19, ClassBodyCompiler, MethodBodyCompiler, RootScopedBodyCompiler
```
public interface BodyCompiler
```
Author:

headius

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 moduleAndValue)` 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`	`buildNewString(ArrayCallback callback, int count, org.jcodings.Encoding encoding)` Build a string using the given callback.
`void`	`callZSuper(CompilerCallback closure)`
`BodyCompiler`	`chainToMethod(String name)`
`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`	`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 beginEndCalback, 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[] elementArray, ArrayCallback callback)`
`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.
`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 count, int start, 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 count, int preSize, Object preSource, int postSize, 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'.
`void`	`getFrameKlazz()`
`void`	`getFrameName()`
`void`	`getInstanceVariable(String name)`
`InvocationCompiler`	`getInvocationCompiler()`
`String`	`getNativeMethodName()`
`Object`	`getNewEnding()`
`VariableCompiler`	`getVariableCompiler()`
`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`	`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)`
`boolean`	`isSimpleRoot()` Return true if this method compiled is a "simple" root compiler, i.e.
`void`	`issueBreakEvent(CompilerCallback value)`
`void`	`issueNextEvent(CompilerCallback value)`
`void`	`issueRedoEvent()`
`void`	`issueRetryEvent()`
`void`	`isTrue()` Convert the top IRubyObject value on the stack to a primitive boolean using 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[] caseInts, Object[] caseBodies, ArrayCallback casesCallback, CompilerCallback defaultCallback)`
`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`	`loadSelf()`
`void`	`loadStandardError()`
`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()`
`BodyCompiler`	`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 ensuredCode)`
`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`	`performRescueLight(BranchCallback regularCode, BranchCallback rubyCatchCode, BranchCallback rubyElseCode, boolean needsRetry)`
`void`	`performReturn()` Return the current value on the top of the stack, taking into consideration surrounding blocks.
`void`	`pollThreadEvents()`
`void`	`preMultiAssign(int head, boolean args)`
`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 bl)`
`void`	`pushDefinedMessage(DefinedMessage definedMessage)`
`void`	`pushNull()`
`void`	`pushString(String strVal)`
`void`	`raiseTypeError(String string)`
`void`	`rescue(BranchCallback regularCode, Class exception, BranchCallback protectedCode, 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 n)` 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.
`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()`

- Method Detail
  - endBody
```
void endBody()
```
    End compilation for the method associated with the specified token. This should close out all structures created for compilation of the method.
    
    Parameters:
    token - A token identifying the method to be terminated.
  - consumeCurrentValue
```
void consumeCurrentValue()
```
    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).
  - duplicateCurrentValue
```
void duplicateCurrentValue()
```
    Push a copy the topmost value on the stack.
  - aprintln
```
void aprintln()
```
    For logging, println the object reference currently atop the stack
  - swapValues
```
void swapValues()
```
    Swap the top and second values on the stack.
  - reverseValues
```
void reverseValues(int n)
```
    Reverse the top n values on the stack.
    
    Parameters:
    n - The number of values to reverse.
  - lineNumber
```
void lineNumber(ISourcePosition position)
```
    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.
    
    Parameters:
    position - The ISourcePosition information to use.
  - getVariableCompiler
```
VariableCompiler getVariableCompiler()
```
  - getInvocationCompiler
```
InvocationCompiler getInvocationCompiler()
```
  - retrieveSelf
```
void retrieveSelf()
```
    Retrieve the current "self" and put a reference on top of the stack.
  - retrieveSelfClass
```
void retrieveSelfClass()
```
    Retrieve the current "self" object's metaclass and put a reference on top of the stack
  - retrieveClassVariable
```
void retrieveClassVariable(String name)
```
  - assignClassVariable
```
void assignClassVariable(String name)
```
  - assignClassVariable
```
void assignClassVariable(String name,
                       CompilerCallback value)
```
  - declareClassVariable
```
void declareClassVariable(String name)
```
  - declareClassVariable
```
void declareClassVariable(String name,
                        CompilerCallback value)
```
  - createNewFixnum
```
void createNewFixnum(long value)
```
    Generate a new "Fixnum" value.
  - createNewFloat
```
void createNewFloat(double value)
```
    Generate a new "Float" value.
  - createNewBignum
```
void createNewBignum(BigInteger value)
```
    Generate a new "Bignum" value.
  - createNewString
```
void createNewString(org.jruby.util.ByteList value,
                   int codeRange)
```
    Generate a new "String" value.
  - createNewString
```
void createNewString(ArrayCallback callback,
                   int count,
                   org.jcodings.Encoding encoding)
```
    Generate a new dynamic "String" value.
  - createNewSymbol
```
void createNewSymbol(ArrayCallback callback,
                   int count,
                   org.jcodings.Encoding encoding)
```
  - buildNewString
```
void buildNewString(ArrayCallback callback,
                  int count,
                  org.jcodings.Encoding encoding)
```
    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.
  - appendByteList
```
void appendByteList(org.jruby.util.ByteList value,
                  int codeRange,
                  boolean is19)
```
    Append the given bytelist + coderange to the string currently on the stack.
  - appendObject
```
void appendObject(boolean is19)
```
    Append the object on stack to the string below it.
  - shortcutAppend
```
void shortcutAppend(boolean is19)
```
    A "shortcut" append that skips conversions to String where possible. Same stack requirements as appendObject.
  - stringToSymbol
```
void stringToSymbol(boolean is19)
```
    Convert a String on stack to a Symbol
  - createNewSymbol
```
void createNewSymbol(String name,
                   org.jcodings.Encoding encoding)
```
    Generate a new "Symbol" value (or fetch the existing one).
  - createObjectArray
```
void createObjectArray(Object[] elementArray,
                     ArrayCallback callback)
```
  - createNewArray
```
void createNewArray(boolean lightweight)
```
    Given an aggregated set of objects (likely created through a call to createObjectArray) create a Ruby array object.
  - createNewArray
```
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.
    
    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
```
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. All the elements are guaranteed to be literals, so the contents can safely be chunked if too large.
    
    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
```
void createEmptyArray()
```
    Create an empty Ruby array
  - createEmptyHash
```
void createEmptyHash()
```
    Create an empty Ruby Hash object and put a reference on top of the stack.
  - createNewHash
```
void createNewHash(Object elements,
                 ArrayCallback callback,
                 int keyCount)
```
    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.
    
    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
```
void createNewLiteralHash(Object elements,
                        ArrayCallback callback,
                        int keyCount)
```
    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.
    
    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
```
void createNewHash19(Object elements,
                   ArrayCallback callback,
                   int keyCount)
```
    Create new hash running in ruby 1.9 compat version.
  - createNewRange
```
void createNewRange(CompilerCallback beginEndCalback,
                  boolean isExclusive)
```
    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.
    
    Parameters:
    isExclusive - Whether the range is exclusive or not (inclusive)
  - createNewLambda
```
void createNewLambda(CompilerCallback closure)
```
    Create a new literal lambda. The stack should contain a reference to the closure object.
  - performBooleanBranch
```
void performBooleanBranch(BranchCallback trueBranch,
                        BranchCallback falseBranch)
```
    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.
    
    Parameters:
    trueBranch - The callback for generating code for the "true" condition
    falseBranch - The callback for generating code for the "false" condition
  - performBooleanBranch2
```
void performBooleanBranch2(BranchCallback trueBranch,
                         BranchCallback falseBranch)
```
    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.
    
    Parameters:
    trueBranch - The callback for generating code for the "true" condition
    falseBranch - The callback for generating code for the "false" condition
  - performBooleanGlobalBranch
```
void performBooleanGlobalBranch(String globalName,
                              BranchCallback trueBranch,
                              BranchCallback falseBranch)
```
    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.
    
    Parameters:
    trueBranch - The callback for generating code for the "true" condition
    falseBranch - The callback for generating code for the "false" condition
  - performBooleanConstantBranch
```
void performBooleanConstantBranch(String globalName,
                                BranchCallback trueBranch,
                                BranchCallback falseBranch)
```
    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.
    
    Parameters:
    trueBranch - The callback for generating code for the "true" condition
    falseBranch - The callback for generating code for the "false" condition
  - performLogicalAnd
```
void performLogicalAnd(BranchCallback longBranch)
```
    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.
    
    Parameters:
    longBranch - The branch to execute if the "and" operation does not short-circuit.
  - performLogicalOr
```
void performLogicalOr(BranchCallback longBranch)
```
    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.
    
    Parameters:
    longBranch - The branch to execute if the "or" operation does not short-circuit.
  - performBooleanLoopSafe
```
void performBooleanLoopSafe(BranchCallback condition,
                          BranchCallback body,
                          boolean checkFirst)
```
    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.
    
    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
```
void performBooleanLoop(BranchCallback condition,
                      BranchCallback body,
                      boolean checkFirst)
```
    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.
    
    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
```
void performBooleanLoopLight(BranchCallback condition,
                           BranchCallback body,
                           boolean checkFirst)
```
    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.
    
    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.
  - performReturn
```
void performReturn()
```
    Return the current value on the top of the stack, taking into consideration surrounding blocks.
  - createNewClosure
```
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. The closure will capture containing scopes and related information.
  - createNewClosure19
```
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. The closure will capture containing scopes and related information.
  - createNewForLoop
```
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.
  - defineNewMethod
```
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. This will create a new compiled method and bind it to the given name at this point in the program's execution.
  - defineAlias
```
void defineAlias(CompilerCallback args)
```
    Define an alias for a new name to an existing oldName'd method.
  - assignConstantInCurrent
```
void assignConstantInCurrent(String name,
                           CompilerCallback value)
```
    Assign a constant on the class or module currently in scope.
    
    Parameters:
    name - name of the constant
    value - callback to load the value
  - assignConstantInModule
```
void assignConstantInModule(String name,
                          CompilerCallback moduleAndValue)
```
    Assign a constant on a specific class or module.
    
    Parameters:
    name - name of the constant
    moduleAndValue - callback to load the class/module and value
  - assignConstantInObject
```
void assignConstantInObject(String name,
                          CompilerCallback value)
```
    Assign a constant on the Object class.
    
    Parameters:
    name - name of the constant
    value - callback to load the value
  - mAssignConstantInCurrent
```
void mAssignConstantInCurrent(String name)
```
    Assign a constant on the class or module currently in scope. The value is expected to be on the top of the stack.
    
    Parameters:
    name - name of the constant
  - mAssignConstantInModule
```
void mAssignConstantInModule(String name)
```
    Assign a constant on a specific class or module. The class/module and value are expected to be on the top of the stack.
    
    Parameters:
    name - name of the constant
  - mAssignConstantInObject
```
void mAssignConstantInObject(String name)
```
    Assign a constant on the Object class. The value is expected to be on the top of the stack.
    
    Parameters:
    name - name of the constant
  - retrieveConstant
```
void retrieveConstant(String name)
```
    Retrieve the constant with the specified name available at the current point in the program's execution.
    
    Parameters:
    name - The name of the constant
  - retrieveConstantFromModule
```
void retrieveConstantFromModule(String name)
```
    Retreive a named constant from the RubyModule/RubyClass that's just been pushed.
    
    Parameters:
    name - The name of the constant
  - retrieveConstantFromObject
```
void retrieveConstantFromObject(String name)
```
    Retreive a named constant from the RubyModule/RubyClass that's just been pushed.
    
    Parameters:
    name - The name of the constant
  - loadFalse
```
void loadFalse()
```
    Load a Ruby "false" value on top of the stack.
  - loadTrue
```
void loadTrue()
```
    Load a Ruby "true" value on top of the stack.
  - loadNil
```
void loadNil()
```
    Load a Ruby "nil" value on top of the stack.
  - loadNull
```
void loadNull()
```
  - loadObject
```
void loadObject()
```
    Load the Object class
  - retrieveInstanceVariable
```
void retrieveInstanceVariable(String name)
```
    Retrieve the instance variable with the given name, based on the current "self".
    
    Parameters:
    name - The name of the instance variable to retrieve.
  - assignInstanceVariable
```
void assignInstanceVariable(String name)
```
    Assign the value on top of the stack to the instance variable with the specified name on the current "self". The value is consumed.
    
    Parameters:
    name - The name of the value to assign.
  - assignInstanceVariable
```
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". The value is consumed.
    
    Parameters:
    name - The name of the value to assign.
    value - A callback for compiling the value to assign
  - assignGlobalVariable
```
void assignGlobalVariable(String name)
```
    Assign the top of the stack to the global variable with the specified name.
    
    Parameters:
    name - The name of the global variable.
  - assignGlobalVariable
```
void assignGlobalVariable(String name,
                        CompilerCallback value)
```
    Assign the top of the stack to the global variable with the specified name.
    
    Parameters:
    name - The name of the global variable.
    value - The callback to compile the value to assign
  - retrieveGlobalVariable
```
void retrieveGlobalVariable(String name)
```
    Retrieve the global variable with the specified name to the top of the stack.
    
    Parameters:
    name - The name of the global variable.
  - negateCurrentValue
```
void negateCurrentValue()
```
    Perform a logical Ruby "not" operation on the value on top of the stack, leaving the negated result.
  - splatCurrentValue
```
void splatCurrentValue(String methodName)
```
    Convert the current value into a "splatted value" suitable for passing as method arguments or disassembling into multiple variables.
  - singlifySplattedValue
```
void singlifySplattedValue()
```
    Given a splatted value, extract a single value. If no splat or length is zero, use nil
  - singlifySplattedValue19
```
void singlifySplattedValue19()
```
    1.9 version of singlifySplattedValue.
  - forEachInValueArray
```
void forEachInValueArray(int count,
                       int start,
                       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'. 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*.
  - forEachInValueArray
```
void forEachInValueArray(int count,
                       int preSize,
                       Object preSource,
                       int postSize,
                       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'. 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*.
  - ensureRubyArray
```
void ensureRubyArray()
```
    Ensures that the present value is an IRubyObject[] by wrapping it with one if it is not.
  - ensureMultipleAssignableRubyArray
```
void ensureMultipleAssignableRubyArray(boolean masgnHasHead)
```
    Ensures that the present value is an IRubyObject[] by wrapping it with one or coercing it if it is not.
  - issueBreakEvent
```
void issueBreakEvent(CompilerCallback value)
```
  - issueNextEvent
```
void issueNextEvent(CompilerCallback value)
```
  - issueRedoEvent
```
void issueRedoEvent()
```
  - issueRetryEvent
```
void issueRetryEvent()
```
  - asString
```
void asString()
```
  - nthRef
```
void nthRef(int match)
```
  - match
```
void match(boolean is19)
```
  - match2
```
void match2(CompilerCallback value,
          boolean is19)
```
  - match2Capture
```
void match2Capture(CompilerCallback value,
                 int[] scopeOffsets,
                 boolean is19)
```
  - match3
```
void match3(boolean is19)
```
  - createNewRegexp
```
void createNewRegexp(org.jruby.util.ByteList value,
                   int options)
```
  - createNewRegexp
```
void createNewRegexp(CompilerCallback createStringCallback,
                   int options)
```
  - createDRegexp19
```
void createDRegexp19(ArrayCallback arrayCallback,
                   Object[] sourceArray,
                   int options)
```
  - pollThreadEvents
```
void pollThreadEvents()
```
  - literal
```
void literal(String value)
```
  - backref
```
void backref()
```
    Push the current back reference
  - backrefMethod
```
void backrefMethod(String methodName)
```
    Call a static helper method on RubyRegexp with the current backref
  - nullToNil
```
void nullToNil()
```
  - protect
```
void protect(BranchCallback regularCode,
           BranchCallback protectedCode,
           Class ret)
```
    Makes sure that the code in protectedCode will always run after regularCode.
  - rescue
```
void rescue(BranchCallback regularCode,
          Class exception,
          BranchCallback protectedCode,
          Class ret)
```
  - performRescue
```
void performRescue(BranchCallback regularCode,
                 BranchCallback rubyCatchCode,
                 BranchCallback rubyElseCode,
                 boolean needsRetry)
```
  - performRescueLight
```
void performRescueLight(BranchCallback regularCode,
                      BranchCallback rubyCatchCode,
                      BranchCallback rubyElseCode,
                      boolean needsRetry)
```
  - performEnsure
```
void performEnsure(BranchCallback regularCode,
                 BranchCallback ensuredCode)
```
  - stringOrNil
```
void stringOrNil()
```
  - pushNull
```
void pushNull()
```
  - pushString
```
void pushString(String strVal)
```
  - pushByteList
```
void pushByteList(org.jruby.util.ByteList bl)
```
  - pushDefinedMessage
```
void pushDefinedMessage(DefinedMessage definedMessage)
```
  - isMethodBound
```
void isMethodBound(String name,
                 BranchCallback trueBranch,
                 BranchCallback falseBranch)
```
  - hasBlock
```
void hasBlock(BranchCallback trueBranch,
            BranchCallback falseBranch)
```
  - isGlobalDefined
```
void isGlobalDefined(String name,
                   BranchCallback trueBranch,
                   BranchCallback falseBranch)
```
  - isConstantDefined
```
void isConstantDefined(String name)
```
  - isInstanceVariableDefined
```
void isInstanceVariableDefined(String name)
```
  - isClassVarDefined
```
void isClassVarDefined(String name,
                     BranchCallback trueBranch,
                     BranchCallback falseBranch)
```
  - getNewEnding
```
Object getNewEnding()
```
  - ifNull
```
void ifNull(Object gotoToken)
```
  - isNil
```
void isNil(BranchCallback trueBranch,
         BranchCallback falseBranch)
```
  - isNull
```
void isNull(BranchCallback trueBranch,
          BranchCallback falseBranch)
```
  - ifNotNull
```
void ifNotNull(Object gotoToken)
```
  - setEnding
```
void setEnding(Object endingToken)
```
  - go
```
void go(Object gotoToken)
```
  - isConstantBranch
```
void isConstantBranch(BranchCallback setup,
                    String name)
```
  - metaclass
```
void metaclass()
```
  - getVisibilityFor
```
void getVisibilityFor(String name)
```
  - isPrivate
```
void isPrivate(Object gotoToken,
             int toConsume)
```
  - isNotProtected
```
void isNotProtected(Object gotoToken,
                  int toConsume)
```
  - selfIsKindOf
```
void selfIsKindOf(Object gotoToken)
```
  - loadCurrentModule
```
void loadCurrentModule()
```
  - notIsModuleAndClassVarDefined
```
void notIsModuleAndClassVarDefined(String name,
                                 Object gotoToken)
```
  - loadSelf
```
void loadSelf()
```
  - ifSingleton
```
void ifSingleton(Object gotoToken)
```
  - getInstanceVariable
```
void getInstanceVariable(String name)
```
  - getFrameName
```
void getFrameName()
```
  - getFrameKlazz
```
void getFrameKlazz()
```
  - superClass
```
void superClass()
```
  - attached
```
void attached()
```
  - ifNotSuperMethodBound
```
void ifNotSuperMethodBound(Object token)
```
  - isInstanceOf
```
void isInstanceOf(Class clazz,
                BranchCallback trueBranch,
                BranchCallback falseBranch)
```
  - isCaptured
```
void isCaptured(int number,
              BranchCallback trueBranch,
              BranchCallback falseBranch)
```
  - concatArrays
```
void concatArrays()
```
  - appendToArray
```
void appendToArray()
```
  - argsCatToArguments
```
void argsCatToArguments()
```
  - argsCatToArguments19
```
void argsCatToArguments19()
```
  - splatToArguments
```
void splatToArguments()
```
  - splatToArguments19
```
void splatToArguments19()
```
  - convertToJavaArray
```
void convertToJavaArray()
```
  - aryToAry
```
void aryToAry()
```
  - toJavaString
```
void toJavaString()
```
  - aliasGlobal
```
void aliasGlobal(String newName,
               String oldName)
```
  - undefMethod
```
void undefMethod(CompilerCallback nameArg)
```
  - defineClass
```
void defineClass(String name,
               StaticScope staticScope,
               CompilerCallback superCallback,
               CompilerCallback pathCallback,
               CompilerCallback bodyCallback,
               CompilerCallback receiverCallback,
               ASTInspector inspector,
               ISourcePosition startPosition)
```
  - defineModule
```
void defineModule(String name,
                StaticScope staticScope,
                CompilerCallback pathCallback,
                CompilerCallback bodyCallback,
                ASTInspector inspector,
                ISourcePosition startPosition)
```
  - unwrapPassedBlock
```
void unwrapPassedBlock()
```
  - performBackref
```
void performBackref(char type)
```
  - callZSuper
```
void callZSuper(CompilerCallback closure)
```
  - appendToObjectArray
```
void appendToObjectArray()
```
  - checkIsExceptionHandled
```
void checkIsExceptionHandled(ArgumentsCallback rescueArgs)
```
  - rethrowException
```
void rethrowException()
```
  - loadClass
```
void loadClass(String name)
```
  - loadStandardError
```
void loadStandardError()
```
  - unwrapRaiseException
```
void unwrapRaiseException()
```
  - loadException
```
void loadException()
```
  - setLinePosition
```
void setLinePosition(ISourcePosition position)
```
  - checkWhenWithSplat
```
void checkWhenWithSplat()
```
  - createNewEndBlock
```
void createNewEndBlock(CompilerCallback body)
```
  - runBeginBlock
```
void runBeginBlock(StaticScope scope,
                 CompilerCallback body)
```
  - rethrowIfSystemExit
```
void rethrowIfSystemExit()
```
  - chainToMethod
```
BodyCompiler chainToMethod(String name)
```
  - outline
```
BodyCompiler outline(String methodName)
```
  - wrapJavaException
```
void wrapJavaException()
```
  - literalSwitch
```
void literalSwitch(int[] caseInts,
                 Object[] caseBodies,
                 ArrayCallback casesCallback,
                 CompilerCallback defaultCallback)
```
  - typeCheckBranch
```
void typeCheckBranch(Class type,
                   BranchCallback trueCallback,
                   BranchCallback falseCallback)
```
  - loadFilename
```
void loadFilename()
```
  - storeExceptionInErrorInfo
```
void storeExceptionInErrorInfo()
```
    Store the current live exception object in the $! thread-global.
  - storeNativeExceptionInErrorInfo
```
void storeNativeExceptionInErrorInfo()
```
    Store the current exception in $!, wrapping in NativeException if necessary.
  - clearErrorInfo
```
void clearErrorInfo()
```
  - compileSequencedConditional
```
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.
    
    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
  - raiseTypeError
```
void raiseTypeError(String string)
```
  - traceLine
```
void traceLine(ISourcePosition position)
```
  - traceClass
```
void traceClass(ISourcePosition position)
```
  - traceEnd
```
void traceEnd(int line)
```
  - getNativeMethodName
```
String getNativeMethodName()
```
  - preMultiAssign
```
void preMultiAssign(int head,
                  boolean args)
```
  - isSimpleRoot
```
boolean isSimpleRoot()
```
    Return true if this method compiled is a "simple" root compiler, i.e. not chained and not a block/closure.
    
    Returns:
  - argsPush
```
void argsPush()
```
    Pass two stack elements, the first an array, to the "argsPush" utility method.
  - argsCat
```
void argsCat()
```
    Pass two stack elements, converting the first to an array, to the "argsCat" utility method.
  - loadEncoding
```
void loadEncoding(org.jcodings.Encoding encoding)
```
    Load the specified encoding.
  - definedCall
```
void definedCall(String name)
```
    Check defined?() for a Call
  - definedNot
```
void definedNot()
```
    Check defined?() for a Not. Under 1.9, returns "method" if the contained logic evaluates ok.
  - isTrue
```
void isTrue()
```
    Convert the top IRubyObject value on the stack to a primitive boolean using IRubyObject.isTrue();

Interface BodyCompiler

Method Summary

Method Detail

endBody

consumeCurrentValue

duplicateCurrentValue

aprintln

swapValues

reverseValues

lineNumber

getVariableCompiler

getInvocationCompiler

retrieveSelf

retrieveSelfClass

retrieveClassVariable

assignClassVariable

assignClassVariable

declareClassVariable

declareClassVariable

createNewFixnum

createNewFloat

createNewBignum

createNewString

createNewString

createNewSymbol

buildNewString

appendByteList

appendObject

shortcutAppend

stringToSymbol

createNewSymbol

createObjectArray

createNewArray

createNewArray

createNewLiteralArray

createEmptyArray

createEmptyHash

createNewHash

createNewLiteralHash

createNewHash19

createNewRange

createNewLambda

performBooleanBranch

performBooleanBranch2

performBooleanGlobalBranch

performBooleanConstantBranch

performLogicalAnd

performLogicalOr

performBooleanLoopSafe

performBooleanLoop

performBooleanLoopLight

performReturn

createNewClosure

createNewClosure19

createNewForLoop

defineNewMethod

defineAlias

assignConstantInCurrent

assignConstantInModule

assignConstantInObject

mAssignConstantInCurrent

mAssignConstantInModule

mAssignConstantInObject

retrieveConstant

retrieveConstantFromModule

retrieveConstantFromObject

loadFalse

loadTrue

loadNil

loadNull

loadObject

retrieveInstanceVariable

assignInstanceVariable

assignInstanceVariable

assignGlobalVariable

assignGlobalVariable

retrieveGlobalVariable

negateCurrentValue

splatCurrentValue

singlifySplattedValue