Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.compiler.impl;
  
 import  org.objectweb.asm.Label;
 import static org.jruby.util.CodegenUtils.*;
 
 public class ChildScopedBodyCompiler extends BaseBodyCompiler {
 
     public ChildScopedBodyCompiler(StandardASMCompiler scriptCompilerString closureMethodNameString rubyNameASTInspector inspectorStaticScope scope) {
         super(scriptCompilerclosureMethodNamerubyNameinspectorscope);
     }
 
     @Override
     protected int getActualArgsCount(StaticScope scope) {
         // always 1, since we pass in an Array (1.8) or an IRubyObject[] (1.9)
         return 1;
     }
 
     protected String getSignature() {
         return StandardASMCompiler.getStaticClosureSignature(.getClassname());
     }
 
     protected void createVariableCompiler() {
         if ( == null) {
         } else if (.hasClosure() || .hasScopeAwareMethods()) {
         } else {
         }
     }
 
     public void beginMethod(CompilerCallback argsStaticScope scope) {
         .start();
 
         if (scope == null) {
             // not using a new scope, use saved one for a flat closure
             .beginFlatClosure(argsthis.);
         } else {
             // normal closure
             .beginClosure(argsscope);
         }
          = new Label();
         .label();
     }
 
     public void beginClass(CompilerCallback bodyPrepStaticScope scope) {
         throw new NotCompilableException("ERROR: closure compiler should not be used for class bodies");
     }
 
     public ChainedChildBodyCompiler outline(String methodName) {
         // chain to the next segment of this giant method
 
         // load all arguments straight through
         for (int i = 1; i <= 4; i++) {
             .aload(i);
         }
         // we append an index to ensure two identical method names will not conflict
         // TODO: make this match general method name structure with SYNTHETIC in place
         methodName = "chained_" + .getAndIncrementMethodIndex() + "_" + methodName;
         .invokestatic(.getClassname(), methodNamegetSignature());
 
         ChainedChildBodyCompiler methodCompiler = new ChainedChildBodyCompiler(methodNamethis);
 
         methodCompiler.beginChainedMethod();
 
         return methodCompiler;
     }
 
     public void endBody() {
         // end of scoping for closure's vars
         .areturn();
         .label();
 
         // we only need full-on redo exception handling if there's logic that might produce it
         if ( == null || .hasScopeAwareMethods()) {
             // handle redos by restarting the block
             .pop();
             .go_to();
 
             .trycatch(p(JumpException.RedoJump.class));
         }
 
         // method is done, declare all variables
 
         .end();
     }
 
     @Override
     public void loadBlock() {
        loadThreadContext();
        invokeThreadContext("getFrameBlock"sig(Block.class));
    }
    public void performReturn() {
        loadThreadContext();
        invokeUtilityMethod("throwReturnJump"sig(IRubyObject.classIRubyObject.classThreadContext.class));
    }
    public void issueBreakEvent(CompilerCallback value) {
        if ( != null) {
            value.call(this);
            issueLoopBreak();
        } else {
            loadThreadContext();
            value.call(this);
            invokeUtilityMethod("breakJump"sig(IRubyObject.classThreadContext.classIRubyObject.class));
        }
    }
    public void issueNextEvent(CompilerCallback value) {
        if ( != null) {
            value.call(this);
            issueLoopNext();
        } else {
            value.call(this);
            invokeUtilityMethod("nextJump"sig(IRubyObject.classIRubyObject.class));
        }
    }
    public void issueRedoEvent() {
        // FIXME: This isn't right for within ensured/rescued code
        if ( != null) {
            issueLoopRedo();
        } else if () {
            invokeUtilityMethod("redoJump"sig(IRubyObject.class));
        } else {
            // jump back to the top of the main body of this closure
            .go_to();
        }
    }
    public boolean isSimpleRoot() {
        return false;
    }
New to GrepCode? Check out our FAQ X