Package org.jruby.ir

Class IRBuilder

java.lang.Object

org.jruby.ir.IRBuilder

public class IRBuilder
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static interface	IRBuilder.CodeBlock
private static class	IRBuilder.EnsureBlockInfo
private static class	IRBuilder.IRLoop
private static class	IRBuilder.RescueBlockInfo
(package private) static interface	IRBuilder.VoidCodeBlock

Field Summary

Fields

Modifier and Type	Field	Description
private final Deque<IRBuilder.EnsureBlockInfo>	activeEnsureBlockStack
private final Deque<IRBuilder.RescueBlockInfo>	activeRescueBlockStack
private final Deque<Label>	activeRescuers
protected int	afterPrologueIndex
protected List<Object>	argumentDescriptions
protected int	coverageMode
private Variable	currentModuleVariable
private final Deque<IRBuilder.EnsureBlockInfo>	ensureBodyBuildStack
private boolean	executesOnce
private EnumSet<IRFlags>	flags
protected final List<Instr>	instructions
private int	lastProcessedLineNum
private final Deque<IRBuilder.IRLoop>	loopStack
protected final IRManager	manager
private RubySymbol	methodName
private boolean	needsLineNumInfo
private boolean	needsYieldBlock
protected final IRBuilder	parent
protected final IRScope	scope
private int	temporaryVariableIndex
(package private) static final UnexecutableNil	U_NIL
boolean	underscoreVariableSeen
protected IRBuilder	variableBuilder
private TemporaryVariable	yieldClosureVariable

Constructor Summary

Constructors

Constructor	Description
IRBuilder(IRManager manager, IRScope scope, IRBuilder parent)
IRBuilder(IRManager manager, IRScope scope, IRBuilder parent, IRBuilder variableBuilder)

Method Summary

