org.jruby.compiler.ir
Class IRBuilder

java.lang.Object
  extended by org.jruby.compiler.ir.IRBuilder

public class IRBuilder
extends java.lang.Object


Constructor Summary
IRBuilder()
           
 
Method Summary
 Operand build(Node node, IRScope m)
           
 Operand buildAlias(AliasNode alias, IRScope s)
           
 Operand buildAnd(AndNode andNode, IRScope m)
           
 void buildArgs(java.util.List<Operand> argsList, Node args, IRScope s)
           
 Operand buildArgsCat(ArgsCatNode argsCatNode, IRScope s)
           
 void buildArgsCatArguments(java.util.List<Operand> args, ArgsCatNode argsCatNode, IRScope s)
           
 Operand buildArgsPush(ArgsPushNode node, IRScope m)
           
 void buildArgsPushArguments(java.util.List<Operand> args, ArgsPushNode argsPushNode, IRScope m)
           
 void buildArguments(java.util.List<Operand> args, Node node, IRScope s)
           
 Operand buildArray(Node node, IRScope m)
           
 void buildArrayArguments(java.util.List<Operand> args, Node node, IRScope s)
           
 void buildAssignment(Node node, IRScope s, Operand values, int argIndex, boolean isSplat)
           
static Node buildAST(boolean isCommandLineScript, java.lang.String arg)
           
 Operand buildAttrAssignAssignment(Node node, IRScope s, Operand value)
           
 Operand buildBackref(BackRefNode node, IRScope m)
           
 Operand buildBegin(BeginNode beginNode, IRScope s)
           
 Operand buildBignum(BignumNode node, IRScope s)
           
 Operand buildBlock(BlockNode node, IRScope s)
           
 void buildBlockArgsAssignment(Node node, IRScope s, int argIndex, boolean isSplat)
           
 Operand buildBreak(BreakNode breakNode, IRExecutionScope s)
           
 Operand buildCall(CallNode callNode, IRScope s)
           
 Operand buildCase(CaseNode caseNode, IRScope m)
           
 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 buildConstDecl(ConstDeclNode node, IRScope s)
           
 Operand buildConstDeclAssignment(ConstDeclNode constDeclNode, IRScope s, Operand val)
           
 Operand buildDAsgn(DAsgnNode dasgnNode, IRScope s)
           
 Operand buildDefined(Node node, IRScope m)
           
 Operand buildDefn(MethodDefNode node, IRScope s)
           
 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(Node node, IRScope s)
           
 Operand buildDVar(DVarNode node, IRScope m)
           
 Operand buildDXStr(DXStrNode dstrNode, IRScope m)
           
 Operand buildEnsureNode(Node node, IRScope m)
           
 Operand buildEvStr(EvStrNode node, IRScope s)
           
 Operand buildFalse(Node node, IRScope s)
           
 Operand buildFCall(FCallNode fcallNode, IRScope s)
           
 Operand buildFixnum(FixnumNode node, IRScope m)
           
 Operand buildFloat(FloatNode node, IRScope m)
          public Operand buildFlip(Node node, IRScope m) { final FlipNode flipNode = (FlipNode) node; m.getVariableCompiler().retrieveLocalVariable(flipNode.getIndex(), flipNode.getDepth()); if (flipNode.isExclusive()) { m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { build(flipNode.getEndNode(), m,true); m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { m.loadFalse(); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), false); } }, new BranchCallback() { public void branch(IRScope m) { } }); m.loadTrue(); } }, new BranchCallback() { public void branch(IRScope m) { build(flipNode.getBeginNode(), m,true); becomeTrueOrFalse(m); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), true); } }); } else { m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { build(flipNode.getEndNode(), m,true); m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { m.loadFalse(); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), false); } }, new BranchCallback() { public void branch(IRScope m) { } }); m.loadTrue(); } }, new BranchCallback() { public void branch(IRScope m) { build(flipNode.getBeginNode(), m,true); m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { build(flipNode.getEndNode(), m,true); flipTrueOrFalse(m); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), false); m.loadTrue(); } }, new BranchCallback() { public void branch(IRScope m) { m.loadFalse(); } }); } }); } // TODO: don't require pop if (!expr) m.consumeCurrentValue(); } private void becomeTrueOrFalse(IRScope m) { m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { m.loadTrue(); } }, new BranchCallback() { public void branch(IRScope m) { m.loadFalse(); } }); } private void flipTrueOrFalse(IRScope m) { m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { m.loadFalse(); } }, new BranchCallback() { public void branch(IRScope m) { m.loadTrue(); } }); }
 Operand buildFor(ForNode forNode, IRExecutionScope m)
           
 Operand buildForIter(ForNode forNode, IRExecutionScope s)
           
 Operand buildGetArgumentDefinition(Node node, IRScope m, java.lang.String type)
           
 Operand buildGetDefinition(Node node, IRScope s)
           
 Operand buildGetDefinitionBase(Node node, IRScope m)
           
 Operand buildGlobalAsgn(GlobalAsgnNode globalAsgnNode, IRScope m)
           
 Operand buildGlobalVar(GlobalVarNode node, IRScope m)
           
 Operand buildHash(HashNode hashNode, IRScope m)
           
 Operand buildIf(IfNode ifNode, IRScope s)
           
 Operand buildInstAsgn(InstAsgnNode instAsgnNode, IRScope s)
           
 Operand buildInstVar(InstVarNode node, IRScope m)
           
 Operand buildIter(IterNode iterNode, IRExecutionScope s)
           
 Operand buildLiteral(LiteralNode literalNode, IRScope s)
           
 Operand buildLocalAsgn(LocalAsgnNode localAsgnNode, IRScope s)
           
 Operand buildLocalVar(LocalVarNode node, IRScope s)
           
 Operand buildMatch(MatchNode matchNode, IRScope m)
           
 Operand buildMatch2(Match2Node matchNode, IRScope m)
           
 Operand buildMatch3(Match3Node matchNode, IRScope m)
           
 Operand buildModule(ModuleNode moduleNode, IRScope s)
           
 Operand buildMultipleAsgn(MultipleAsgnNode multipleAsgnNode, IRScope s)
           
 void buildMultipleAsgnAssignment(MultipleAsgnNode multipleAsgnNode, IRScope s, Operand values)
           
 Operand buildNewline(NewlineNode node, IRScope s)
           
 Operand buildNext(NextNode nextNode, IRExecutionScope s)
           
 Operand buildNil(Node node, IRScope m)
           
 Operand buildNot(NotNode node, IRScope m)
           
 Operand buildNthRef(NthRefNode nthRefNode, IRScope m)
           
 Operand buildOpAsgn(OpAsgnNode opAsgnNode, IRScope s)
           
 Operand buildOpAsgnAnd(OpAsgnAndNode andNode, IRScope s)
           
 Operand buildOpAsgnOr(OpAsgnOrNode orNode, IRScope s)
           
 Operand buildOpElementAsgn(Node node, IRScope m)
           
 Operand buildOpElementAsgnWithAnd(Node node, IRScope s)
           
 Operand buildOpElementAsgnWithMethod(Node node, IRScope s)
           
 Operand buildOpElementAsgnWithOr(Node node, IRScope s)
           
 Operand buildOr(OrNode orNode, IRScope m)
           
 Operand buildRedo(Node node, IRExecutionScope s)
          public Operand buildPostExe(Node node, IRScope m) { final PostExeNode postExeNode = (PostExeNode) node; // create the closure class and instantiate it final CompilerCallback closureBody = new CompilerCallback() { public void call(IRScope m) { if (postExeNode.getBodyNode() != null) { build(postExeNode.getBodyNode(), m, true); } else { m.loadNil(); } } }; m.createNewEndBlock(closureBody); } public Operand buildPreExe(Node node, IRScope m) { final PreExeNode preExeNode = (PreExeNode) node; // create the closure class and instantiate it final CompilerCallback closureBody = new CompilerCallback() { public void call(IRScope m) { if (preExeNode.getBodyNode() != null) { build(preExeNode.getBodyNode(), m,true); } else { m.loadNil(); } } }; m.runBeginBlock(preExeNode.getScope(), closureBody); }
 Operand buildRegexp(RegexpNode reNode, IRScope m)
           
 Operand buildRescue(Node node, IRScope m)
           
 Operand buildRetry(Node node, IRScope s)
           
 Operand buildReturn(ReturnNode returnNode, IRScope m)
           
 IRScope buildRoot(RootNode rootNode)
           
 Operand buildSClass(SClassNode sclassNode, IRScope s)
           
 Operand buildSelf(Node node, IRScope s)
           
 void buildSpecificArityArguments(java.util.List<Operand> args, Node node, IRScope s)
           
 Operand buildSplat(SplatNode splatNode, IRScope s)
           
 void buildSplatArguments(java.util.List<Operand> args, SplatNode node, IRScope s)
           
 Operand buildStr(StrNode strNode, IRScope s)
           
 Operand buildSuper(SuperNode superNode, IRScope s)
           
 Operand buildSValue(SValueNode node, IRScope s)
           
 Operand buildSymbol(SymbolNode node, IRScope s)
           
 Operand buildToAry(ToAryNode node, IRScope s)
           
 Operand buildTrue(Node node, IRScope m)
           
 java.lang.String buildType(Node typeNode)
           
 Operand buildUndef(Node node, IRScope m)
           
 Operand buildUntil(UntilNode untilNode, IRExecutionScope s)
           
 Operand buildVAlias(Node node, IRScope m)
           
 void buildVariableArityArguments(java.util.List<Operand> args, Node node, IRScope s)
           
 Operand buildVCall(VCallNode node, IRScope s)
           
 Operand buildWhile(WhileNode whileNode, IRExecutionScope s)
           
 Operand buildXStr(XStrNode node, IRScope m)
           
 Operand buildYield(YieldNode node, IRScope s)
           
 Operand buildZArray(Node node, IRScope m)
           
 Operand buildZSuper(ZSuperNode zsuperNode, IRScope s)
           
 Operand generateJRubyUtilityCall(IRScope m, MethAddr meth, Operand receiver, Operand[] args)
           
static void main(java.lang.String[] args)
           
 void receiveArgs(ArgsNode argsNode, IRScope s)
           
 java.util.List<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
 

Constructor Detail

IRBuilder

public IRBuilder()
Method Detail

main

public static void main(java.lang.String[] args)

buildAST

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

skipOverNewlines

public Node skipOverNewlines(IRScope s,
                             Node n)

generateJRubyUtilityCall

public Operand generateJRubyUtilityCall(IRScope m,
                                        MethAddr meth,
                                        Operand receiver,
                                        Operand[] args)

build

public Operand build(Node node,
                     IRScope m)

buildArguments

public void buildArguments(java.util.List<Operand> args,
                           Node node,
                           IRScope s)

buildVariableArityArguments

public void buildVariableArityArguments(java.util.List<Operand> args,
                                        Node node,
                                        IRScope s)

buildSpecificArityArguments

public void buildSpecificArityArguments(java.util.List<Operand> args,
                                        Node node,
                                        IRScope s)

setupCallArgs

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

buildArgs

public void buildArgs(java.util.List<Operand> argsList,
                      Node args,
                      IRScope s)

buildAssignment

public void buildAssignment(Node node,
                            IRScope s,
                            Operand values,
                            int argIndex,
                            boolean isSplat)

buildBlockArgsAssignment

public void buildBlockArgsAssignment(Node node,
                                     IRScope s,
                                     int argIndex,
                                     boolean isSplat)

buildAlias

public Operand buildAlias(AliasNode alias,
                          IRScope s)

buildAnd

public Operand buildAnd(AndNode andNode,
                        IRScope m)

buildArray

public Operand buildArray(Node node,
                          IRScope m)

buildArgsCat

public Operand buildArgsCat(ArgsCatNode argsCatNode,
                            IRScope s)

buildArgsPush

public Operand buildArgsPush(ArgsPushNode node,
                             IRScope m)

buildAttrAssignAssignment

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

buildBackref

public Operand buildBackref(BackRefNode node,
                            IRScope m)

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,
                          IRExecutionScope s)

