Uses of Class
org.jruby.compiler.ir.operands.Operand

Packages that use Operand
org.jruby.compiler.ir   
org.jruby.compiler.ir.dataflow   
org.jruby.compiler.ir.instructions   
org.jruby.compiler.ir.operands   
org.jruby.compiler.ir.targets   
 

Uses of Operand in org.jruby.compiler.ir
 

Fields in org.jruby.compiler.ir declared as Operand
 Operand IR_Class._superClass
           
 

Methods in org.jruby.compiler.ir that return Operand
 Operand IR_Builder.build(Node node, IR_Scope m)
           
 Operand IR_Builder.buildAlias(AliasNode alias, IR_Scope s)
           
 Operand IR_Builder.buildAnd(AndNode andNode, IR_Scope m)
           
 Operand IR_Builder.buildArgsCat(ArgsCatNode argsCatNode, IR_Scope s)
           
 Operand IR_Builder.buildArgsPush(ArgsPushNode node, IR_Scope m)
           
 Operand IR_Builder.buildArray(Node node, IR_Scope m)
           
 Operand IR_Builder.buildAttrAssignAssignment(Node node, IR_Scope s, Operand value)
           
 Operand IR_Builder.buildBackref(BackRefNode node, IR_Scope m)
           
 Operand IR_Builder.buildBegin(BeginNode beginNode, IR_Scope s)
           
 Operand IR_Builder.buildBignum(BignumNode node, IR_Scope s)
           
 Operand IR_Builder.buildBlock(BlockNode node, IR_Scope s)
           
 Operand IR_Builder.buildBreak(BreakNode breakNode, IR_Scope s)
           
 Operand IR_Builder.buildCall(CallNode callNode, IR_Scope s)
           
 Operand IR_Builder.buildCase(CaseNode caseNode, IR_Scope m)
           
 Operand IR_Builder.buildClass(ClassNode classNode, IR_Scope s)
           
 Operand IR_Builder.buildClassVar(ClassVarNode node, IR_Scope s)
          public Operand buildSClass(Node node, IR_Scope m) { final SClassNode sclassNode = (SClassNode) node; CompilerCallback receiverCallback = new CompilerCallback() { public void call(IR_Scope m) { build(sclassNode.getReceiverNode(), m, true); } }; CompilerCallback bodyCallback = new CompilerCallback() { public void call(IR_Scope m) { if (sclassNode.getBodyNode() != null) { build(sclassNode.getBodyNode(), m, true); } else { m.loadNil(); } } }; m.defineClass("SCLASS", sclassNode.getScope(), null, null, bodyCallback, receiverCallback, inspector); }
 Operand IR_Builder.buildClassVarAsgn(ClassVarAsgnNode classVarAsgnNode, IR_Scope s)
           
 Operand IR_Builder.buildClassVarDecl(ClassVarDeclNode classVarDeclNode, IR_Scope s)
           
 Operand IR_Builder.buildColon2(Colon2Node iVisited, IR_Scope s)
           
 Operand IR_Builder.buildColon3(Colon3Node node, IR_Scope s)
           
 Operand IR_Builder.buildConst(ConstNode node, IR_Scope s)
           
 Operand IR_Builder.buildConstDecl(ConstDeclNode node, IR_Scope s)
           
 Operand IR_Builder.buildConstDeclAssignment(ConstDeclNode constDeclNode, IR_Scope s, Operand val)
           
 Operand IR_Builder.buildDAsgn(DAsgnNode dasgnNode, IR_Scope s)
          public Operand buildGetDefinitionBase(final Node node, IR_Scope m) { switch (node.getNodeType()) { case CLASSVARASGNNODE: case CLASSVARDECLNODE: case CONSTDECLNODE: case DASGNNODE: case GLOBALASGNNODE: case LOCALASGNNODE: case MULTIPLEASGNNODE: case OPASGNNODE: case OPELEMENTASGNNODE: case DVARNODE: case FALSENODE: case TRUENODE: case LOCALVARNODE: case INSTVARNODE: case BACKREFNODE: case SELFNODE: case VCALLNODE: case YIELDNODE: case GLOBALVARNODE: case CONSTNODE: case FCALLNODE: case CLASSVARNODE: // these are all simple cases that don't require the heavier defined logic buildGetDefinition(node, m); break; default: BranchCallback reg = new BranchCallback() { public void branch(IR_Scope m) { m.inDefined(); buildGetDefinition(node, m); } }; BranchCallback out = new BranchCallback() { public void branch(IR_Scope m) { m.outDefined(); } }; m.protect(reg, out, String.class); } } public Operand buildDefined(final Node node, IR_Scope m) { buildGetDefinitionBase(((DefinedNode) node).getExpressionNode(), m); m.stringOrNil(); } public Operand buildGetArgumentDefinition(final Node node, IR_Scope m, String type) { if (node == null) { return new StringLiteral(type); } else if (node instanceof ArrayNode) { Object endToken = m.getNewEnding(); for (int i = 0; i < ((ArrayNode) node).size(); i++) { Node iterNode = ((ArrayNode) node).get(i); buildGetDefinition(iterNode, m); m.ifNull(endToken); } Operand sl = new StringLiteral(type); Object realToken = m.getNewEnding(); m.go(realToken); m.setEnding(endToken); m.pushNull(); m.setEnding(realToken); } else { buildGetDefinition(node, m); Object endToken = m.getNewEnding(); m.ifNull(endToken); Operand sl = new StringLiteral(type); Object realToken = m.getNewEnding(); m.go(realToken); m.setEnding(endToken); m.pushNull(); m.setEnding(realToken); } } public Operand buildGetDefinition(final Node node, IR_Scope m) { switch (node.getNodeType()) { case CLASSVARASGNNODE: case CLASSVARDECLNODE: case CONSTDECLNODE: case DASGNNODE: case GLOBALASGNNODE: case LOCALASGNNODE: case MULTIPLEASGNNODE: case OPASGNNODE: case OPELEMENTASGNNODE: return new StringLiteral("assignment"); case BACKREFNODE: // SSS FIXME! Operand x = m.backref(); return x instanceof RubyMatchData.class ? new StringLiteral("$" + ((BackRefNode) node).getType()) : Nil.NIL; case DVARNODE: return new StringLiteral("local-variable(in-block)"); case FALSENODE: return new StringLiteral("false"); case TRUENODE: return new StringLiteral("true"); case LOCALVARNODE: return new StringLiteral("local-variable"); case MATCH2NODE: case MATCH3NODE: return new StringLiteral("method"); case NILNODE: return new StringLiteral("nil"); case NTHREFNODE: m.isCaptured(((NthRefNode) node).getMatchNumber(), new BranchCallback() { public void branch(IR_Scope m) { return new StringLiteral("$" + ((NthRefNode) node).getMatchNumber()); } }, new BranchCallback() { public void branch(IR_Scope m) { return Nil.NIL; } }); break; case SELFNODE: return new StringLiteral("self"); case VCALLNODE: m.loadSelf(); m.isMethodBound(((VCallNode) node).getName(), new BranchCallback() { public void branch(IR_Scope m) { return new StringLiteral("method"); } }, new BranchCallback() { public void branch(IR_Scope m) { return Nil.NIL; } }); break; case YIELDNODE: m.hasBlock(new BranchCallback() { public void branch(IR_Scope m) { return new StringLiteral("yield"); } }, new BranchCallback() { public void branch(IR_Scope m) { return Nil.NIL; } }); break; case GLOBALVARNODE: m.isGlobalDefined(((GlobalVarNode) node).getName(), new BranchCallback() { public void branch(IR_Scope m) { return new StringLiteral("global-variable"); } }, new BranchCallback() { public void branch(IR_Scope m) { return Nil.NIL; } }); break; case INSTVARNODE: m.isInstanceVariableDefined(((InstVarNode) node).getName(), new BranchCallback() { public void branch(IR_Scope m) { return new StringLiteral("instance-variable"); } }, new BranchCallback() { public void branch(IR_Scope m) { return Nil.NIL; } }); break; case CONSTNODE: m.isConstantDefined(((ConstNode) node).getName(), new BranchCallback() { public void branch(IR_Scope m) { return new StringLiteral("constant"); } }, new BranchCallback() { public void branch(IR_Scope m) { return Nil.NIL; } }); break; case FCALLNODE: m.loadSelf(); m.isMethodBound(((FCallNode) node).getName(), new BranchCallback() { public void branch(IR_Scope m) { buildGetArgumentDefinition(((FCallNode) node).getArgsNode(), m, "method"); } }, new BranchCallback() { public void branch(IR_Scope m) { return Nil.NIL; } }); break; case COLON3NODE: case COLON2NODE: { final Colon3Node iVisited = (Colon3Node) node; final String name = iVisited.getName(); BranchCallback setup = new BranchCallback() { public void branch(IR_Scope m) { if (iVisited instanceof Colon2Node) { final Node leftNode = ((Colon2Node) iVisited).getLeftNode(); build(leftNode, m,true); } else { m.loadObject(); } } }; BranchCallback isConstant = new BranchCallback() { public void branch(IR_Scope m) { return new StringLiteral("constant"); } }; BranchCallback isMethod = new BranchCallback() { public void branch(IR_Scope m) { return new StringLiteral("method"); } }; BranchCallback none = new BranchCallback() { public void branch(IR_Scope m) { return Nil.NIL; } }; m.isConstantBranch(setup, isConstant, isMethod, none, name); break; } case CALLNODE: { final CallNode iVisited = (CallNode) node; Object isnull = m.getNewEnding(); Object ending = m.getNewEnding(); buildGetDefinition(iVisited.getReceiverNode(), m); m.ifNull(isnull); m.rescue(new BranchCallback() { public void branch(IR_Scope m) { build(iVisited.getReceiverNode(), m,true); //[IRubyObject] m.duplicateCurrentValue(); //[IRubyObject, IRubyObject] m.metaclass(); //[IRubyObject, RubyClass] m.duplicateCurrentValue(); //[IRubyObject, RubyClass, RubyClass] m.getVisibilityFor(iVisited.getName()); //[IRubyObject, RubyClass, Visibility] m.duplicateCurrentValue(); //[IRubyObject, RubyClass, Visibility, Visibility] final Object isfalse = m.getNewEnding(); Object isreal = m.getNewEnding(); Object ending = m.getNewEnding(); m.isPrivate(isfalse, 3); //[IRubyObject, RubyClass, Visibility] m.isNotProtected(isreal, 1); //[IRubyObject, RubyClass] m.selfIsKindOf(isreal); //[IRubyObject] m.consumeCurrentValue(); m.go(isfalse); m.setEnding(isreal); //[] m.isMethodBound(iVisited.getName(), new BranchCallback() { public void branch(IR_Scope m) { buildGetArgumentDefinition(iVisited.getArgsNode(), m, "method"); } }, new BranchCallback() { public void branch(IR_Scope m) { m.go(isfalse); } }); m.go(ending); m.setEnding(isfalse); m.pushNull(); m.setEnding(ending); } }, JumpException.class, new BranchCallback() { public void branch(IR_Scope m) { m.pushNull(); } }, String.class); // m.swapValues(); //m.consumeCurrentValue(); m.go(ending); m.setEnding(isnull); m.pushNull(); m.setEnding(ending); break; } case CLASSVARNODE: { ClassVarNode iVisited = (ClassVarNode) node; final Object ending = m.getNewEnding(); final Object failure = m.getNewEnding(); final Object singleton = m.getNewEnding(); Object second = m.getNewEnding(); Object third = m.getNewEnding(); m.loadCurrentModule(); //[RubyClass] m.duplicateCurrentValue(); //[RubyClass, RubyClass] m.ifNotNull(second); //[RubyClass] m.consumeCurrentValue(); //[] m.loadSelf(); //[self] m.metaclass(); //[RubyClass] m.duplicateCurrentValue(); //[RubyClass, RubyClass] m.isClassVarDefined(iVisited.getName(), new BranchCallback() { public void branch(IR_Scope m) { m.consumeCurrentValue(); Operand sl = new StringLiteral("class variable"); m.go(ending); } }, new BranchCallback() { public void branch(IR_Scope m) { } }); m.setEnding(second); //[RubyClass] m.duplicateCurrentValue(); m.isClassVarDefined(iVisited.getName(), new BranchCallback() { public void branch(IR_Scope m) { m.consumeCurrentValue(); Operand sl = new StringLiteral("class variable"); m.go(ending); } }, new BranchCallback() { public void branch(IR_Scope m) { } }); m.setEnding(third); //[RubyClass] m.duplicateCurrentValue(); //[RubyClass, RubyClass] m.ifSingleton(singleton); //[RubyClass] m.consumeCurrentValue();//[] m.go(failure); m.setEnding(singleton); m.attached();//[RubyClass] m.notIsModuleAndClassVarDefined(iVisited.getName(), failure); //[] Operand sl = new StringLiteral("class variable"); m.go(ending); m.setEnding(failure); m.pushNull(); m.setEnding(ending); } break; case ZSUPERNODE: { Object fail = m.getNewEnding(); Object fail2 = m.getNewEnding(); Object fail_easy = m.getNewEnding(); Object ending = m.getNewEnding(); m.getFrameName(); //[String] m.duplicateCurrentValue(); //[String, String] m.ifNull(fail); //[String] m.getFrameKlazz(); //[String, RubyClass] m.duplicateCurrentValue(); //[String, RubyClass, RubyClass] m.ifNull(fail2); //[String, RubyClass] m.superClass(); m.ifNotSuperMethodBound(fail_easy); Operand sl = new StringLiteral("super"); m.go(ending); m.setEnding(fail2); m.consumeCurrentValue(); m.setEnding(fail); m.consumeCurrentValue(); m.setEnding(fail_easy); m.pushNull(); m.setEnding(ending); } break; case SUPERNODE: { Object fail = m.getNewEnding(); Object fail2 = m.getNewEnding(); Object fail_easy = m.getNewEnding(); Object ending = m.getNewEnding(); m.getFrameName(); //[String] m.duplicateCurrentValue(); //[String, String] m.ifNull(fail); //[String] m.getFrameKlazz(); //[String, RubyClass] m.duplicateCurrentValue(); //[String, RubyClass, RubyClass] m.ifNull(fail2); //[String, RubyClass] m.superClass(); m.ifNotSuperMethodBound(fail_easy); buildGetArgumentDefinition(((SuperNode) node).getArgsNode(), m, "super"); m.go(ending); m.setEnding(fail2); m.consumeCurrentValue(); m.setEnding(fail); m.consumeCurrentValue(); m.setEnding(fail_easy); m.pushNull(); m.setEnding(ending); break; } case ATTRASSIGNNODE: { final AttrAssignNode iVisited = (AttrAssignNode) node; Object isnull = m.getNewEnding(); Object ending = m.getNewEnding(); buildGetDefinition(iVisited.getReceiverNode(), m); m.ifNull(isnull); m.rescue(new BranchCallback() { public void branch(IR_Scope m) { build(iVisited.getReceiverNode(), m,true); //[IRubyObject] m.duplicateCurrentValue(); //[IRubyObject, IRubyObject] m.metaclass(); //[IRubyObject, RubyClass] m.duplicateCurrentValue(); //[IRubyObject, RubyClass, RubyClass] m.getVisibilityFor(iVisited.getName()); //[IRubyObject, RubyClass, Visibility] m.duplicateCurrentValue(); //[IRubyObject, RubyClass, Visibility, Visibility] final Object isfalse = m.getNewEnding(); Object isreal = m.getNewEnding(); Object ending = m.getNewEnding(); m.isPrivate(isfalse, 3); //[IRubyObject, RubyClass, Visibility] m.isNotProtected(isreal, 1); //[IRubyObject, RubyClass] m.selfIsKindOf(isreal); //[IRubyObject] m.consumeCurrentValue(); m.go(isfalse); m.setEnding(isreal); //[] m.isMethodBound(iVisited.getName(), new BranchCallback() { public void branch(IR_Scope m) { buildGetArgumentDefinition(iVisited.getArgsNode(), m, "assignment"); } }, new BranchCallback() { public void branch(IR_Scope m) { m.go(isfalse); } }); m.go(ending); m.setEnding(isfalse); m.pushNull(); m.setEnding(ending); } }, JumpException.class, new BranchCallback() { public void branch(IR_Scope m) { m.pushNull(); } }, String.class); m.go(ending); m.setEnding(isnull); m.pushNull(); m.setEnding(ending); break; } default: m.rescue(new BranchCallback() { public void branch(IR_Scope m) { build(node, m,true); m.consumeCurrentValue(); m.pushNull(); } }, JumpException.class, new BranchCallback() { public void branch(IR_Scope m) { m.pushNull(); } }, String.class); m.consumeCurrentValue(); //MPS_FIXME: new StringLiteral("expression"); } }
 Operand IR_Builder.buildDefn(MethodDefNode node, IR_Scope s)
           
 Operand IR_Builder.buildDefs(MethodDefNode node, IR_Scope s)
           
 Operand IR_Builder.buildDot(DotNode dotNode, IR_Scope s)
           
 Operand IR_Builder.buildDRegexp(DRegexpNode dregexpNode, IR_Scope s)
           
 Operand IR_Builder.buildDStr(DStrNode dstrNode, IR_Scope s)
           
 Operand IR_Builder.buildDSymbol(Node node, IR_Scope s)
           
 Operand IR_Builder.buildDVar(DVarNode node, IR_Scope m)
           
 Operand IR_Builder.buildDXStr(DXStrNode dstrNode, IR_Scope m)
           
 Operand IR_Builder.buildEvStr(EvStrNode node, IR_Scope s)
          public Operand buildEnsureNode(Node node, IR_Scope m) { final EnsureNode ensureNode = (EnsureNode) node; if (ensureNode.getEnsureNode() != null) { m.performEnsure(new BranchCallback() { public void branch(IR_Scope m) { if (ensureNode.getBodyNode() != null) { build(ensureNode.getBodyNode(), m, true); } else { m.loadNil(); } } }, new BranchCallback() { public void branch(IR_Scope m) { build(ensureNode.getEnsureNode(), m, false); } }); } else { if (ensureNode.getBodyNode() != null) { build(ensureNode.getBodyNode(), m,true); } else { m.loadNil(); } } // TODO: don't require pop if (!expr) m.consumeCurrentValue(); }
 Operand IR_Builder.buildFalse(Node node, IR_Scope s)
           
 Operand IR_Builder.buildFCall(FCallNode fcallNode, IR_Scope s)
           
 Operand IR_Builder.buildFixnum(FixnumNode node, IR_Scope m)
           
 Operand IR_Builder.buildFloat(FloatNode node, IR_Scope m)
          public Operand buildFlip(Node node, IR_Scope m) { final FlipNode flipNode = (FlipNode) node; m.getVariableCompiler().retrieveLocalVariable(flipNode.getIndex(), flipNode.getDepth()); if (flipNode.isExclusive()) { m.performBooleanBranch(new BranchCallback() { public void branch(IR_Scope m) { build(flipNode.getEndNode(), m,true); m.performBooleanBranch(new BranchCallback() { public void branch(IR_Scope m) { m.loadFalse(); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), false); } }, new BranchCallback() { public void branch(IR_Scope m) { } }); m.loadTrue(); } }, new BranchCallback() { public void branch(IR_Scope m) { build(flipNode.getBeginNode(), m,true); becomeTrueOrFalse(m); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), true); } }); } else { m.performBooleanBranch(new BranchCallback() { public void branch(IR_Scope m) { build(flipNode.getEndNode(), m,true); m.performBooleanBranch(new BranchCallback() { public void branch(IR_Scope m) { m.loadFalse(); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), false); } }, new BranchCallback() { public void branch(IR_Scope m) { } }); m.loadTrue(); } }, new BranchCallback() { public void branch(IR_Scope m) { build(flipNode.getBeginNode(), m,true); m.performBooleanBranch(new BranchCallback() { public void branch(IR_Scope m) { build(flipNode.getEndNode(), m,true); flipTrueOrFalse(m); m.getVariableCompiler().assignLocalVariable(flipNode.getIndex(), flipNode.getDepth(), false); m.loadTrue(); } }, new BranchCallback() { public void branch(IR_Scope m) { m.loadFalse(); } }); } }); } // TODO: don't require pop if (!expr) m.consumeCurrentValue(); } private void becomeTrueOrFalse(IR_Scope m) { m.performBooleanBranch(new BranchCallback() { public void branch(IR_Scope m) { m.loadTrue(); } }, new BranchCallback() { public void branch(IR_Scope m) { m.loadFalse(); } }); } private void flipTrueOrFalse(IR_Scope m) { m.performBooleanBranch(new BranchCallback() { public void branch(IR_Scope m) { m.loadFalse(); } }, new BranchCallback() { public void branch(IR_Scope m) { m.loadTrue(); } }); }
 Operand IR_Builder.buildFor(ForNode forNode, IR_Scope m)
           
 Operand IR_Builder.buildForIter(ForNode forNode, IR_Scope s)
           
 Operand IR_Builder.buildGlobalAsgn(GlobalAsgnNode globalAsgnNode, IR_Scope m)
           
 Operand IR_Builder.buildGlobalVar(GlobalVarNode node, IR_Scope m)
           
 Operand IR_Builder.buildHash(HashNode hashNode, IR_Scope m)
           
 Operand IR_Builder.buildIf(IfNode ifNode, IR_Scope s)
           
 Operand IR_Builder.buildInstAsgn(InstAsgnNode instAsgnNode, IR_Scope s)
           
 Operand IR_Builder.buildInstVar(InstVarNode node, IR_Scope m)
           
 Operand IR_Builder.buildIter(IterNode iterNode, IR_Scope s)
           
 Operand IR_Builder.buildLocalAsgn(LocalAsgnNode localAsgnNode, IR_Scope s)
           
 Operand IR_Builder.buildLocalVar(LocalVarNode node, IR_Scope s)
           
 Operand IR_Builder.buildMatch(MatchNode matchNode, IR_Scope m)
           
 Operand IR_Builder.buildMatch2(Match2Node matchNode, IR_Scope m)
           
 Operand IR_Builder.buildMatch3(Match3Node matchNode, IR_Scope m)
           
 Operand IR_Builder.buildModule(ModuleNode moduleNode, IR_Scope s)
           
 Operand IR_Builder.buildMultipleAsgn(MultipleAsgnNode multipleAsgnNode, IR_Scope s)
           
 Operand IR_Builder.buildNewline(NewlineNode node, IR_Scope s)
           
 Operand IR_Builder.buildNext(NextNode nextNode, IR_Scope s)
           
 Operand IR_Builder.buildNil(Node node, IR_Scope m)
           
 Operand IR_Builder.buildNot(NotNode node, IR_Scope m)
           
 Operand IR_Builder.buildNthRef(NthRefNode nthRefNode, IR_Scope m)
           
 Operand IR_Builder.buildOpAsgn(OpAsgnNode opAsgnNode, IR_Scope s)
           
 Operand IR_Builder.buildOpAsgnAnd(OpAsgnAndNode andNode, IR_Scope s)
           
 Operand IR_Builder.buildOpAsgnOr(OpAsgnOrNode orNode, IR_Scope s)
           
 Operand IR_Builder.buildOr(OrNode orNode, IR_Scope m)
          private class OpElementAsgnArgumentsCallback implements ArgumentsCallback { private Node node; public OpElementAsgnArgumentsCallback(Node node) { this.node = node; } public int getArity() { switch (node.getNodeType()) { case ARGSCATNODE: case ARGSPUSHNODE: case SPLATNODE: return -1; case ARRAYNODE: ArrayNode arrayNode = (ArrayNode)node; if (arrayNode.size() == 0) { return 0; } else if (arrayNode.size() > 3) { return -1; } else { return ((ArrayNode)node).size(); } default: return 1; } } public void call(IR_Scope m) { if (getArity() == 1) { // if arity 1, just build the one element to save us the array cost build(((ArrayNode)node).get(0), m,true); } else { // build into array buildArguments(node, m); } } }; public Operand buildOpElementAsgnWithOr(Node node, IR_Scope m) { final OpElementAsgnNode opElementAsgnNode = (OpElementAsgnNode) node; CompilerCallback receiverCallback = new CompilerCallback() { public void call(IR_Scope m) { build(opElementAsgnNode.getReceiverNode(), m); } }; ArgumentsCallback argsCallback = new OpElementAsgnArgumentsCallback(opElementAsgnNode.getArgsNode()); CompilerCallback valueCallback = new CompilerCallback() { public void call(IR_Scope m) { build(opElementAsgnNode.getValueNode(), m, true); } }; m.getInvocationCompiler().opElementAsgnWithOr(receiverCallback, argsCallback, valueCallback); // TODO: don't require pop if (!expr) m.consumeCurrentValue(); } public Operand buildOpElementAsgnWithAnd(Node node, IR_Scope m) { final OpElementAsgnNode opElementAsgnNode = (OpElementAsgnNode) node; CompilerCallback receiverCallback = new CompilerCallback() { public void call(IR_Scope m) { build(opElementAsgnNode.getReceiverNode(), m); } }; ArgumentsCallback argsCallback = new OpElementAsgnArgumentsCallback(opElementAsgnNode.getArgsNode()); CompilerCallback valueCallback = new CompilerCallback() { public void call(IR_Scope m) { build(opElementAsgnNode.getValueNode(), m); } }; m.getInvocationCompiler().opElementAsgnWithAnd(receiverCallback, argsCallback, valueCallback); } public Operand buildOpElementAsgnWithMethod(Node node, IR_Scope m) { final OpElementAsgnNode opElementAsgnNode = (OpElementAsgnNode) node; CompilerCallback receiverCallback = new CompilerCallback() { public void call(IR_Scope m) { build(opElementAsgnNode.getReceiverNode(), m); } }; ArgumentsCallback argsCallback = setupCallArgs(opElementAsgnNode.getArgsNode()); CompilerCallback valueCallback = new CompilerCallback() { public void call(IR_Scope m) { build(opElementAsgnNode.getValueNode(), m); } }; m.getInvocationCompiler().opElementAsgnWithMethod(receiverCallback, argsCallback, valueCallback, opElementAsgnNode.getOperatorName()); }
 Operand IR_Builder.buildRedo(Node node, IR_Scope s)
          public Operand buildPostExe(Node node, IR_Scope m) { final PostExeNode postExeNode = (PostExeNode) node; // create the closure class and instantiate it final CompilerCallback closureBody = new CompilerCallback() { public void call(IR_Scope m) { if (postExeNode.getBodyNode() != null) { build(postExeNode.getBodyNode(), m, true); } else { m.loadNil(); } } }; m.createNewEndBlock(closureBody); } public Operand buildPreExe(Node node, IR_Scope m) { final PreExeNode preExeNode = (PreExeNode) node; // create the closure class and instantiate it final CompilerCallback closureBody = new CompilerCallback() { public void call(IR_Scope m) { if (preExeNode.getBodyNode() != null) { build(preExeNode.getBodyNode(), m,true); } else { m.loadNil(); } } }; m.runBeginBlock(preExeNode.getScope(), closureBody); }
 Operand IR_Builder.buildRegexp(RegexpNode reNode, IR_Scope m)
           
 Operand IR_Builder.buildReturn(ReturnNode returnNode, IR_Scope m)
          public Operand buildRetry(Node node, IR_Scope s) { // JRuby only supports retry when present in rescue blocks! // 1.9 doesn't support retry anywhere else.
 Operand IR_Builder.buildSelf(Node node, IR_Scope s)
           
 Operand IR_Builder.buildSplat(SplatNode splatNode, IR_Scope s)
           
 Operand IR_Builder.buildStr(StrNode strNode, IR_Scope s)
           
 Operand IR_Builder.buildSuper(SuperNode superNode, IR_Scope s)
           
 Operand IR_Builder.buildSValue(SValueNode node, IR_Scope s)
           
 Operand IR_Builder.buildSymbol(SymbolNode node, IR_Scope s)
           
 Operand IR_Builder.buildToAry(ToAryNode node, IR_Scope s)
           
 Operand IR_Builder.buildTrue(Node node, IR_Scope m)
           
 Operand IR_Builder.buildUntil(UntilNode untilNode, IR_Scope s)
           
 Operand IR_Builder.buildVCall(VCallNode node, IR_Scope s)
          public Operand buildVAlias(Node node, IR_Scope m) { VAliasNode valiasNode = (VAliasNode) node; m.aliasGlobal(valiasNode.getNewName(), valiasNode.getOldName()); }
 Operand IR_Builder.buildWhile(WhileNode whileNode, IR_Scope s)
           
 Operand IR_Builder.buildXStr(XStrNode node, IR_Scope m)
           
 Operand IR_Builder.buildYield(YieldNode node, IR_Scope s)
           
 Operand IR_Builder.buildZArray(Node node, IR_Scope m)
           
 Operand IR_Builder.buildZSuper(ZSuperNode zsuperNode, IR_Scope s)
           
 Operand[] IR_Method.getCallArgs()
           
 Operand IR_Scope.getConstantValue(java.lang.String constRef)
           
 Operand IR_ScopeImpl.getConstantValue(java.lang.String constRef)
           
 Operand IR_Script.getFileName()
           
 Operand IR_Scope.getParent()
           
 Operand IR_ScopeImpl.getParent()
           
 Operand IR_Builder.receiveArgs(ArgsNode argsNode, IR_Scope s)
           
 

Methods in org.jruby.compiler.ir that return types with arguments of type Operand
 java.util.List<Operand> IR_Builder.setupCallArgs(Node args, IR_Scope s)
           
 java.util.List<Operand> IR_Builder.setupCallArgs(Node receiver, Node args, IR_Scope s)
           
 

Methods in org.jruby.compiler.ir with parameters of type Operand
 void IR_Builder.buildAssignment(Node node, IR_Scope s, Operand values, int argIndex, boolean isSplat)
           
 Operand IR_Builder.buildAttrAssignAssignment(Node node, IR_Scope s, Operand value)
           
 Operand IR_Builder.buildConstDeclAssignment(ConstDeclNode constDeclNode, IR_Scope s, Operand val)
           
 void IR_Builder.buildMultipleAsgnAssignment(MultipleAsgnNode multipleAsgnNode, IR_Scope s, Operand values)
           
 void IR_Closure.setConstantValue(java.lang.String constRef, Operand val)
           
 void IR_Method.setConstantValue(java.lang.String constRef, Operand val)
           
 void IR_Scope.setConstantValue(java.lang.String constRef, Operand value)
           
 void IR_ScopeImpl.setConstantValue(java.lang.String constRef, Operand val)
           
 

Method parameters in org.jruby.compiler.ir with type arguments of type Operand
 void IR_Builder.buildArgs(java.util.List<Operand> argsList, Node args, IR_Scope s)
           
 void IR_Builder.buildArgsCatArguments(java.util.List<Operand> args, ArgsCatNode argsCatNode, IR_Scope s)
           
 void IR_Builder.buildArgsPushArguments(java.util.List<Operand> args, ArgsPushNode argsPushNode, IR_Scope m)
           
 void IR_Builder.buildArguments(java.util.List<Operand> args, Node node, IR_Scope s)
           
 void IR_Builder.buildArrayArguments(java.util.List<Operand> args, Node node, IR_Scope s)
           
 void IR_Builder.buildSpecificArityArguments(java.util.List<Operand> args, Node node, IR_Scope s)
           
 void IR_Builder.buildSplatArguments(java.util.List<Operand> args, SplatNode node, IR_Scope s)
           
 void IR_Builder.buildVariableArityArguments(java.util.List<Operand> args, Node node, IR_Scope s)
           
 

Constructors in org.jruby.compiler.ir with parameters of type Operand
IR_Class(IR_Scope parent, IR_Scope lexicalParent, Operand superClass, java.lang.String className, boolean isSingleton)
           
IR_Class(Operand parent, IR_Scope lexicalParent, Operand superClass, java.lang.String className, boolean isSingleton)
           
IR_Module(Operand parent, IR_Scope lexicalParent, java.lang.String name)
           
IR_ScopeImpl(Operand parent, IR_Scope lexicalParent)
           
 

Uses of Operand in org.jruby.compiler.ir.dataflow
 

Fields in org.jruby.compiler.ir.dataflow declared as Operand
static Operand DataFlowConstants.ANY
           
static Operand DataFlowConstants.BOTTOM
           
static Operand DataFlowConstants.TOP
           
 

Uses of Operand in org.jruby.compiler.ir.instructions
 

Fields in org.jruby.compiler.ir.instructions declared as Operand
 Operand[] MultiOperandInstr._args
           
 

Methods in org.jruby.compiler.ir.instructions that return Operand
 Operand[] CALL_Instr.getCallArgs()
           
 Operand CALL_Instr.getClosureArg()
           
 Operand CALL_Instr.getMethodAddr()
           
 Operand[] ASSERT_METHOD_VERSION_Instr.getOperands()
           
 Operand[] GET_Instr.getOperands()
           
abstract  Operand[] IR_Instr.getOperands()
           
 Operand[] MultiOperandInstr.getOperands()
           
 Operand[] NoOperandInstr.getOperands()
           
 Operand[] OneOperandInstr.getOperands()
           
 Operand[] PUT_Instr.getOperands()
           
 Operand[] TwoOperandInstr.getOperands()
           
static Operand GET_CVAR_Instr.getParentmostScope(Operand scope)
           
static Operand PUT_CVAR_Instr.getParentmostScope(Operand scope)
           
 Operand CALL_Instr.getReceiver()
           
 Operand COPY_Instr.simplifyAndGetResult(java.util.Map<Operand,Operand> valueMap)
           
 Operand GET_ARRAY_Instr.simplifyAndGetResult(java.util.Map<Operand,Operand> valueMap)
           
 Operand IR_Instr.simplifyAndGetResult(java.util.Map<Operand,Operand> valueMap)
           
 

Methods in org.jruby.compiler.ir.instructions with parameters of type Operand
static Operand GET_CVAR_Instr.getParentmostScope(Operand scope)
           
static Operand PUT_CVAR_Instr.getParentmostScope(Operand scope)
           
 IR_Method CALL_Instr.getTargetMethodWithReceiver(Operand receiver)
           
 

Method parameters in org.jruby.compiler.ir.instructions with type arguments of type Operand
 void CASE_Instr.setVariables(java.util.List<Operand> variables)
           
 Operand COPY_Instr.simplifyAndGetResult(java.util.Map<Operand,Operand> valueMap)
           
 Operand COPY_Instr.simplifyAndGetResult(java.util.Map<Operand,Operand> valueMap)
           
 Operand GET_ARRAY_Instr.simplifyAndGetResult(java.util.Map<Operand,Operand> valueMap)
           
 Operand GET_ARRAY_Instr.simplifyAndGetResult(java.util.Map<Operand,Operand> valueMap)
           
 Operand IR_Instr.simplifyAndGetResult(java.util.Map<Operand,Operand> valueMap)
           
 Operand IR_Instr.simplifyAndGetResult(java.util.Map<Operand,Operand> valueMap)
           
 void ASSERT_METHOD_VERSION_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void ASSERT_METHOD_VERSION_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void CALL_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void CALL_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void CASE_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void CASE_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void GET_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void GET_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
abstract  void IR_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
abstract  void IR_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void MultiOperandInstr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void MultiOperandInstr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void NoOperandInstr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void NoOperandInstr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void OneOperandInstr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void OneOperandInstr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void PUT_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void PUT_Instr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void TwoOperandInstr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 void TwoOperandInstr.simplifyOperands(java.util.Map<Operand,Operand> valueMap)
           
 

Constructors in org.jruby.compiler.ir.instructions with parameters of type Operand
ALU_Instr(Operation op, Variable dst, Operand arg)
           
ALU_Instr(Operation op, Variable dst, Operand arg1, Operand arg2)
           
ATTR_ASSIGN_Instr(Operand obj, Operand attr, Operand value)
           
BEQ_Instr(Operand v1, Operand v2, Label jmpTarget)
           
BRANCH_Instr(Operation op, Operand v1, Operand v2, Label jmpTarget)
           
BREAK_Instr(Operand rv)
           
CALL_Instr(Operation op, Variable result, Operand methAddr, Operand[] args, Operand closure)
           
CALL_Instr(Operation op, Variable result, Operand methAddr, Operand[] args, Operand closure)
           
CALL_Instr(Variable result, Operand methAddr, Operand[] args, Operand closure)
           
CALL_Instr(Variable result, Operand methAddr, Operand[] args, Operand closure)
           
CASE_Instr(Variable result, Operand arg, Label endLabel)
           
CLOSURE_RETURN_Instr(Operand rv)
           
COPY_Instr(Variable d, Operand s)
           
EQQ_Instr(Variable result, Operand v1, Operand v2)
           
GET_ARRAY_Instr(Variable dest, Operand array, int index, boolean getRestOfArray)
           
GET_CONST_Instr(Variable dest, Operand scopeOrObj, java.lang.String constName)
           
GET_CVAR_Instr(Variable dest, Operand scope, java.lang.String varName)
           
GET_FIELD_Instr(Variable dest, Operand obj, java.lang.String fieldName)
           
GET_Instr(Operation op, Variable dest, Operand src, java.lang.String ref)
           
IS_TRUE_Instr(Variable result, Operand arg)
           
JRUBY_IMPL_CALL_Instr(Variable result, Operand methAddr, Operand[] args)
           
JRUBY_IMPL_CALL_Instr(Variable result, Operand methAddr, Operand[] args)
           
JRUBY_IMPL_CALL_Instr(Variable result, Operand methAddr, Operand[] args, Operand closure)
           
JRUBY_IMPL_CALL_Instr(Variable result, Operand methAddr, Operand[] args, Operand closure)
           
MultiOperandInstr(Operation opType, Variable result, Operand[] args)
           
OneOperandInstr(Operation op, Variable dest, Operand arg)
           
PUT_CONST_Instr(IR_Scope scope, java.lang.String constName, Operand val)
           
PUT_CONST_Instr(Operand scopeOrObj, java.lang.String constName, Operand val)
           
PUT_CVAR_Instr(Operand scope, java.lang.String varName, Operand value)
           
PUT_FIELD_Instr(Operand obj, java.lang.String fieldName, Operand value)
           
PUT_GLOBAL_VAR_Instr(java.lang.String varName, Operand value)
           
PUT_Instr(Operation op, Operand target, java.lang.String ref, Operand value)
           
RETURN_Instr(Operand rv)
           
RUBY_INTERNALS_CALL_Instr(Variable result, Operand methAddr, Operand[] args)
           
RUBY_INTERNALS_CALL_Instr(Variable result, Operand methAddr, Operand[] args)
           
RUBY_INTERNALS_CALL_Instr(Variable result, Operand methAddr, Operand[] args, Operand closure)
           
RUBY_INTERNALS_CALL_Instr(Variable result, Operand methAddr, Operand[] args, Operand closure)
           
TwoOperandInstr(Operation op, Variable dest, Operand a1, Operand a2)
           
YIELD_Instr(Variable result, Operand[] args)
           
 

Uses of Operand in org.jruby.compiler.ir.operands
 

Subclasses of Operand in org.jruby.compiler.ir.operands
 class ArgIndex
           
 class Array
           
 class Attribute
           
 class Backref
           
 class BacktickString
           
 class Bignum
           
 class BooleanLiteral
           
 class CompoundArray
           
 class CompoundString
           
 class Constant
           
 class DynamicReference
           
 class DynamicSymbol
           
 class FieldRef
           
 class Fixnum
           
 class Float
           
 class GlobalVariable
           
 class Hash
           
 class Label
           
 class MetaObject
           
 class MethAddr
           
 class Nil
           
 class NthRef
           
 class Range
           
 class Reference
           
 class Regexp
           
 class Splat
           
 class StringLiteral
           
 class SValue
           
 class Symbol
           
 class Variable
           
 

Fields in org.jruby.compiler.ir.operands declared as Operand
 Operand[] Array._elts
           
static Operand[] Operand.EMPTY_ARRAY
           
 

Fields in org.jruby.compiler.ir.operands with type parameters of type Operand
 java.util.List<Operand> BacktickString._pieces
           
 java.util.List<Operand> CompoundString._pieces
           
 

Methods in org.jruby.compiler.ir.operands that return Operand
 Operand Array.fetchCompileTimeArrayElement(int argIndex, boolean getSubArray)
           
 Operand CompoundArray.fetchCompileTimeArrayElement(int argIndex, boolean getSubArray)
           
 Operand Fixnum.fetchCompileTimeArrayElement(int argIndex, boolean getSubArray)
           
 Operand Float.fetchCompileTimeArrayElement(int argIndex, boolean getSubArray)
           
 Operand Nil.fetchCompileTimeArrayElement(int argIndex, boolean getSubArray)
           
 Operand Operand.fetchCompileTimeArrayElement(int index, boolean getSubArray)
           
 Operand Range.fetchCompileTimeArrayElement(int argIndex, boolean getSubArray)
           
 Operand SValue.fetchCompileTimeArrayElement(int argIndex, boolean getSubArray)
           
 Operand Splat.fetchCompileTimeArrayElement(int argIndex, boolean getSubArray)
           
 Operand Array.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Attribute.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand BacktickString.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand CompoundArray.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand CompoundString.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand DynamicReference.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Hash.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Operand.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Range.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Regexp.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand SValue.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Splat.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Variable.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Operand.getValue(java.util.Map<Operand,Operand> valueMap)
           
 Operand Variable.getValue(java.util.Map<Operand,Operand> valueMap)
           
 Operand Array.toArray()
           
 

Method parameters in org.jruby.compiler.ir.operands with type arguments of type Operand
 Operand Array.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Array.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Attribute.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Attribute.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand BacktickString.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand BacktickString.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand CompoundArray.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand CompoundArray.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand CompoundString.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand CompoundString.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand DynamicReference.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand DynamicReference.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Hash.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Hash.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Operand.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Operand.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Range.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Range.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Regexp.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Regexp.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand SValue.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand SValue.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Splat.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Splat.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Variable.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Variable.getSimplifiedOperand(java.util.Map<Operand,Operand> valueMap)
           
 Operand Operand.getValue(java.util.Map<Operand,Operand> valueMap)
           
 Operand Operand.getValue(java.util.Map<Operand,Operand> valueMap)
           
 Operand Variable.getValue(java.util.Map<Operand,Operand> valueMap)
           
 Operand Variable.getValue(java.util.Map<Operand,Operand> valueMap)
           
 

Constructors in org.jruby.compiler.ir.operands with parameters of type Operand
Array(Operand[] elts)
           
BacktickString(Operand val)
           
CompoundArray(Operand a1, Operand a2)
           
KeyValuePair(Operand k, Operand v)
           
Range(Operand b, Operand e)
           
Regexp(Operand re, int opts)
           
Splat(Operand a)
           
SValue(Operand a)
           
 

Constructor parameters in org.jruby.compiler.ir.operands with type arguments of type Operand
Array(java.util.List<Operand> elts)
           
BacktickString(java.util.List<Operand> pieces)
           
CompoundString(java.util.List<Operand> pieces)
           
 

Uses of Operand in org.jruby.compiler.ir.targets
 

Methods in org.jruby.compiler.ir.targets with parameters of type Operand
 void JVM.emit(Operand operand)
           
 



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