IRBuilder (JRuby Core 9.0.0.0.pre1 API)

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

```
public class IRBuilder
extends Object
```

Field Summary

Fields
Modifier and Type Field and Description

protected IRManager manager

Fields
Modifier and Type	Field and Description
`protected IRManager`	`manager`

Constructor Summary

Constructors
Constructor and Description

IRBuilder(IRManager manager)

Constructors
Constructor and Description
`IRBuilder(IRManager manager)`

Method Summary

Methods
Modifier and Type	Method and Description
`static Operand[]`	`addArg(Operand[] args, Operand extraArg)`
`void`	`addInstr(IRScope s, Instr i)`
`void`	`addInstrAtBeginning(IRScope s, Instr i)`
`Operand`	`build(Node node, IRScope s)`
`Operand`	`buildAlias(AliasNode alias, IRScope s)`
`Operand`	`buildAnd(AndNode andNode, IRScope s)`
`Operand`	`buildArgsCat(ArgsCatNode argsCatNode, IRScope s)`
`void`	`buildArgsMasgn(Node node, IRScope s, Operand argsArray, boolean isMasgnRoot, int preArgsCount, int postArgsCount, int index, boolean isSplat)`
`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, String arg)`
`Operand`	`buildAttrAssignAssignment(Node node, IRScope s, Operand value)`
`protected Operand`	`buildAttrAssignCallArgs(List<Operand> argsList, Node args, IRScope s)`
`Operand`	`buildBackref(BackRefNode node, IRScope s)`
`Operand`	`buildBegin(BeginNode beginNode, IRScope s)`
`Operand`	`buildBignum(BignumNode node)`
`Operand`	`buildBlock(BlockNode node, IRScope s)`
`void`	`buildBlockArgsAssignment(Node node, IRScope s, Operand argsArray, int argIndex, boolean isSplat)`
`Operand`	`buildBreak(BreakNode breakNode, IRScope s)`
`Operand`	`buildCall(CallNode callNode, IRScope s)`
`protected Operand[]`	`buildCallArgs(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)`
`Operand`	`buildComplex(ComplexNode node, IRScope s)`
`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, 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 node, IRScope s)`
`Operand`	`buildDStr(DStrNode node, IRScope s)`
`Operand`	`buildDSymbol(DSymbolNode node, IRScope s)`
`Operand`	`buildDVar(DVarNode node, IRScope s)`
`Operand`	`buildDXStr(DXStrNode dstrNode, IRScope s)`
`Operand`	`buildEncoding(EncodingNode node, IRScope s)`
`Operand`	`buildEnsureNode(EnsureNode ensureNode, IRScope s)`
`IREvalScript`	`buildEvalRoot(StaticScope staticScope, IRScope containingScope, String file, int lineNumber, RootNode rootNode, EvalType evalType)`
`Operand`	`buildEvStr(EvStrNode node, IRScope s)`
`Operand`	`buildFalse()`
`Operand`	`buildFCall(FCallNode fcallNode, IRScope s)`
`Operand`	`buildFixnum(FixnumNode node)`
`Operand`	`buildFlip(FlipNode flipNode, IRScope s)`
`Operand`	`buildFloat(FloatNode node)`
`Operand`	`buildFor(ForNode forNode, IRScope s)`
`Operand`	`buildForIter(ForNode forNode, IRScope s)`
`Operand`	`buildGetArgumentDefinition(Node node, IRScope s, String type)`
`Operand`	`buildGetDefinition(Node node, IRScope scope)`
`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`	`buildLambda(LambdaNode node, 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)`
`Operand`	`buildMultipleAsgn19(MultipleAsgn19Node multipleAsgnNode, IRScope s)`
`void`	`buildMultipleAsgn19Assignment(MultipleAsgn19Node multipleAsgnNode, IRScope s, Operand argsArray, Operand values)`
`void`	`buildMultipleAsgnAssignment(MultipleAsgnNode multipleAsgnNode, IRScope s, Operand argsArray, Operand values)`
`Operand`	`buildNewline(NewlineNode node, IRScope s)`
`Operand`	`buildNext(NextNode nextNode, IRScope s)`
`Operand`	`buildNil()`
`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)`
`Operand`	`buildOr(OrNode orNode, IRScope s)`
`Operand`	`buildPostExe(PostExeNode postExeNode, IRScope s)`
`Operand`	`buildPreExe(PreExeNode preExeNode, IRScope s)`
`Operand`	`buildRational(RationalNode rationalNode)`
`Operand`	`buildRedo(IRScope s)`
`Operand`	`buildRegexp(RegexpNode reNode, IRScope s)`
`Operand`	`buildRescue(RescueNode node, IRScope s)`
`Operand`	`buildRetry(IRScope s)`
`Operand`	`buildReturn(ReturnNode returnNode, IRScope s)`
`IRScriptBody`	`buildRoot(RootNode rootNode)`
`Operand`	`buildSClass(SClassNode sclassNode, IRScope s)`
`Operand`	`buildSelf(IRScope s)`
`Operand`	`buildSplat(SplatNode splatNode, IRScope s)`
`Operand`	`buildStr(StrNode strNode, IRScope s)`
`Operand`	`buildSuper(SuperNode superNode, IRScope s)`
`Operand`	`buildSValue(SValueNode node, IRScope s)`
`Operand`	`buildSymbol(SymbolNode node)`
`Operand`	`buildTrue()`
`Operand`	`buildUndef(Node node, IRScope s)`
`Operand`	`buildUntil(UntilNode untilNode, IRScope s)`
`Operand`	`buildVAlias(VAliasNode valiasNode, IRScope s)`
`Operand`	`buildVCall(VCallNode node, IRScope s)`
`void`	`buildVersionSpecificAssignment(Node node, IRScope s, Variable v)`
`void`	`buildVersionSpecificBlockArgsAssignment(Node node, IRScope s)`
`Operand`	`buildWhile(WhileNode whileNode, IRScope s)`
`Operand`	`buildXStr(XStrNode node, IRScope s)`
`Operand`	`buildYield(YieldNode node, IRScope s)`
`Operand`	`buildZArray(IRScope s)`
`Operand`	`buildZSuper(ZSuperNode zsuperNode, IRScope s)`
`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)`
`protected IRMethod`	`defineMethodInner(MethodDefNode defNode, IRMethod method, IRScope parent)`
`protected LocalVariable`	`getArgVariable(IRScope s, String name, int depth)`
`protected LocalVariable`	`getBlockArgVariable(IRScope s, String name, int depth)`
`org.jruby.ir.IRBuilder.IRLoop`	`getCurrentLoop()`
`protected Variable`	`getValueInTemporaryVariable(IRScope s, Operand val)`
`static IRBuilder`	`newIRBuilder(IRManager manager)`
`void`	`receiveArgs(ArgsNode argsNode, IRScope s)` Process all arguments specified for this scope.
`protected void`	`receiveBlockArg(ArgsNode argsNode, IRScope s)` 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(IRScope s, Variable v, Operand argsArray, int argIndex, boolean isSplat)`
`void`	`receiveBlockArgs(IterNode node, IRScope s)`
`void`	`receiveMethodArgs(ArgsNode argsNode, IRMethod s)`
`protected void`	`receiveNonBlockArgs(ArgsNode argsNode, IRScope s)`
`void`	`receiveRequiredArg(Node node, IRScope s, int argIndex, boolean post, int numPreReqd, int numPostRead)`
`Operand[]`	`setupCallArgs(Node args, IRScope s)`
`Node`	`skipOverNewlines(IRScope s, Node n)`

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

Field Detail
- manager
```
protected IRManager manager
```

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

Method Detail

createIRBuilder

public static IRBuilder createIRBuilder(Ruby runtime,
                        IRManager manager)

buildAST

public static Node buildAST(boolean isCommandLineScript,
            String arg)

getCurrentLoop

public org.jruby.ir.IRBuilder.IRLoop getCurrentLoop()

addInstr

public void addInstr(IRScope s,
            Instr i)

addInstrAtBeginning

public void addInstrAtBeginning(IRScope s,
                       Instr i)

newIRBuilder

public static IRBuilder newIRBuilder(IRManager manager)

skipOverNewlines

public Node skipOverNewlines(IRScope s,
                    Node n)

build

public Operand build(Node node,
            IRScope s)

buildLambda

public Operand buildLambda(LambdaNode node,
                  IRScope s)

buildEncoding

public Operand buildEncoding(EncodingNode node,
                    IRScope s)

buildMultipleAsgn19

public Operand buildMultipleAsgn19(MultipleAsgn19Node multipleAsgnNode,
                          IRScope s)

copyAndReturnValue

protected Variable copyAndReturnValue(IRScope s,
                          Operand val)

getValueInTemporaryVariable

protected Variable getValueInTemporaryVariable(IRScope s,
                                   Operand val)

buildAttrAssignCallArgs

protected Operand buildAttrAssignCallArgs(List<Operand> argsList,
                              Node args,
                              IRScope s)

buildCallArgs

protected Operand[] buildCallArgs(Node args,
                      IRScope s)

setupCallArgs

public Operand[] setupCallArgs(Node args,
                      IRScope s)

addArg

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

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 s,
                                String name,
                                int depth)

receiveBlockArg

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

buildVersionSpecificBlockArgsAssignment

public void buildVersionSpecificBlockArgsAssignment(Node node,
                                           IRScope s)

buildBlockArgsAssignment

public void buildBlockArgsAssignment(Node node,
                            IRScope s,
                            Operand argsArray,
                            int argIndex,
                            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)

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)

buildBlock

public Operand buildBlock(BlockNode node,
                 IRScope s)

buildBreak

public Operand buildBreak(BreakNode breakNode,
                 IRScope s)

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)

buildConstDeclAssignment

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

buildColon2

public Operand buildColon2(Colon2Node iVisited,
                  IRScope s)

buildColon3

public Operand buildColon3(Colon3Node node,
                  IRScope s)

buildComplex

public Operand buildComplex(ComplexNode node,
                   IRScope s)

buildGetDefinition

public Operand buildGetDefinition(Node node,
                         IRScope scope)

buildDefnCheckIfThenPaths

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

buildDefinitionCheck

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

buildGetArgumentDefinition

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

buildDAsgn

public Operand buildDAsgn(DAsgnNode dasgnNode,
                 IRScope s)

defineMethodInner

protected IRMethod defineMethodInner(MethodDefNode defNode,
                         IRMethod method,
                         IRScope parent)

buildDefn

public Operand buildDefn(MethodDefNode node,
                IRScope s)

buildDefs

public Operand buildDefs(DefsNode node,
                IRScope s)

getArgVariable

protected LocalVariable getArgVariable(IRScope s,
                           String name,
                           int depth)

receiveRequiredArg

public void receiveRequiredArg(Node node,
                      IRScope s,
                      int argIndex,
                      boolean post,
                      int numPreReqd,
                      int numPostRead)

receiveNonBlockArgs

protected void receiveNonBlockArgs(ArgsNode argsNode,
                       IRScope s)

receiveBlockArg
```
protected void receiveBlockArg(ArgsNode argsNode,
                   IRScope s)