buildCall

public Operand buildCall(CallNode callNode,
                         IRScope s)

buildCase

public Operand buildCase(CaseNode caseNode,
                         IRScope m)

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)

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)

buildGetDefinitionBase

public Operand buildGetDefinitionBase(Node node,
                                      IRScope m)

buildDefined

public Operand buildDefined(Node node,
                            IRScope m)

buildGetArgumentDefinition

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

buildGetDefinition

public Operand buildGetDefinition(Node node,
                                  IRScope s)

buildDAsgn

public Operand buildDAsgn(DAsgnNode dasgnNode,
                          IRScope s)

buildDefn

public Operand buildDefn(MethodDefNode node,
                         IRScope s)

buildDefs

public Operand buildDefs(DefsNode node,
                         IRScope s)

receiveArgs

public void receiveArgs(ArgsNode argsNode,
                        IRScope s)

buildType

public java.lang.String buildType(Node typeNode)

buildDot

public Operand buildDot(DotNode dotNode,
                        IRScope s)

buildDRegexp

public Operand buildDRegexp(DRegexpNode dregexpNode,
                            IRScope s)

buildDStr

public Operand buildDStr(DStrNode dstrNode,
                         IRScope s)

buildDSymbol

public Operand buildDSymbol(Node node,
                            IRScope s)

