IRBuilder

java.lang.Object
- org.jruby.ir.IRBuilder

Direct Known Subclasses:: IRBuilder19

public class IRBuilder
extends java.lang.Object

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`(package private) static interface`	`IRBuilder.CodeBlock`
`private static class`	`IRBuilder.EnsureBlockInfo`
`private static class`	`IRBuilder.RescueBlockInfo`

Field Summary

Fields
Modifier and Type	Field and Description
`private java.util.Stack<IRBuilder.EnsureBlockInfo>`	`_ensureBlockStack`
`private int`	`_lastProcessedLineNum`
`private java.util.Stack<IRBuilder.RescueBlockInfo>`	`_rescueBlockStack`
`private java.util.Stack<IRLoop>`	`loopStack`
`protected IRManager`	`manager`
`protected static Operand[]`	`NO_ARGS`
`private static java.lang.String`	`rubyVersion`
`protected static UnexecutableNil`	`U_NIL`

Constructor Summary

Constructors
Constructor and Description

IRBuilder(IRManager manager)

Constructors
Constructor and Description
`IRBuilder(IRManager manager)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Operand`	`build(Node node, IRScope s)`
`Operand`	`buildAlias(AliasNode alias, IRScope s)`
`Operand`	`buildAnd(AndNode andNode, IRScope s)`
`Operand`	`buildArgsCat(ArgsCatNode argsCatNode, IRScope s)`
`Operand`	`buildArgsPush(ArgsPushNode node, IRScope s)`
`Operand`	`buildArray(Node node, IRScope s)`
`void`	`buildAssignment(Node node, IRScope s, Variable rhsVal)`
`static Node`	`buildAST(boolean isCommandLineScript, java.lang.String arg)`
`private Operand`	`buildAttrAssign(AttrAssignNode attrAssignNode, IRScope s)`
`Operand`	`buildAttrAssignAssignment(Node node, IRScope s, Operand value)`
`Operand`	`buildBackref(BackRefNode node, IRScope s)`
`Operand`	`buildBegin(BeginNode beginNode, IRScope s)`
`Operand`	`buildBignum(BignumNode node, IRScope s)`
`Operand`	`buildBlock(BlockNode node, IRScope s)`
`void`	`buildBlockArgsAssignment(Node node, IRScope s, Operand argsArray, int argIndex, boolean isMasgnRoot, boolean isClosureArg, boolean isSplat)`
`Operand`	`buildBreak(BreakNode breakNode, IRScope s)`
`Operand`	`buildCall(CallNode callNode, IRScope s)`
`protected Operand`	`buildCallArgs(java.util.List<Operand> argsList, Node args, IRScope s)`
`Operand`	`buildCase(CaseNode caseNode, IRScope s)`
`Operand`	`buildClass(ClassNode classNode, IRScope s)` Build a new class and add it to the current scope (s).
`Operand`	`buildClassVar(ClassVarNode node, IRScope s)`
`Operand`	`buildClassVarAsgn(ClassVarAsgnNode classVarAsgnNode, IRScope s)`
`Operand`	`buildClassVarDecl(ClassVarDeclNode classVarDeclNode, IRScope s)`
`Operand`	`buildColon2(Colon2Node iVisited, IRScope s)`
`Operand`	`buildColon3(Colon3Node node, IRScope s)`
`private Operand`	`buildConditionalLoop(IRScope s, Node conditionNode, Node bodyNode, boolean isWhile, boolean isLoopHeadCondition)`
`Operand`	`buildConstDecl(ConstDeclNode node, IRScope s)`
`Operand`	`buildConstDeclAssignment(ConstDeclNode constDeclNode, IRScope s, Operand val)`
`Operand`	`buildDAsgn(DAsgnNode dasgnNode, IRScope s)`
`protected Variable`	`buildDefinitionCheck(IRScope s, ResultInstr definedInstr, java.lang.String definedReturnValue)`
`Operand`	`buildDefn(MethodDefNode node, IRScope s)`
`protected Variable`	`buildDefnCheckIfThenPaths(IRScope s, Label undefLabel, Operand defVal)`
`Operand`	`buildDefs(DefsNode node, IRScope s)`
`Operand`	`buildDot(DotNode dotNode, IRScope s)`
`Operand`	`buildDRegexp(DRegexpNode dregexpNode, IRScope s)`
`Operand`	`buildDStr(DStrNode dstrNode, IRScope s)`
`Operand`	`buildDSymbol(DSymbolNode node, IRScope s)`
`Operand`	`buildDVar(DVarNode node, IRScope s)`
`Operand`	`buildDXStr(DXStrNode dstrNode, IRScope s)`
`Operand`	`buildEnsureNode(EnsureNode ensureNode, IRScope s)`
`IREvalScript`	`buildEvalRoot(StaticScope staticScope, IRScope containingScope, java.lang.String file, int lineNumber, RootNode rootNode)`
`Operand`	`buildEvStr(EvStrNode node, IRScope s)`
`Operand`	`buildFalse(Node node, IRScope s)`
`Operand`	`buildFCall(FCallNode fcallNode, IRScope s)`
`Operand`	`buildFixnum(FixnumNode node, IRScope s)`
`Operand`	`buildFlip(FlipNode flipNode, IRScope s)`
`Operand`	`buildFloat(FloatNode node, IRScope s)`
`Operand`	`buildFor(ForNode forNode, IRScope s)`
`Operand`	`buildForIter(ForNode forNode, IRScope s)`
`protected Operand`	`buildGenericGetDefinitionIR(Node node, IRScope s)`
`Operand`	`buildGetArgumentDefinition(Node node, IRScope s, java.lang.String type)`
`Operand`	`buildGetDefinition(Node defnNode, IRScope s)`
`Operand`	`buildGetDefinitionBase(Node node, IRScope s)`
`Operand`	`buildGlobalAsgn(GlobalAsgnNode globalAsgnNode, IRScope s)`
`Operand`	`buildGlobalVar(GlobalVarNode node, IRScope s)`
`Operand`	`buildHash(HashNode hashNode, IRScope s)`
`Operand`	`buildIf(IfNode ifNode, IRScope s)`
`Operand`	`buildInstAsgn(InstAsgnNode instAsgnNode, IRScope s)`
`Operand`	`buildInstVar(InstVarNode node, IRScope s)`
`Operand`	`buildIter(IterNode iterNode, IRScope s)`
`Operand`	`buildLiteral(LiteralNode literalNode, IRScope s)`
`Operand`	`buildLocalAsgn(LocalAsgnNode localAsgnNode, IRScope s)`
`Operand`	`buildLocalVar(LocalVarNode node, IRScope s)`
`Operand`	`buildMatch(MatchNode matchNode, IRScope s)`
`Operand`	`buildMatch2(Match2Node matchNode, IRScope s)`
`Operand`	`buildMatch3(Match3Node matchNode, IRScope s)`
`Operand`	`buildModule(ModuleNode moduleNode, IRScope s)`
`Operand`	`buildMultipleAsgn(MultipleAsgnNode multipleAsgnNode, IRScope s)`
`void`	`buildMultipleAsgnAssignment(MultipleAsgnNode multipleAsgnNode, IRScope s, Operand argsArray, Operand values)`
`Operand`	`buildNewline(NewlineNode node, IRScope s)`
`Operand`	`buildNext(NextNode nextNode, IRScope s)`
`Operand`	`buildNil(Node node, IRScope s)`
`Operand`	`buildNot(NotNode node, IRScope s)`
`Operand`	`buildNthRef(NthRefNode nthRefNode, IRScope s)`
`Operand`	`buildOpAsgn(OpAsgnNode opAsgnNode, IRScope s)`
`Operand`	`buildOpAsgnAnd(OpAsgnAndNode andNode, IRScope s)`
`Operand`	`buildOpAsgnOr(OpAsgnOrNode orNode, IRScope s)`
`Operand`	`buildOpElementAsgn(OpElementAsgnNode node, IRScope s)`
`Operand`	`buildOpElementAsgnWithAnd(OpElementAsgnNode opElementAsgnNode, IRScope s)`
`Operand`	`buildOpElementAsgnWithMethod(OpElementAsgnNode opElementAsgnNode, IRScope s)`
`Operand`	`buildOpElementAsgnWithOr(OpElementAsgnNode opElementAsgnNode, IRScope s)`
`private Operand`	`buildOperand(Node node, IRScope s)`
`Operand`	`buildOr(OrNode orNode, IRScope s)`
`Operand`	`buildPostExe(PostExeNode postExeNode, IRScope s)`
`Operand`	`buildPreExe(PreExeNode preExeNode, IRScope s)`
`Operand`	`buildRedo(Node node, IRScope s)`
`Operand`	`buildRegexp(RegexpNode reNode, IRScope s)`
`Operand`	`buildRescue(RescueNode node, IRScope s)`
`private void`	`buildRescueBodyInternal(IRScope s, Node node, Variable rv, Label endLabel)`
`private Operand`	`buildRescueInternal(RescueNode rescueNode, IRScope s, IRBuilder.EnsureBlockInfo ensure)`
`Operand`	`buildRetry(Node node, IRScope s)`
`Operand`	`buildReturn(ReturnNode returnNode, IRScope s)`
`IRScope`	`buildRoot(RootNode rootNode)`
`Operand`	`buildSClass(SClassNode sclassNode, IRScope s)`
`Operand`	`buildSelf(Node node, IRScope s)`
`Operand`	`buildSplat(SplatNode splatNode, IRScope s)`
`Operand`	`buildStr(StrNode strNode, IRScope s)`
`Operand`	`buildSuper(SuperNode superNode, IRScope s)`
`private Operand`	`buildSuperInScriptBody(IRScope s)`
`private Operand`	`buildSuperInstr(IRScope s, Operand block, Operand[] args)`
`Operand`	`buildSValue(SValueNode node, IRScope s)`
`Operand`	`buildSymbol(SymbolNode node, IRScope s)`
`Operand`	`buildToAry(ToAryNode node, IRScope s)`
`Operand`	`buildTrue(Node node, IRScope s)`
`java.lang.String`	`buildType(Node typeNode)`
`Operand`	`buildUndef(Node node, IRScope s)`
`Operand`	`buildUntil(UntilNode untilNode, IRScope s)`
`Operand`	`buildVAlias(Node node, IRScope s)`
`Operand`	`buildVCall(VCallNode node, IRScope s)`
`void`	`buildVersionSpecificAssignment(Node node, IRScope s, Variable v)`
`void`	`buildVersionSpecificBlockArgsAssignment(Node node, IRScope s, Operand argsArray, int argIndex, boolean isMasgnRoot, boolean isClosureArg, boolean isSplat)`
`protected Operand`	`buildVersionSpecificGetDefinitionIR(Node node, IRScope s)`
`protected Operand`	`buildVersionSpecificNodes(Node node, IRScope s)`
`Operand`	`buildWhile(WhileNode whileNode, IRScope s)`
`Operand`	`buildXStr(XStrNode node, IRScope s)`
`Operand`	`buildYield(YieldNode node, IRScope s)`
`Operand`	`buildZArray(Node node, IRScope s)`
`Operand`	`buildZSuper(ZSuperNode zsuperNode, IRScope s)` private Operand[] getZSuperArgs(IRScope s) { if (s instanceof IRMethod) return ((IRMethod)s).getCallArgs(); Operand[] sArgs = s.getNearestMethod().getCallArgs(); // Update args to make them accessible at a different depth int n = ((IRClosure)s).getNestingDepth(); for (int i = 0; i < sArgs.length; i++) { Operand arg = sArgs[i]; sArgs[i] = (arg instanceof Splat) ? new Splat(((LocalVariable)((Splat)arg).getArray()).cloneForDepth(n)) : ((LocalVariable)arg).cloneForDepth(n); } return sArgs; }
`Operand`	`classVarContainer(IRScope s, boolean declContext)`
`Operand`	`classVarDeclarationContainer(IRScope s)`
`Operand`	`classVarDefinitionContainer(IRScope s)`
`protected Variable`	`copyAndReturnValue(IRScope s, Operand val)`
`static IRBuilder`	`createIRBuilder(Ruby runtime, IRManager manager)`
`private IRMethod`	`defineNewMethod(MethodDefNode defNode, IRScope s, boolean isInstanceMethod)`
`private Operand`	`dynamicPiece(Node pieceNode, IRScope s)`
`private Operand`	`findContainerModule(IRScope s)`
`private void`	`genInheritanceSearchInstrs(IRScope s, Operand startingModule, Variable constVal, Label foundLabel, boolean noPrivateConstants, java.lang.String name)`
`protected LocalVariable`	`getBlockArgVariable(IRScope cl, java.lang.String name, int depth)`
`private Operand`	`getContainerFromCPath(Colon3Node cpath, IRScope s)`
`IRLoop`	`getCurrentLoop()`
`protected Variable`	`getSelf(IRScope s)`
`protected Variable`	`getValueInTemporaryVariable(IRScope s, Operand val)`
`private void`	`handleNonlocalReturnInMethod(IRScope s)`
`private boolean`	`hasListener()`
`boolean`	`is1_9()`
`boolean`	`is2_0()`
`private boolean`	`needsDefinitionCheck(Node node)` Check whether the given node is considered always "defined" or whether it has some form of definition check.
`IRBuilder`	`newIRBuilder(IRManager manager)`
`private void`	`outputExceptionCheck(IRScope s, Operand excType, Operand excObj, Label caughtLabel)`
`private Operand`	`protectCodeWithRescue(IRScope m, IRBuilder.CodeBlock protectedCode, java.lang.Object[] protectedCodeArgs, IRBuilder.CodeBlock rescueBlock, java.lang.Object[] rescueBlockArgs)`
`protected void`	`receiveBlockArg(IRScope s, Variable v, Operand argsArray, int argIndex, boolean isClosureArg, boolean isSplat)`
`void`	`receiveBlockArgs(IterNode node, IRScope s)`
`void`	`receiveBlockClosureArg(Node node, IRScope s)`
`private void`	`receiveBreakException(IRScope s, Operand block, CallInstr callInstr)`
`void`	`receiveMethodArgs(ArgsNode argsNode, IRScope s)`
`private void`	`receiveMethodClosureArg(ArgsNode argsNode, IRScope s)`
`protected int`	`receiveOptArgs(ArgsNode argsNode, IRScope s, int opt, int argIndex)`
`private Operand`	`searchConst(IRScope s, IRScope startingScope, java.lang.String name)`
`private Operand`	`searchConstInInheritanceHierarchy(IRScope s, Operand startingModule, java.lang.String name)`
`static void`	`setRubyVersion(java.lang.String rubyVersion)`
`java.util.List<Operand>`	`setupCallArgs(Node args, IRScope s)`
`private Operand`	`setupCallClosure(Node node, IRScope s)`
`Node`	`skipOverNewlines(IRScope s, Node n)`
`private Operand`	`startingSearchScope(IRScope s)`

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

Field Detail

NO_ARGS

protected static final Operand[] NO_ARGS

U_NIL

protected static final UnexecutableNil U_NIL

rubyVersion

private static java.lang.String rubyVersion

_ensureBlockStack

private java.util.Stack<IRBuilder.EnsureBlockInfo> _ensureBlockStack

_rescueBlockStack

private java.util.Stack<IRBuilder.RescueBlockInfo> _rescueBlockStack

_lastProcessedLineNum
```
private int _lastProcessedLineNum
```

loopStack

private java.util.Stack<IRLoop> loopStack

manager
```
protected IRManager manager
```

Constructor Detail
- IRBuilder
```
public IRBuilder(IRManager manager)
```

Method Detail

setRubyVersion

public static void setRubyVersion(java.lang.String rubyVersion)

is1_9
```
public boolean is1_9()
```

is2_0
```
public boolean is2_0()
```

buildOperand

private Operand buildOperand(Node node,
                             IRScope s)
                      throws NotCompilableException

Throws:: NotCompilableException

getCurrentLoop
```
public IRLoop getCurrentLoop()
```

buildAST

public static Node buildAST(boolean isCommandLineScript,
                            java.lang.String arg)

createIRBuilder

public static IRBuilder createIRBuilder(Ruby runtime,
                                        IRManager manager)

hasListener
```
private boolean hasListener()
```

newIRBuilder

public IRBuilder newIRBuilder(IRManager manager)

skipOverNewlines

public Node skipOverNewlines(IRScope s,
                             Node n)

build

public Operand build(Node node,
                     IRScope s)

buildVersionSpecificNodes

protected Operand buildVersionSpecificNodes(Node node,
                                            IRScope s)

getSelf

protected Variable getSelf(IRScope s)

copyAndReturnValue

protected Variable copyAndReturnValue(IRScope s,
                                      Operand val)

getValueInTemporaryVariable

protected Variable getValueInTemporaryVariable(IRScope s,
                                               Operand val)

buildCallArgs

protected Operand buildCallArgs(java.util.List<Operand> argsList,
                                Node args,
                                IRScope s)

setupCallArgs

public java.util.List<Operand> setupCallArgs(Node args,
                                             IRScope s)

buildVersionSpecificAssignment

public void buildVersionSpecificAssignment(Node node,
                                           IRScope s,
                                           Variable v)

buildAssignment

public void buildAssignment(Node node,
                            IRScope s,
                            Variable rhsVal)

getBlockArgVariable

protected LocalVariable getBlockArgVariable(IRScope cl,
                                            java.lang.String name,
                                            int depth)

receiveBlockArg

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

buildVersionSpecificBlockArgsAssignment

public void buildVersionSpecificBlockArgsAssignment(Node node,
                                                    IRScope s,
                                                    Operand argsArray,
                                                    int argIndex,
                                                    boolean isMasgnRoot,
                                                    boolean isClosureArg,
                                                    boolean isSplat)

buildBlockArgsAssignment

public void buildBlockArgsAssignment(Node node,
                                     IRScope s,
                                     Operand argsArray,
                                     int argIndex,
                                     boolean isMasgnRoot,
                                     boolean isClosureArg,
                                     boolean isSplat)

buildAlias

public Operand buildAlias(AliasNode alias,
                          IRScope s)

buildAnd

public Operand buildAnd(AndNode andNode,
                        IRScope s)

buildArray

public Operand buildArray(Node node,
                          IRScope s)

buildArgsCat

public Operand buildArgsCat(ArgsCatNode argsCatNode,
                            IRScope s)

buildArgsPush

public Operand buildArgsPush(ArgsPushNode node,
                             IRScope s)

buildAttrAssign

private Operand buildAttrAssign(AttrAssignNode attrAssignNode,
                                IRScope s)

buildAttrAssignAssignment

public Operand buildAttrAssignAssignment(Node node,
                                         IRScope s,
                                         Operand value)

buildBackref

public Operand buildBackref(BackRefNode node,
                            IRScope s)

buildBegin

public Operand buildBegin(BeginNode beginNode,
                          IRScope s)

buildBignum

public Operand buildBignum(BignumNode node,
                           IRScope s)

buildBlock

public Operand buildBlock(BlockNode node,
                          IRScope s)

buildBreak

public Operand buildBreak(BreakNode breakNode,
                          IRScope s)

handleNonlocalReturnInMethod

private void handleNonlocalReturnInMethod(IRScope s)

receiveBreakException

private void receiveBreakException(IRScope s,
                                   Operand block,
                                   CallInstr callInstr)

buildCall

public Operand buildCall(CallNode callNode,
                         IRScope s)

buildCase

public Operand buildCase(CaseNode caseNode,
                         IRScope s)

buildClass

public Operand buildClass(ClassNode classNode,
                          IRScope s)

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

buildSClass

public Operand buildSClass(SClassNode sclassNode,
                           IRScope s)

buildClassVar

public Operand buildClassVar(ClassVarNode node,
                             IRScope s)

buildClassVarAsgn

public Operand buildClassVarAsgn(ClassVarAsgnNode classVarAsgnNode,
                                 IRScope s)

buildClassVarDecl

public Operand buildClassVarDecl(ClassVarDeclNode classVarDeclNode,
                                 IRScope s)

classVarDeclarationContainer

public Operand classVarDeclarationContainer(IRScope s)

classVarDefinitionContainer

public Operand classVarDefinitionContainer(IRScope s)

classVarContainer

public Operand classVarContainer(IRScope s,
                                 boolean declContext)

buildConstDecl

public Operand buildConstDecl(ConstDeclNode node,
                              IRScope s)

findContainerModule

private Operand findContainerModule(IRScope s)

startingSearchScope

private Operand startingSearchScope(IRScope s)

buildConstDeclAssignment

public Operand buildConstDeclAssignment(ConstDeclNode constDeclNode,
                                        IRScope s,
                                        Operand val)

genInheritanceSearchInstrs

private void genInheritanceSearchInstrs(IRScope s,
                                        Operand startingModule,
                                        Variable constVal,
                                        Label foundLabel,
                                        boolean noPrivateConstants,
                                        java.lang.String name)

searchConstInInheritanceHierarchy

private Operand searchConstInInheritanceHierarchy(IRScope s,
                                                  Operand startingModule,
                                                  java.lang.String name)

searchConst

private Operand searchConst(IRScope s,
                            IRScope startingScope,
                            java.lang.String name)

buildColon2

public Operand buildColon2(Colon2Node iVisited,
                           IRScope s)

buildColon3

public Operand buildColon3(Colon3Node node,
                           IRScope s)

protectCodeWithRescue

private Operand protectCodeWithRescue(IRScope m,
                                      IRBuilder.CodeBlock protectedCode,
                                      java.lang.Object[] protectedCodeArgs,
                                      IRBuilder.CodeBlock rescueBlock,
                                      java.lang.Object[] rescueBlockArgs)

buildGenericGetDefinitionIR

protected Operand buildGenericGetDefinitionIR(Node node,
                                              IRScope s)

buildVersionSpecificGetDefinitionIR

protected Operand buildVersionSpecificGetDefinitionIR(Node node,
                                                      IRScope s)

buildGetDefinitionBase

public Operand buildGetDefinitionBase(Node node,
                                      IRScope s)

buildDefnCheckIfThenPaths

protected Variable buildDefnCheckIfThenPaths(IRScope s,
                                             Label undefLabel,
                                             Operand defVal)

buildDefinitionCheck

protected Variable buildDefinitionCheck(IRScope s,
                                        ResultInstr definedInstr,
                                        java.lang.String definedReturnValue)

buildGetArgumentDefinition

public Operand buildGetArgumentDefinition(Node node,
                                          IRScope s,
                                          java.lang.String type)

buildGetDefinition

public Operand buildGetDefinition(Node defnNode,
                                  IRScope s)

buildDAsgn

public Operand buildDAsgn(DAsgnNode dasgnNode,
                          IRScope s)

defineNewMethod

private IRMethod defineNewMethod(MethodDefNode defNode,
                                 IRScope s,
                                 boolean isInstanceMethod)

buildDefn

public Operand buildDefn(MethodDefNode node,
                         IRScope s)

buildDefs

public Operand buildDefs(DefsNode node,
                         IRScope s)

receiveOptArgs

protected int receiveOptArgs(ArgsNode argsNode,
                             IRScope s,
                             int opt,
                             int argIndex)

receiveMethodArgs

public void receiveMethodArgs(ArgsNode argsNode,
                              IRScope s)

receiveMethodClosureArg

private void receiveMethodClosureArg(ArgsNode argsNode,
                                     IRScope s)

receiveBlockArgs

public void receiveBlockArgs(IterNode node,
                             IRScope s)

receiveBlockClosureArg

public void receiveBlockClosureArg(Node node,
                                   IRScope s)

buildType

public java.lang.String buildType(Node typeNode)

buildDot

public Operand buildDot(DotNode dotNode,
                        IRScope s)

dynamicPiece

private Operand dynamicPiece(Node pieceNode,
                             IRScope s)

buildDRegexp

public Operand buildDRegexp(DRegexpNode dregexpNode,
                            IRScope s)

buildDStr

public Operand buildDStr(DStrNode dstrNode,
                         IRScope s)

buildDSymbol

public Operand buildDSymbol(DSymbolNode node,
                            IRScope s)

buildDVar

public Operand buildDVar(DVarNode node,
                         IRScope s)

buildDXStr

public Operand buildDXStr(DXStrNode dstrNode,
                          IRScope s)

buildEnsureNode

public Operand buildEnsureNode(EnsureNode ensureNode,
                               IRScope s)

buildEvStr

public Operand buildEvStr(EvStrNode node,
                          IRScope s)

buildFalse

public Operand buildFalse(Node node,
                          IRScope s)

buildFCall

public Operand buildFCall(FCallNode fcallNode,
                          IRScope s)

setupCallClosure

private Operand setupCallClosure(Node node,
                                 IRScope s)

buildFixnum

public Operand buildFixnum(FixnumNode node,
                           IRScope s)

buildFlip

public Operand buildFlip(FlipNode flipNode,
                         IRScope s)

buildFloat

public Operand buildFloat(FloatNode node,
                          IRScope s)

buildFor

public Operand buildFor(ForNode forNode,
                        IRScope s)

buildForIter

public Operand buildForIter(ForNode forNode,
                            IRScope s)

buildGlobalAsgn

public Operand buildGlobalAsgn(GlobalAsgnNode globalAsgnNode,
                               IRScope s)

buildGlobalVar

public Operand buildGlobalVar(GlobalVarNode node,
                              IRScope s)

buildHash

public Operand buildHash(HashNode hashNode,
                         IRScope s)

buildIf

public Operand buildIf(IfNode ifNode,
                       IRScope s)

buildInstAsgn

public Operand buildInstAsgn(InstAsgnNode instAsgnNode,
                             IRScope s)

buildInstVar

public Operand buildInstVar(InstVarNode node,
                            IRScope s)

buildIter

public Operand buildIter(IterNode iterNode,
                         IRScope s)

buildLiteral

public Operand buildLiteral(LiteralNode literalNode,
                            IRScope s)

buildLocalAsgn

public Operand buildLocalAsgn(LocalAsgnNode localAsgnNode,
                              IRScope s)

buildLocalVar

public Operand buildLocalVar(LocalVarNode node,
                             IRScope s)

buildMatch

public Operand buildMatch(MatchNode matchNode,
                          IRScope s)

buildMatch2

public Operand buildMatch2(Match2Node matchNode,
                           IRScope s)

buildMatch3

public Operand buildMatch3(Match3Node matchNode,
                           IRScope s)

getContainerFromCPath

private Operand getContainerFromCPath(Colon3Node cpath,
                                      IRScope s)

buildModule

public Operand buildModule(ModuleNode moduleNode,
                           IRScope s)

buildMultipleAsgn

public Operand buildMultipleAsgn(MultipleAsgnNode multipleAsgnNode,
                                 IRScope s)

buildMultipleAsgnAssignment

public void buildMultipleAsgnAssignment(MultipleAsgnNode multipleAsgnNode,
                                        IRScope s,
                                        Operand argsArray,
                                        Operand values)

buildNewline

public Operand buildNewline(NewlineNode node,
                            IRScope s)

buildNext

public Operand buildNext(NextNode nextNode,
                         IRScope s)

buildNthRef

public Operand buildNthRef(NthRefNode nthRefNode,
                           IRScope s)

buildNil

public Operand buildNil(Node node,
                        IRScope s)

buildNot

public Operand buildNot(NotNode node,
                        IRScope s)

buildOpAsgn

public Operand buildOpAsgn(OpAsgnNode opAsgnNode,
                           IRScope s)

buildOpAsgnAnd

public Operand buildOpAsgnAnd(OpAsgnAndNode andNode,
                              IRScope s)

buildOpAsgnOr

public Operand buildOpAsgnOr(OpAsgnOrNode orNode,
                             IRScope s)

needsDefinitionCheck
```
private boolean needsDefinitionCheck(Node node)
```
Check whether the given node is considered always "defined" or whether it has some form of definition check.

Parameters:

node - Then node to check

Returns:

Whether the type of node represents a possibly undefined construct

buildOpElementAsgn

public Operand buildOpElementAsgn(OpElementAsgnNode node,
                                  IRScope s)

buildOpElementAsgnWithOr

public Operand buildOpElementAsgnWithOr(OpElementAsgnNode opElementAsgnNode,
                                        IRScope s)

buildOpElementAsgnWithAnd

public Operand buildOpElementAsgnWithAnd(OpElementAsgnNode opElementAsgnNode,
                                         IRScope s)

buildOpElementAsgnWithMethod

public Operand buildOpElementAsgnWithMethod(OpElementAsgnNode opElementAsgnNode,
                                            IRScope s)

buildOr

public Operand buildOr(OrNode orNode,
                       IRScope s)

buildPostExe

public Operand buildPostExe(PostExeNode postExeNode,
                            IRScope s)

buildPreExe

public Operand buildPreExe(PreExeNode preExeNode,
                           IRScope s)

buildRedo

public Operand buildRedo(Node node,
                         IRScope s)

buildRegexp

public Operand buildRegexp(RegexpNode reNode,
                           IRScope s)

buildRescue

public Operand buildRescue(RescueNode node,
                           IRScope s)

buildRescueInternal

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

outputExceptionCheck

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

buildRescueBodyInternal

private void buildRescueBodyInternal(IRScope s,
                                     Node node,
                                     Variable rv,
                                     Label endLabel)

buildRetry

public Operand buildRetry(Node node,
                          IRScope s)

buildReturn

public Operand buildReturn(ReturnNode returnNode,
                           IRScope s)

buildEvalRoot

public IREvalScript buildEvalRoot(StaticScope staticScope,
                                  IRScope containingScope,
                                  java.lang.String file,
                                  int lineNumber,
                                  RootNode rootNode)

buildRoot

public IRScope buildRoot(RootNode rootNode)

buildSelf

public Operand buildSelf(Node node,
                         IRScope s)

buildSplat

public Operand buildSplat(SplatNode splatNode,
                          IRScope s)

buildStr

public Operand buildStr(StrNode strNode,
                        IRScope s)

buildSuperInstr

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

buildSuper

public Operand buildSuper(SuperNode superNode,
                          IRScope s)

buildSuperInScriptBody

private Operand buildSuperInScriptBody(IRScope s)

buildSValue

public Operand buildSValue(SValueNode node,
                           IRScope s)

buildSymbol

public Operand buildSymbol(SymbolNode node,
                           IRScope s)

buildToAry

public Operand buildToAry(ToAryNode node,
                          IRScope s)

buildTrue

public Operand buildTrue(Node node,
                         IRScope s)

buildUndef

public Operand buildUndef(Node node,
                          IRScope s)

buildConditionalLoop

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

buildUntil

public Operand buildUntil(UntilNode untilNode,
                          IRScope s)

buildVAlias

public Operand buildVAlias(Node node,
                           IRScope s)

buildVCall

public Operand buildVCall(VCallNode node,
                          IRScope s)

buildWhile

public Operand buildWhile(WhileNode whileNode,
                          IRScope s)

buildXStr

public Operand buildXStr(XStrNode node,
                         IRScope s)

buildYield

public Operand buildYield(YieldNode node,
                          IRScope s)

buildZArray

public Operand buildZArray(Node node,
                           IRScope s)

buildZSuper
```
public Operand buildZSuper(ZSuperNode zsuperNode,
                           IRScope s)
```
private Operand[] getZSuperArgs(IRScope s) { if (s instanceof IRMethod) return ((IRMethod)s).getCallArgs(); Operand[] sArgs = s.getNearestMethod().getCallArgs(); // Update args to make them accessible at a different depth int n = ((IRClosure)s).getNestingDepth(); for (int i = 0; i < sArgs.length; i++) { Operand arg = sArgs[i]; sArgs[i] = (arg instanceof Splat) ? new Splat(((LocalVariable)((Splat)arg).getArray()).cloneForDepth(n)) : ((LocalVariable)arg).cloneForDepth(n); } return sArgs; }

Class IRBuilder

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NO_ARGS

U_NIL

rubyVersion

_ensureBlockStack

_rescueBlockStack

_lastProcessedLineNum

loopStack

manager

Constructor Detail

IRBuilder

Method Detail

setRubyVersion

is1_9

is2_0

buildOperand

getCurrentLoop

buildAST

createIRBuilder

hasListener

newIRBuilder

skipOverNewlines

build

buildVersionSpecificNodes

getSelf

copyAndReturnValue

getValueInTemporaryVariable

buildCallArgs

setupCallArgs

buildVersionSpecificAssignment

buildAssignment

getBlockArgVariable

receiveBlockArg

buildVersionSpecificBlockArgsAssignment

buildBlockArgsAssignment

buildAlias

buildAnd

buildArray

buildArgsCat

buildArgsPush

buildAttrAssign

buildAttrAssignAssignment

buildBackref

buildBegin

buildBignum

buildBlock

buildBreak

handleNonlocalReturnInMethod

receiveBreakException

buildCall

buildCase

buildClass

buildSClass

buildClassVar

buildClassVarAsgn

buildClassVarDecl

classVarDeclarationContainer

classVarDefinitionContainer

classVarContainer

buildConstDecl

findContainerModule

startingSearchScope

buildConstDeclAssignment

genInheritanceSearchInstrs

searchConstInInheritanceHierarchy

searchConst

buildColon2

buildColon3

protectCodeWithRescue

buildGenericGetDefinitionIR

buildVersionSpecificGetDefinitionIR

buildGetDefinitionBase

buildDefnCheckIfThenPaths

buildDefinitionCheck