```
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
s - the scope to which we are adding instructions

receiveArgs
```
public void receiveArgs(ArgsNode argsNode,
               IRScope s)
```
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
s - the scope to which we are adding instructions

buildArgsMasgn

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

buildMultipleAsgn19Assignment

public void buildMultipleAsgn19Assignment(MultipleAsgn19Node multipleAsgnNode,
                                 IRScope s,
                                 Operand argsArray,
                                 Operand values)

receiveMethodArgs

public void receiveMethodArgs(ArgsNode argsNode,
                     IRMethod s)

receiveBlockArgs

public void receiveBlockArgs(IterNode node,
                    IRScope s)

buildDot

public Operand buildDot(DotNode dotNode,
               IRScope s)

buildDRegexp

public Operand buildDRegexp(DRegexpNode node,
                   IRScope s)

buildDStr

public Operand buildDStr(DStrNode node,
                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()
```

buildFCall

public Operand buildFCall(FCallNode fcallNode,
                 IRScope s)

buildFixnum

public Operand buildFixnum(FixnumNode node)

buildFlip

public Operand buildFlip(FlipNode flipNode,
                IRScope s)

buildFloat

public Operand buildFloat(FloatNode node)

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)

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

buildOpAsgn

public Operand buildOpAsgn(OpAsgnNode opAsgnNode,
                  IRScope s)