Modifier and Type	Method	Description
static Operand[]	addArg(Operand[] args, Operand extraArg)
private void	addArgReceiveInstr(Variable v, int argIndex, Signature signature)
void	addArgumentDescription(ArgumentType type, RubySymbol name)
private void	addCurrentModule()
void	addInstr(Instr instr)
void	addInstrAtBeginning(Instr instr)
private void	addKeyArgDesc(AssignableNode kasgn, RubySymbol key)
private void	addRaiseError(String id, String message)
private Variable	addResultInstr(ResultInstr instr)
private Operand[]	adjustVariableDepth(Operand[] args, int depthFromSuper)
private Variable	argumentResult(RubySymbol name)
Operand	build(Node node)
Operand	build(Variable result, Node node)
Operand	buildAlias(AliasNode alias)
Operand	buildAnd(AndNode andNode)
Operand	buildArgsCat(ArgsCatNode argsCatNode)
void	buildArgsMasgn(Node node, Operand argsArray, boolean isMasgnRoot, int preArgsCount, int postArgsCount, int index, boolean isSplat)
Operand	buildArgsPush(ArgsPushNode node)
Operand	buildArray(ArrayNode node, boolean operandOnly)
void	buildAssignment(Node node, Variable rhsVal)
static Node	buildAST(boolean isCommandLineScript, String arg)
private Operand	buildAttrAssign(Variable result, AttrAssignNode attrAssignNode)
Operand	buildAttrAssignAssignment(Node node, Operand value)
protected Operand	buildAttrAssignCallArgs(List<Operand> argsList, Node args, boolean containsAssignment)
Operand	buildBackref(Variable result, BackRefNode node)
Operand	buildBegin(BeginNode beginNode)
Operand	buildBignum(BignumNode node)
Operand	buildBlock(BlockNode node)
void	buildBlockArgsAssignment(Node node, Operand argsArray, int argIndex, boolean isSplat)
Operand	buildBreak(BreakNode breakNode)
Operand	buildCall(Variable aResult, CallNode callNode, Label lazyLabel, Label endLabel)
protected Operand[]	buildCallArgs(Node args)
protected Operand[]	buildCallArgsExcept(Node args, Node excludeKeywordArg)	build each argument to a call but if we detect what appears to be a literal simple keyword argument signature we will pass that along to be excluded in the build here (we will build it separately).
Operand	buildCase(CaseNode caseNode)
private Operand	buildCaseTestValue(CaseNode caseNode)
Operand	buildClass(ClassNode classNode)	Build a new class and add it to the current scope (s).
Operand	buildClassVar(ClassVarNode node)
Operand	buildClassVarAsgn(ClassVarAsgnNode classVarAsgnNode)
Operand	buildColon2(Colon2Node colon2)
private Operand	buildColon2ForConstAsgnDeclNode(Node lhs, Variable valueResult, boolean constMissing)
Operand	buildColon3(Colon3Node node)
Operand	buildComplex(ComplexNode node)
private Operand	buildConditionalLoop(Node conditionNode, Node bodyNode, boolean isWhile, boolean isLoopHeadCondition)
Operand	buildConstDecl(ConstDeclNode node)
Operand	buildConstDeclAssignment(ConstDeclNode constDeclNode, Operand value)
Operand	buildDAsgn(DAsgnNode dasgnNode)
protected Variable	buildDefinitionCheck(ResultInstr definedInstr, String definedReturnValue)
Operand	buildDefn(MethodDefNode node)
protected Variable	buildDefnCheckIfThenPaths(Label undefLabel, Operand defVal)
Operand	buildDefs(DefsNode node)
Operand	buildDot(DotNode dotNode)
Operand	buildDRegexp(Variable result, DRegexpNode node)
Operand	buildDStr(Variable result, DStrNode node)
Operand	buildDSymbol(Variable result, DSymbolNode node)
Operand	buildDVar(DVarNode node)
Operand	buildDXStr(Variable result, DXStrNode node)
Operand	buildEncoding(EncodingNode node)
Operand	buildEnsureInternal(Node ensureBodyNode, Node ensureNode)
Operand	buildEnsureNode(EnsureNode ensureNode)
InterpreterContext	buildEvalRoot(RootNode rootNode)
Operand	buildFalse()
Operand	buildFCall(Variable aResult, FCallNode fcallNode)
Operand	buildFixnum(FixnumNode node)
private Operand	buildFixnumCase(CaseNode caseNode)
Operand	buildFlip(FlipNode flipNode)
Operand	buildFloat(FloatNode node)
Operand	buildFor(ForNode forNode)
Operand	buildForIter(ForNode forNode)
Operand	buildGetArgumentDefinition(Node node, String type)
Operand	buildGetDefinition(Node node)
Operand	buildGlobalAsgn(GlobalAsgnNode globalAsgnNode)
Operand	buildGlobalVar(Variable result, GlobalVarNode node)
Operand	buildHash(HashNode hashNode)
Operand	buildIf(Variable result, IfNode ifNode)
Operand	buildInstAsgn(InstAsgnNode instAsgnNode)
Operand	buildInstVar(InstVarNode node)
Operand	buildIter(IterNode iterNode)
private InterpreterContext	buildIterInner(RubySymbol methodName, IterNode iterNode)
private List<KeyValuePair<Operand,Operand>>	buildKeywordArguments(HashNode keywordArgs)
Operand	buildLambda(LambdaNode node)
private InterpreterContext	buildLambdaInner(LambdaNode node)
protected Operand	buildLazyWithOrder(CallNode node, Label lazyLabel, Label endLabel, boolean preserveOrder)
Operand	buildLiteral(LiteralNode literalNode)
Operand	buildLocalAsgn(LocalAsgnNode localAsgnNode)
Operand	buildLocalVar(LocalVarNode node)
Operand	buildMatch(Variable result, MatchNode matchNode)
Operand	buildMatch2(Variable result, Match2Node matchNode)
Operand	buildMatch3(Variable result, Match3Node matchNode)
Operand	buildModule(ModuleNode moduleNode)
private InterpreterContext	buildModuleOrClassBody(Node bodyNode, int startLine, int endLine)
Operand	buildMultipleAsgn19(MultipleAsgnNode multipleAsgnNode)
void	buildMultipleAsgn19Assignment(MultipleAsgnNode multipleAsgnNode, Operand argsArray, Operand values)
Operand	buildNext(NextNode nextNode)
Operand	buildNil()
Operand	buildNthRef(NthRefNode nthRefNode)
Operand	buildOpAsgn(OpAsgnNode opAsgnNode)
Operand	buildOpAsgnAnd(OpAsgnAndNode andNode)
Operand	buildOpAsgnConstDeclNode(OpAsgnConstDeclNode node)
Operand	buildOpAsgnOr(OpAsgnOrNode orNode)
Operand	buildOpElementAsgn(OpElementAsgnNode node)
private Operand	buildOpElementAsgnWith(OpElementAsgnNode opElementAsgnNode, Boolean truthy)
Operand	buildOpElementAsgnWithMethod(OpElementAsgnNode opElementAsgnNode)
private Operand	buildOperand(Variable result, Node node)
Operand	buildOr(OrNode orNode)
Operand	buildPostExe(PostExeNode postExeNode)
Operand	buildPreExe(PreExeNode preExeNode)
private List<Instr>	buildPreExeInner(Node body)
private InterpreterContext	buildPrePostExeInner(Node body)
Operand	buildRational(RationalNode rationalNode)
Operand	buildRedo(RedoNode redoNode)
Operand	buildRegexp(RegexpNode reNode)
Operand	buildRescue(RescueNode node)
private void	buildRescueBodyInternal(RescueBodyNode rescueBodyNode, Variable rv, Variable exc, Label endLabel)
private Operand	buildRescueInternal(RescueNode rescueNode, IRBuilder.EnsureBlockInfo ensure)
private Variable	buildRestKeywordArgs(HashNode keywordArgs)
Operand	buildRetry(RetryNode retryNode)
Operand	buildReturn(ReturnNode returnNode)
static InterpreterContext	buildRoot(IRManager manager, RootNode rootNode)
private InterpreterContext	buildRootInner(RootNode rootNode)
Operand	buildSClass(SClassNode sclassNode)
Variable	buildSelf()
Operand	buildSplat(SplatNode splatNode)
Operand	buildStr(StrNode strNode)
Operand	buildStrRaw(StrNode strNode)
Operand	buildSuper(SuperNode superNode)
private Operand	buildSuperInstr(Operand block, Operand[] args)
Operand	buildSValue(SValueNode node)
Operand	buildSymbol(SymbolNode node)
Operand	buildTrue()
Operand	buildUndef(Node node)
Operand	buildUntil(UntilNode untilNode)
Operand	buildVAlias(VAliasNode valiasNode)
Operand	buildVCall(Variable result, VCallNode node)
void	buildVersionSpecificBlockArgsAssignment(Node node)
private void	buildWhenArgs(WhenNode whenNode, Operand testValue, Label bodyLabel, Set<IRubyObject> seenLiterals)
private void	buildWhenSplatValues(Variable eqqResult, Node node, Operand testValue, Label bodyLabel, Set<IRubyObject> seenLiterals)
private void	buildWhenValue(Variable eqqResult, Operand testValue, Label bodyLabel, Node node, Set<IRubyObject> seenLiterals, boolean needsSplat)
private void	buildWhenValues(Variable eqqResult, ListNode exprValues, Operand testValue, Label bodyLabel, Set<IRubyObject> seenLiterals)
Operand	buildWhile(WhileNode whileNode)
protected Operand	buildWithOrder(Node node, boolean preserveOrder)
Operand	buildXStr(XStrNode node)
Operand	buildYield(YieldNode node, Variable result)
Operand	buildZArray(Variable result)
Operand	buildZSuper(ZSuperNode zsuperNode)
private Operand	buildZSuperIfNest(Operand block)
private void	calculateClosureScopeFlags()
private boolean	canBacktraceBeRemoved(RescueNode rescueNode)
Operand	classVarContainer(boolean declContext)
Operand	classVarDeclarationContainer()	Deprecated.
Operand	classVarDefinitionContainer()
private boolean	computeNeedsDynamicScopeFlag()
void	computeScopeFlagsFrom(List<Instr> instructions)
Operand	copy(Operand value)
Operand	copy(Variable result, Operand value)
protected Variable	copyAndReturnValue(Operand val)
static Instr	createBranch(Operand v1, Operand v2, Label jmpTarget)
Variable	createCurrentModuleVariable()
private TemporaryVariable	createTemporaryVariable()
protected InterpreterContext	defineMethodInner(DefNode defNode, IRScope parent, int coverageMode)
private IRMethod	defineNewMethod(MethodDefNode defNode, boolean isInstanceMethod)
private void	determineIfMaybeRefined(RubySymbol methodName, Operand[] args)
private CallInstr	determineIfProcNew(Node receiverNode, CallInstr callInstr)
private void	determineIfWeNeedLineNumber(Node node)
private int	dynamicPiece(Operand[] pieces, int i, Node pieceNode)
private void	emitEnsureBlocks(IRBuilder.IRLoop loop)
private static void	extractCallOperands(List<Operand> callArgs, List<KeyValuePair<Operand,Operand>> keywordArgs, Instr instr)
private Operand	findContainerModule()
protected LocalVariable	getArgVariable(RubySymbol name, int depth)
protected LocalVariable	getBlockArgVariable(RubySymbol name, int depth)
static Operand[]	getCallArgs(IRScope scope, IRBuilder builder)	Extract all call arguments from the specified scope (only useful for Closures and Methods) so that we can convert zsupers to supers with explicit arguments.
private static Operand[]	getCallOperands(IRScope scope, List<Operand> callArgs, List<KeyValuePair<Operand,Operand>> keywordArgs)
private Operand	getContainerFromCPath(Colon3Node cpath)
private IRBuilder.IRLoop	getCurrentLoop()
Variable	getCurrentModuleVariable()
private String	getFileName()
LocalVariable	getLocalVariable(RubySymbol name, int scopeDepth)
RubySymbol	getName()
private Label	getNewLabel()
LocalVariable	getNewLocalVariable(RubySymbol name, int scopeDepth)
private HashNode	getPossibleKeywordArgument(Node argsNode)
protected Variable	getValueInTemporaryVariable(Operand val)
private String	getVarNameFromScopeTree(IRScope scope, int depth, int offset)
private IRubyObject	getWhenLiteral(Node node)
TemporaryVariable	getYieldClosureVariable()	Get the variable for accessing the "yieldable" closure in this scope.
private void	handleBreakAndReturnsInLambdas()
private void	handleNonlocalReturnInMethod()
private boolean	hasListener()
private void	if_else(Operand testVariable, Operand testValue, IRBuilder.VoidCodeBlock ifBlock, IRBuilder.VoidCodeBlock elseBlock)	Generate if testVariable NEQ testValue { ifBlock } else { elseBlock }.
private boolean	isDefineMethod()
private static boolean	isErrorInfoGlobal(String name)
private boolean	isRequiredKeywordArgumentValue(AssignableNode kasgn)
private boolean	literalWhenCheck(Node value, Set<IRubyObject> seenLiterals)
private RubySymbol	methodNameFor()
private boolean	needsCodeCoverage()
IRBuilder	newIRBuilder(IRManager manager, IRScope newScope)
private NotCompilableException	notCompilable(String message, Node node)
private void	outputExceptionCheck(Operand excType, Operand excObj, Label caughtLabel)
private void	preloadBlockImplicitClosure()
private void	prepareClosureImplicitState()	Prepare closure runtime state.
private void	prepareImplicitState()	Prepare implicit runtime state needed for typical methods to execute.
private Operand	processEnsureRescueBlocks(Operand retVal)
private Operand	protectCodeWithRescue(IRBuilder.CodeBlock protectedCode, IRBuilder.CodeBlock rescueBlock)
private Operand	putConstant(Colon2Node node, Operand value)
private Operand	putConstant(Colon3Node node, Operand value)
private Operand	putConstant(RubySymbol name, Operand value)
private Operand	putConstantAssignment(OpAsgnConstDeclNode node, Operand value)
void	receiveArgs(ArgsNode argsNode)	Process all arguments specified for this scope.
protected void	receiveBlockArg(ArgsNode argsNode)	Reify the implicit incoming block into a full Proc, for use as "block arg", but only if a block arg is specified in this scope's arguments.
protected void	receiveBlockArg(Variable v, Operand argsArray, int argIndex, boolean isSplat)
void	receiveBlockArgs(IterNode node)
private void	receiveBreakException(Operand block, CallInstr callInstr)
private Operand	receiveBreakException(Operand block, IRBuilder.CodeBlock codeBlock)
void	receiveMethodArgs(ArgsNode argsNode)
protected void	receiveNonBlockArgs(ArgsNode argsNode)
void	receiveRequiredArg(Node node, int argIndex, Signature signature)
private Operand	searchConst(RubySymbol name)
private Operand	searchModuleForConst(Operand startingModule, RubySymbol name)
Operand[]	setupCallArgs(Node args)
private Operand	setupCallClosure(Node node)
private RubySymbol	symbol(String id)
private RubySymbol	symbol(ByteList bytelist)
private void	throwSyntaxError(Node node, String message)
static IRBuilder	topIRBuilder(IRManager manager, IRScope newScope)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

