org.jruby.compiler

Interface BodyCompiler

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