buildOpAsgnAnd

public Operand buildOpAsgnAnd(OpAsgnAndNode andNode,
                     IRScope s)

buildOpAsgnOr

public Operand buildOpAsgnOr(OpAsgnOrNode orNode,
                    IRScope s)

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)

buildRational

public Operand buildRational(RationalNode rationalNode)

buildRedo
```
public Operand buildRedo(IRScope s)
```

buildRegexp

public Operand buildRegexp(RegexpNode reNode,
                  IRScope s)

buildRescue

public Operand buildRescue(RescueNode node,
                  IRScope s)

buildRetry
```
public Operand buildRetry(IRScope s)
```

buildReturn

public Operand buildReturn(ReturnNode returnNode,
                  IRScope s)

buildEvalRoot

public IREvalScript buildEvalRoot(StaticScope staticScope,
                         IRScope containingScope,
                         String file,
                         int lineNumber,
                         RootNode rootNode,
                         EvalType evalType)

buildRoot

public IRScriptBody buildRoot(RootNode rootNode)

buildSelf
```
public Operand buildSelf(IRScope s)
```

buildSplat

public Operand buildSplat(SplatNode splatNode,
                 IRScope s)

buildStr

public Operand buildStr(StrNode strNode,
               IRScope s)

buildSuper

public Operand buildSuper(SuperNode superNode,
                 IRScope s)