buildDVar

public Operand buildDVar(DVarNode node,
                         IRScope m)

buildDXStr

public Operand buildDXStr(DXStrNode dstrNode,
                          IRScope m)

buildEnsureNode

public Operand buildEnsureNode(Node node,
                               IRScope m)

buildEvStr

public Operand buildEvStr(EvStrNode node,
                          IRScope s)

buildFalse

public Operand buildFalse(Node node,
                          IRScope s)

buildFCall

public Operand buildFCall(FCallNode fcallNode,
                          IRScope s)

buildFixnum

public Operand buildFixnum(FixnumNode node,
                           IRScope m)

buildFloat

public Operand buildFloat(FloatNode node,
                          IRScope m)
public Operand buildFlip(Node node, IRScope m) { final FlipNode flipNode = (FlipNode) node; m.getVariableCompiler().retrieveLocalVariable(flipNode.getIndex(), flipNode.getDepth()); if (flipNode.isExclusive()) { m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { build(flipNode.getEndNode(), m,true); m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { m.loadFalse(); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), false); } }, new BranchCallback() { public void branch(IRScope m) { } }); m.loadTrue(); } }, new BranchCallback() { public void branch(IRScope m) { build(flipNode.getBeginNode(), m,true); becomeTrueOrFalse(m); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), true); } }); } else { m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { build(flipNode.getEndNode(), m,true); m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { m.loadFalse(); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), false); } }, new BranchCallback() { public void branch(IRScope m) { } }); m.loadTrue(); } }, new BranchCallback() { public void branch(IRScope m) { build(flipNode.getBeginNode(), m,true); m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { build(flipNode.getEndNode(), m,true); flipTrueOrFalse(m); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), false); m.loadTrue(); } }, new BranchCallback() { public void branch(IRScope m) { m.loadFalse(); } }); } }); } // TODO: don't require pop if (!expr) m.consumeCurrentValue(); } private void becomeTrueOrFalse(IRScope m) { m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { m.loadTrue(); } }, new BranchCallback() { public void branch(IRScope m) { m.loadFalse(); } }); } private void flipTrueOrFalse(IRScope m) { m.performBooleanBranch(new BranchCallback() { public void branch(IRScope m) { m.loadFalse(); } }, new BranchCallback() { public void branch(IRScope m) { m.loadTrue(); } }); }