U_NIL

static final UnexecutableNil U_NIL

activeRescueBlockStack

private final Deque<IRBuilder.RescueBlockInfo> activeRescueBlockStack

activeEnsureBlockStack

private final Deque<IRBuilder.EnsureBlockInfo> activeEnsureBlockStack

ensureBodyBuildStack

private final Deque<IRBuilder.EnsureBlockInfo> ensureBodyBuildStack

activeRescuers

private final Deque<Label> activeRescuers

loopStack

private final Deque<IRBuilder.IRLoop> loopStack

lastProcessedLineNum

private int lastProcessedLineNum

needsLineNumInfo

private boolean needsLineNumInfo

underscoreVariableSeen

public boolean underscoreVariableSeen

parent

protected final IRBuilder parent

variableBuilder

protected IRBuilder variableBuilder

manager

protected final IRManager manager

scope

protected final IRScope scope

instructions

protected final List<Instr> instructions

argumentDescriptions

protected List<Object> argumentDescriptions

coverageMode

protected int coverageMode

executesOnce

private boolean executesOnce

temporaryVariableIndex

private int temporaryVariableIndex

needsYieldBlock

private boolean needsYieldBlock

methodName

private RubySymbol methodName

afterPrologueIndex

protected int afterPrologueIndex

yieldClosureVariable