buildSValue

public Operand buildSValue(SValueNode node,
                  IRScope s)

buildSymbol

public Operand buildSymbol(SymbolNode node)

buildTrue
```
public Operand buildTrue()
```

buildUndef

public Operand buildUndef(Node node,
                 IRScope s)

buildUntil

public Operand buildUntil(UntilNode untilNode,
                 IRScope s)

buildVAlias

public Operand buildVAlias(VAliasNode valiasNode,
                  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(IRScope s)

buildZSuper

public Operand buildZSuper(ZSuperNode zsuperNode,
                  IRScope s)

Class IRBuilder

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

manager

Constructor Detail

IRBuilder

Method Detail

createIRBuilder

buildAST

getCurrentLoop

addInstr

addInstrAtBeginning

newIRBuilder

skipOverNewlines

build

buildLambda

buildEncoding

buildMultipleAsgn19

copyAndReturnValue

getValueInTemporaryVariable

buildAttrAssignCallArgs

buildCallArgs

setupCallArgs

addArg

buildVersionSpecificAssignment

buildAssignment

getBlockArgVariable

receiveBlockArg

buildVersionSpecificBlockArgsAssignment

buildBlockArgsAssignment

buildAlias

buildAnd

buildArray

buildArgsCat

buildArgsPush

buildAttrAssignAssignment

buildBackref

buildBegin

buildBignum

buildBlock

buildBreak

buildCall

buildCase

buildClass

buildSClass

buildClassVar

buildClassVarAsgn

buildClassVarDecl

classVarDeclarationContainer

classVarDefinitionContainer

classVarContainer

buildConstDecl

buildConstDeclAssignment

buildColon2

buildColon3

buildComplex

buildGetDefinition

buildDefnCheckIfThenPaths

buildDefinitionCheck

buildGetArgumentDefinition

buildDAsgn

defineMethodInner

buildDefn

buildDefs

getArgVariable

receiveRequiredArg

receiveNonBlockArgs

receiveBlockArg

receiveArgs

buildArgsMasgn

buildMultipleAsgn19Assignment

receiveMethodArgs

receiveBlockArgs

buildDot

buildDRegexp

buildDStr

buildDSymbol