buildFor

public Operand buildFor(ForNode forNode,
                        IRExecutionScope m)

buildForIter

public Operand buildForIter(ForNode forNode,
                            IRExecutionScope s)

buildGlobalAsgn

public Operand buildGlobalAsgn(GlobalAsgnNode globalAsgnNode,
                               IRScope m)

buildGlobalVar

public Operand buildGlobalVar(GlobalVarNode node,
                              IRScope m)

buildHash

public Operand buildHash(HashNode hashNode,
                         IRScope m)

buildIf

public Operand buildIf(IfNode ifNode,
                       IRScope s)

buildInstAsgn

public Operand buildInstAsgn(InstAsgnNode instAsgnNode,
                             IRScope s)

buildInstVar

public Operand buildInstVar(InstVarNode node,
                            IRScope m)

buildIter

public Operand buildIter(IterNode iterNode,
                         IRExecutionScope 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 m)

buildMatch2

public Operand buildMatch2(Match2Node matchNode,
                           IRScope m)

buildMatch3

public Operand buildMatch3(Match3Node matchNode,
                           IRScope m)

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 values)

buildNewline

public Operand buildNewline(NewlineNode node,
                            IRScope s)

buildNext

public Operand buildNext(NextNode nextNode,
                         IRExecutionScope s)