private TemporaryVariable yieldClosureVariable

currentModuleVariable

private Variable currentModuleVariable

flags

private EnumSet<IRFlags> flags

Constructor Details

IRBuilder

public IRBuilder(IRManager manager,
 IRScope scope,
 IRBuilder parent,
 IRBuilder variableBuilder)

IRBuilder

public IRBuilder(IRManager manager,
 IRScope scope,
 IRBuilder parent)

Method Details

buildAST

public static Node buildAST(boolean isCommandLineScript,
 String arg)

getCurrentLoop

private IRBuilder.IRLoop getCurrentLoop()

needsCodeCoverage

private boolean needsCodeCoverage()

addArgumentDescription

public void addArgumentDescription(ArgumentType type,
 RubySymbol name)

addInstr

public void addInstr(Instr instr)

addInstrAtBeginning

public void addInstrAtBeginning(Instr instr)

emitEnsureBlocks

private void emitEnsureBlocks(IRBuilder.IRLoop loop)

determineIfWeNeedLineNumber

private void determineIfWeNeedLineNumber(Node node)

notCompilable

private NotCompilableException notCompilable(String message,
 Node node)

buildOperand

private Operand buildOperand(Variable result,
 Node node)
                      throws NotCompilableException

Throws:

NotCompilableException

hasListener

private boolean hasListener()

newIRBuilder

public IRBuilder newIRBuilder(IRManager manager,
 IRScope newScope)

topIRBuilder

public static IRBuilder topIRBuilder(IRManager manager,
 IRScope newScope)

build

public Operand build(Node node)

build

public Operand build(Variable result,
 Node node)

buildLambdaInner

private InterpreterContext buildLambdaInner(LambdaNode node)

preloadBlockImplicitClosure

private void preloadBlockImplicitClosure()

buildLambda

public Operand buildLambda(LambdaNode node)

buildEncoding

public Operand buildEncoding(EncodingNode node)

buildMultipleAsgn19

public Operand buildMultipleAsgn19(MultipleAsgnNode multipleAsgnNode)

copyAndReturnValue

protected Variable copyAndReturnValue(Operand val)

buildWithOrder

protected Operand buildWithOrder(Node node,
 boolean preserveOrder)

buildLazyWithOrder

protected Operand buildLazyWithOrder(CallNode node,
 Label lazyLabel,
 Label endLabel,
 boolean preserveOrder)

getValueInTemporaryVariable

protected Variable getValueInTemporaryVariable(Operand val)

buildAttrAssignCallArgs

protected Operand buildAttrAssignCallArgs(List<Operand> argsList,
 Node args,
 boolean containsAssignment)

buildCallArgs

protected Operand[] buildCallArgs(Node args)

buildCallArgsExcept

protected Operand[] buildCallArgsExcept(Node args,
 Node excludeKeywordArg)

build each argument to a call but if we detect what appears to be a literal simple keyword argument signature we will pass that along to be excluded in the build here (we will build it separately).

Parameters:

args - for a call to be built

excludeKeywordArg - do not build the last one since it is a keyword arg

Returns:

the operands for the call.

setupCallArgs

public Operand[] setupCallArgs(Node args)

addArg

public static Operand[] addArg(Operand[] args,
 Operand extraArg)

buildAssignment

public void buildAssignment(Node node,
 Variable rhsVal)

getBlockArgVariable

protected LocalVariable getBlockArgVariable(RubySymbol name,
 int depth)

receiveBlockArg

protected void receiveBlockArg(Variable v,
 Operand argsArray,
 int argIndex,
 boolean isSplat)

buildVersionSpecificBlockArgsAssignment

public void buildVersionSpecificBlockArgsAssignment(Node node)

buildBlockArgsAssignment

public void buildBlockArgsAssignment(Node node,
 Operand argsArray,
 int argIndex,
 boolean isSplat)

buildAlias

public Operand buildAlias(AliasNode alias)

buildAnd

public Operand buildAnd(AndNode andNode)

buildArray

public Operand buildArray(ArrayNode node,
 boolean operandOnly)

buildArgsCat

public Operand buildArgsCat(ArgsCatNode argsCatNode)

buildArgsPush

public Operand buildArgsPush(ArgsPushNode node)

buildAttrAssign

private Operand buildAttrAssign(Variable result,
 AttrAssignNode attrAssignNode)

buildAttrAssignAssignment

public Operand buildAttrAssignAssignment(Node node,
 Operand value)

buildBackref

public Operand buildBackref(Variable result,
 BackRefNode node)

buildBegin

public Operand buildBegin(BeginNode beginNode)

buildBignum

public Operand buildBignum(BignumNode node)

buildBlock

public Operand buildBlock(BlockNode node)

buildBreak

public Operand buildBreak(BreakNode breakNode)

throwSyntaxError

private void throwSyntaxError(Node node,
 String message)

handleNonlocalReturnInMethod

private void handleNonlocalReturnInMethod()

receiveBreakException

private Operand receiveBreakException(Operand block,
 IRBuilder.CodeBlock codeBlock)

receiveBreakException

private void receiveBreakException(Operand block,
 CallInstr callInstr)

buildCall

public Operand buildCall(Variable aResult,
 CallNode callNode,
 Label lazyLabel,
 Label endLabel)

buildKeywordArguments

private List<KeyValuePair<Operand,Operand>> buildKeywordArguments(HashNode keywordArgs)

determineIfProcNew

private CallInstr determineIfProcNew(Node receiverNode,
 CallInstr callInstr)

getPossibleKeywordArgument

private HashNode getPossibleKeywordArgument(Node argsNode)

buildCase

public Operand buildCase(CaseNode caseNode)

buildCaseTestValue

private Operand buildCaseTestValue(CaseNode caseNode)

literalWhenCheck

private boolean literalWhenCheck(Node value,
 Set<IRubyObject> seenLiterals)

buildWhenValues

private void buildWhenValues(Variable eqqResult,
 ListNode exprValues,
 Operand testValue,
 Label bodyLabel,
 Set<IRubyObject> seenLiterals)

buildWhenValue

private void buildWhenValue(Variable eqqResult,
 Operand testValue,
 Label bodyLabel,
 Node node,
 Set<IRubyObject> seenLiterals,
 boolean needsSplat)

buildWhenSplatValues

private void buildWhenSplatValues(Variable eqqResult,
 Node node,
 Operand testValue,
 Label bodyLabel,
 Set<IRubyObject> seenLiterals)

buildWhenArgs

private void buildWhenArgs(WhenNode whenNode,
 Operand testValue,
 Label bodyLabel,
 Set<IRubyObject> seenLiterals)

getWhenLiteral

private IRubyObject getWhenLiteral(Node node)

buildFixnumCase

private Operand buildFixnumCase(CaseNode caseNode)

buildClass