buildNthRef

public Operand buildNthRef(NthRefNode nthRefNode,
                           IRScope m)

buildNil

public Operand buildNil(Node node,
                        IRScope m)

buildNot

public Operand buildNot(NotNode node,
                        IRScope m)

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(Node node,
                                  IRScope m)

buildOpElementAsgnWithOr

public Operand buildOpElementAsgnWithOr(Node node,
                                        IRScope s)

buildOpElementAsgnWithAnd

public Operand buildOpElementAsgnWithAnd(Node node,
                                         IRScope s)

buildOpElementAsgnWithMethod

public Operand buildOpElementAsgnWithMethod(Node node,
                                            IRScope s)

buildOr

public Operand buildOr(OrNode orNode,
                       IRScope m)

buildRedo

public Operand buildRedo(Node node,
                         IRExecutionScope s)
public Operand buildPostExe(Node node, IRScope m) { final PostExeNode postExeNode = (PostExeNode) node; // create the closure class and instantiate it final CompilerCallback closureBody = new CompilerCallback() { public void call(IRScope m) { if (postExeNode.getBodyNode() != null) { build(postExeNode.getBodyNode(), m, true); } else { m.loadNil(); } } }; m.createNewEndBlock(closureBody); } public Operand buildPreExe(Node node, IRScope m) { final PreExeNode preExeNode = (PreExeNode) node; // create the closure class and instantiate it final CompilerCallback closureBody = new CompilerCallback() { public void call(IRScope m) { if (preExeNode.getBodyNode() != null) { build(preExeNode.getBodyNode(), m,true); } else { m.loadNil(); } } }; m.runBeginBlock(preExeNode.getScope(), closureBody); }


buildRegexp

public Operand buildRegexp(RegexpNode reNode,
                           IRScope m)

buildRescue

public Operand buildRescue(Node node,
                           IRScope m)

buildRetry

public Operand buildRetry(Node node,
                          IRScope s)

buildReturn

public Operand buildReturn(ReturnNode returnNode,
                           IRScope m)

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)

buildSuper

public Operand buildSuper(SuperNode superNode,
                          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 m)

buildUndef

public Operand buildUndef(Node node,
                          IRScope m)

buildUntil

public Operand buildUntil(UntilNode untilNode,
                          IRExecutionScope s)

buildVAlias

public Operand buildVAlias(Node node,
                           IRScope m)

buildVCall

public Operand buildVCall(VCallNode node,
                          IRScope s)

buildWhile

public Operand buildWhile(WhileNode whileNode,
                          IRExecutionScope s)

buildXStr

public Operand buildXStr(XStrNode node,
                         IRScope m)

buildYield

public Operand buildYield(YieldNode node,
                          IRScope s)

buildZArray

public Operand buildZArray(Node node,
                           IRScope m)

buildZSuper

public Operand buildZSuper(ZSuperNode zsuperNode,
                           IRScope s)

buildArgsCatArguments

public void buildArgsCatArguments(java.util.List<Operand> args,
                                  ArgsCatNode argsCatNode,
                                  IRScope s)

buildArgsPushArguments

public void buildArgsPushArguments(java.util.List<Operand> args,
                                   ArgsPushNode argsPushNode,
                                   IRScope m)

buildArrayArguments

public void buildArrayArguments(java.util.List<Operand> args,
                                Node node,
                                IRScope s)

buildSplatArguments

public void buildSplatArguments(java.util.List<Operand> args,
                                SplatNode node,
                                IRScope s)


Copyright © 2002-2009 JRuby Team. All Rights Reserved.