public Operand buildClass(ClassNode classNode)

Build a new class and add it to the current scope (s).

buildSClass

public Operand buildSClass(SClassNode sclassNode)

buildClassVar

public Operand buildClassVar(ClassVarNode node)

addResultInstr

private Variable addResultInstr(ResultInstr instr)

buildClassVarAsgn

public Operand buildClassVarAsgn(ClassVarAsgnNode classVarAsgnNode)

classVarDeclarationContainer

@Deprecated
public Operand classVarDeclarationContainer()

Deprecated.

classVarDefinitionContainer

public Operand classVarDefinitionContainer()

classVarContainer

public Operand classVarContainer(boolean declContext)

buildConstDecl

public Operand buildConstDecl(ConstDeclNode node)

findContainerModule

private Operand findContainerModule()

buildConstDeclAssignment

public Operand buildConstDeclAssignment(ConstDeclNode constDeclNode,
 Operand value)

putConstant

private Operand putConstant(RubySymbol name,
 Operand value)

putConstant

private Operand putConstant(Colon3Node node,
 Operand value)

putConstant

private Operand putConstant(Colon2Node node,
 Operand value)

putConstantAssignment

private Operand putConstantAssignment(OpAsgnConstDeclNode node,
 Operand value)

searchModuleForConst

private Operand searchModuleForConst(Operand startingModule,
 RubySymbol name)

searchConst

private Operand searchConst(RubySymbol name)

buildColon2

public Operand buildColon2(Colon2Node colon2)

buildColon3

public Operand buildColon3(Colon3Node node)

buildComplex

public Operand buildComplex(ComplexNode node)

protectCodeWithRescue

private Operand protectCodeWithRescue(IRBuilder.CodeBlock protectedCode,
 IRBuilder.CodeBlock rescueBlock)

buildGetDefinition

public Operand buildGetDefinition(Node node)

buildDefnCheckIfThenPaths

protected Variable buildDefnCheckIfThenPaths(Label undefLabel,
 Operand defVal)

buildDefinitionCheck

protected Variable buildDefinitionCheck(ResultInstr definedInstr,
 String definedReturnValue)

buildGetArgumentDefinition

public Operand buildGetArgumentDefinition(Node node,
 String type)

buildDAsgn

public Operand buildDAsgn(DAsgnNode dasgnNode)

defineMethodInner

protected InterpreterContext defineMethodInner(DefNode defNode,
 IRScope parent,
 int coverageMode)

defineNewMethod

private IRMethod defineNewMethod(MethodDefNode defNode,
 boolean isInstanceMethod)

buildDefn

public Operand buildDefn(MethodDefNode node)

buildDefs

public Operand buildDefs(DefsNode node)

getArgVariable

protected LocalVariable getArgVariable(RubySymbol name,
 int depth)

addArgReceiveInstr

private void addArgReceiveInstr(Variable v,
 int argIndex,
 Signature signature)

argumentResult

private Variable argumentResult(RubySymbol name)

receiveRequiredArg

public void receiveRequiredArg(Node node,
 int argIndex,
 Signature signature)

receiveNonBlockArgs

protected void receiveNonBlockArgs(ArgsNode argsNode)

receiveBlockArg

protected void receiveBlockArg(ArgsNode argsNode)

Reify the implicit incoming block into a full Proc, for use as "block arg", but only if a block arg is specified in this scope's arguments.

Parameters:

argsNode - the arguments containing the block arg, if any

prepareImplicitState

private void prepareImplicitState()

Prepare implicit runtime state needed for typical methods to execute. This includes such things as the implicit self variable and any yieldable block available to this scope.

prepareClosureImplicitState

private void prepareClosureImplicitState()

Prepare closure runtime state. This includes the implicit self variable and setting up a variable to hold any frame closure if it is needed later.

receiveArgs

public void receiveArgs(ArgsNode argsNode)

Process all arguments specified for this scope. This includes pre args (required args at the beginning of the argument list), opt args (arguments with a default value), a rest arg (catch-all for argument list overflow), post args (required arguments after a rest arg) and a block arg (to reify an incoming block into a Proc object.

Parameters:

argsNode - the args node containing the specification for the arguments

addKeyArgDesc

private void addKeyArgDesc(AssignableNode kasgn,
 RubySymbol key)

isRequiredKeywordArgumentValue

private boolean isRequiredKeywordArgumentValue(AssignableNode kasgn)

buildArgsMasgn

public void buildArgsMasgn(Node node,
 Operand argsArray,
 boolean isMasgnRoot,
 int preArgsCount,
 int postArgsCount,
 int index,
 boolean isSplat)

buildMultipleAsgn19Assignment

public void buildMultipleAsgn19Assignment(MultipleAsgnNode multipleAsgnNode,
 Operand argsArray,
 Operand values)

handleBreakAndReturnsInLambdas

private void handleBreakAndReturnsInLambdas()

receiveMethodArgs

public void receiveMethodArgs(ArgsNode argsNode)

receiveBlockArgs

public void receiveBlockArgs(IterNode node)

buildDot

public Operand buildDot(DotNode dotNode)

dynamicPiece

private int dynamicPiece(Operand[] pieces,
 int i,
 Node pieceNode)

buildDRegexp

public Operand buildDRegexp(Variable result,
 DRegexpNode node)

buildDStr

public Operand buildDStr(Variable result,
 DStrNode node)

buildDSymbol

public Operand buildDSymbol(Variable result,
 DSymbolNode node)

buildDVar

public Operand buildDVar(DVarNode node)

buildDXStr

public Operand buildDXStr(Variable result,
 DXStrNode node)

buildEnsureNode

public Operand buildEnsureNode(EnsureNode ensureNode)

buildEnsureInternal

public Operand buildEnsureInternal(Node ensureBodyNode,
 Node ensureNode)

buildFalse

public Operand buildFalse()

if_else

private void if_else(Operand testVariable,
 Operand testValue,
 IRBuilder.VoidCodeBlock ifBlock,
 IRBuilder.VoidCodeBlock elseBlock)

Generate if testVariable NEQ testValue { ifBlock } else { elseBlock }.

Parameters:

testVariable - what we will test against testValue

testValue - what we want to testVariable to NOT be equal to.

ifBlock - the code if test values do NOT match

elseBlock - the code to execute otherwise.

buildRestKeywordArgs

private Variable buildRestKeywordArgs(HashNode keywordArgs)

buildFCall

public Operand buildFCall(Variable aResult,
 FCallNode fcallNode)

setupCallClosure

private Operand setupCallClosure(Node node)

determineIfMaybeRefined

private void determineIfMaybeRefined(RubySymbol methodName,
 Operand[] args)

buildFixnum

public Operand buildFixnum(FixnumNode node)

buildFlip

public Operand buildFlip(FlipNode flipNode)

buildFloat

public Operand buildFloat(FloatNode node)

buildFor

public Operand buildFor(ForNode forNode)

buildForIter

public Operand buildForIter(ForNode forNode)

buildGlobalAsgn

public Operand buildGlobalAsgn(GlobalAsgnNode globalAsgnNode)

buildGlobalVar

public Operand buildGlobalVar(Variable result,
 GlobalVarNode node)

buildHash

public Operand buildHash(HashNode hashNode)

buildIf

public Operand buildIf(Variable result,
 IfNode ifNode)

buildInstAsgn

public Operand buildInstAsgn(InstAsgnNode instAsgnNode)

buildInstVar

public Operand buildInstVar(InstVarNode node)

buildIterInner

private InterpreterContext buildIterInner(RubySymbol methodName,
 IterNode iterNode)

buildIter

public Operand buildIter(IterNode iterNode)

buildLiteral

public Operand buildLiteral(LiteralNode literalNode)

buildLocalAsgn

public Operand buildLocalAsgn(LocalAsgnNode localAsgnNode)

buildLocalVar

public Operand buildLocalVar(LocalVarNode node)

buildMatch

public Operand buildMatch(Variable result,
 MatchNode matchNode)

buildMatch2

public Operand buildMatch2(Variable result,
 Match2Node matchNode)

getVarNameFromScopeTree

private String getVarNameFromScopeTree(IRScope scope,
 int depth,
 int offset)

buildMatch3

public Operand buildMatch3(Variable result,
 Match3Node matchNode)

getContainerFromCPath

private Operand getContainerFromCPath(Colon3Node cpath)

buildModule

public Operand buildModule(ModuleNode moduleNode)

buildNext

public Operand buildNext(NextNode nextNode)

buildNthRef

public Operand buildNthRef(NthRefNode nthRefNode)

buildNil

public Operand buildNil()

buildOpAsgn

public Operand buildOpAsgn(OpAsgnNode opAsgnNode)

buildColon2ForConstAsgnDeclNode

private Operand buildColon2ForConstAsgnDeclNode(Node lhs,
 Variable valueResult,
 boolean constMissing)

buildOpAsgnConstDeclNode

public Operand buildOpAsgnConstDeclNode(OpAsgnConstDeclNode node)

buildOpAsgnAnd

public Operand buildOpAsgnAnd(OpAsgnAndNode andNode)

buildOpAsgnOr

public Operand buildOpAsgnOr(OpAsgnOrNode orNode)

buildOpElementAsgn

public Operand buildOpElementAsgn(OpElementAsgnNode node)

buildOpElementAsgnWith

private Operand buildOpElementAsgnWith(OpElementAsgnNode opElementAsgnNode,
 Boolean truthy)

buildOpElementAsgnWithMethod

public Operand buildOpElementAsgnWithMethod(OpElementAsgnNode opElementAsgnNode)

buildOr

public Operand buildOr(OrNode orNode)

buildPrePostExeInner

private InterpreterContext buildPrePostExeInner(Node body)

buildPreExeInner

private List<Instr> buildPreExeInner(Node body)

buildPostExe

public Operand buildPostExe(PostExeNode postExeNode)

buildPreExe

public Operand buildPreExe(PreExeNode preExeNode)

buildRational

public Operand buildRational(RationalNode rationalNode)

buildRedo

public Operand buildRedo(RedoNode redoNode)

buildRegexp

public Operand buildRegexp(RegexpNode reNode)

buildRescue

public Operand buildRescue(RescueNode node)

canBacktraceBeRemoved

private boolean canBacktraceBeRemoved(RescueNode rescueNode)

isErrorInfoGlobal

private static boolean isErrorInfoGlobal(String name)

buildRescueInternal

private Operand buildRescueInternal(RescueNode rescueNode,
 IRBuilder.EnsureBlockInfo ensure)

outputExceptionCheck

private void outputExceptionCheck(Operand excType,
 Operand excObj,
 Label caughtLabel)

buildRescueBodyInternal

private void buildRescueBodyInternal(RescueBodyNode rescueBodyNode,
 Variable rv,
 Variable exc,
 Label endLabel)

buildRetry

public Operand buildRetry(RetryNode retryNode)

processEnsureRescueBlocks

private Operand processEnsureRescueBlocks(Operand retVal)

buildReturn

public Operand buildReturn(ReturnNode returnNode)

buildEvalRoot

public InterpreterContext buildEvalRoot(RootNode rootNode)

buildRoot

public static InterpreterContext buildRoot(IRManager manager,
 RootNode rootNode)

addCurrentModule

private void addCurrentModule()

buildRootInner

private InterpreterContext buildRootInner(RootNode rootNode)

buildSelf

public Variable buildSelf()

buildSplat

public Operand buildSplat(SplatNode splatNode)

buildStr

public Operand buildStr(StrNode strNode)

buildStrRaw

public Operand buildStrRaw(StrNode strNode)

buildSuperInstr

private Operand buildSuperInstr(Operand block,
 Operand[] args)

buildSuper

public Operand buildSuper(SuperNode superNode)

buildSValue

public Operand buildSValue(SValueNode node)

buildSymbol

public Operand buildSymbol(SymbolNode node)

buildTrue

public Operand buildTrue()

buildUndef

public Operand buildUndef(Node node)

buildConditionalLoop

private Operand buildConditionalLoop(Node conditionNode,
 Node bodyNode,
 boolean isWhile,
 boolean isLoopHeadCondition)

buildUntil

public Operand buildUntil(UntilNode untilNode)

buildVAlias

public Operand buildVAlias(VAliasNode valiasNode)

buildVCall

public Operand buildVCall(Variable result,
 VCallNode node)

buildWhile

public Operand buildWhile(WhileNode whileNode)

buildXStr

public Operand buildXStr(XStrNode node)

buildYield

public Operand buildYield(YieldNode node,
 Variable result)

copy

public Operand copy(Operand value)

copy

public Operand copy(Variable result,
 Operand value)

buildZArray

public Operand buildZArray(Variable result)

buildZSuperIfNest

private Operand buildZSuperIfNest(Operand block)

isDefineMethod

private boolean isDefineMethod()

addRaiseError

private void addRaiseError(String id,
 String message)

buildZSuper

public Operand buildZSuper(ZSuperNode zsuperNode)

adjustVariableDepth

private Operand[] adjustVariableDepth(Operand[] args,
 int depthFromSuper)

buildModuleOrClassBody

private InterpreterContext buildModuleOrClassBody(Node bodyNode,
 int startLine,
 int endLine)

methodNameFor

private RubySymbol methodNameFor()

createTemporaryVariable

private TemporaryVariable createTemporaryVariable()

getLocalVariable

public LocalVariable getLocalVariable(RubySymbol name,
 int scopeDepth)

getNewLocalVariable

public LocalVariable getNewLocalVariable(RubySymbol name,
 int scopeDepth)

getName

public RubySymbol getName()

getNewLabel

private Label getNewLabel()

getFileName

private String getFileName()

symbol

private RubySymbol symbol(String id)

symbol

private RubySymbol symbol(ByteList bytelist)

getCallArgs

public static Operand[] getCallArgs(IRScope scope,
 IRBuilder builder)

Extract all call arguments from the specified scope (only useful for Closures and Methods) so that we can convert zsupers to supers with explicit arguments. Note: This is fairly expensive because we walk entire scope when we could potentially stop earlier if we knew when recv_* were done.

extractCallOperands

private static void extractCallOperands(List<Operand> callArgs,
 List<KeyValuePair<Operand,Operand>> keywordArgs,
 Instr instr)

getCallOperands

private static Operand[] getCallOperands(IRScope scope,
 List<Operand> callArgs,
 List<KeyValuePair<Operand,Operand>> keywordArgs)

createBranch

public static Instr createBranch(Operand v1,
 Operand v2,
 Label jmpTarget)

getYieldClosureVariable

public TemporaryVariable getYieldClosureVariable()

Get the variable for accessing the "yieldable" closure in this scope.

getCurrentModuleVariable

public Variable getCurrentModuleVariable()

createCurrentModuleVariable

public Variable createCurrentModuleVariable()

computeScopeFlagsFrom

public void computeScopeFlagsFrom(List<Instr> instructions)

calculateClosureScopeFlags

private void calculateClosureScopeFlags()

computeNeedsDynamicScopeFlag

private boolean computeNeedsDynamicScopeFlag()