Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.runtime;
  
  import org.jruby.Ruby;
 
 public class InterpretedIRBlockBody extends ContextAwareBlockBody {
     protected final IRClosure closure;
 
     public InterpretedIRBlockBody(IRClosure closureArity arityint argumentType) {
         super(closure.getStaticScope(), arityargumentType);
         this. = closure;
     }
 
     @Override
     public IRubyObject call(ThreadContext contextBinding bindingBlock.Type type) {
         return call(context.bindingtype.);
     }
 
     @Override
     public IRubyObject call(ThreadContext contextIRubyObject arg0Binding bindingBlock.Type type) {
         return call(contextnew IRubyObject[] {arg0}, bindingtype.);
     }
 
     @Override
     public IRubyObject call(ThreadContext contextIRubyObject arg0IRubyObject arg1Binding bindingBlock.Type type) {
         return call(contextnew IRubyObject[] {arg0arg1}, bindingtype.);
     }
 
     @Override
     public IRubyObject call(ThreadContext contextIRubyObject arg0IRubyObject arg1IRubyObject arg2Binding bindingBlock.Type type) {
         return call(contextnew IRubyObject[] {arg0arg1arg2}, bindingtype.);
     }
 
     @Override
     public IRubyObject call(ThreadContext contextIRubyObject[] argsBinding bindingBlock.Type type) {
         return call(contextargsbindingtype.);
     }
 
     @Override
     public IRubyObject call(ThreadContext contextIRubyObject[] argsBinding bindingBlock.Type typeBlock block) {
         return commonYieldPath(contextprepareArgumentsForCall(contextargstype), nullnullbindingtypeblock);
     }
 
     @Override
     public IRubyObject yield(ThreadContext contextIRubyObject valueBinding bindingType type) {
         return yield(contextvaluenullnullfalsebindingtype);
     }
 
     @Override
     public IRubyObject yield(ThreadContext contextIRubyObject valueIRubyObject selfRubyModule klassboolean isArrayBinding bindingType type) {
         IRubyObject[] args;
         if (isArray) {
             if (arity().getValue() > 1) {
                 args = value == null ? . : prepareArgumentsForYield(context, ((RubyArray)value).toJavaArray(), type);
             } else {
                 args = assignArrayToBlockArgs(context.runtimevalue);
             }
         } else {
             args = prepareArgumentsForYield(contextvalue == null ? . : new IRubyObject[] { value }, type);
         }
 
         return commonYieldPath(contextargsselfklassbindingtype.);
     }
 
     protected IRubyObject prepareSelf(Binding binding) {
         IRubyObject self = binding.getSelf();
         binding.getFrame().setSelf(self);
 
         return self;
     }
 
     protected IRubyObject commonYieldPath(ThreadContext contextIRubyObject[] argsIRubyObject selfRubyModule klassBinding bindingType typeBlock block) {
         // SSS: Important!  Use getStaticScope() to use a copy of the static-scope stored in the block-body.
         // Do not use 'closure.getStaticScope()' -- that returns the original copy of the static scope.
         // This matters because blocks created for Thread bodies modify the static-scope field of the block-body
         // that records additional state about the block body.
         //
         // FIXME: Rather than modify static-scope, it seems we ought to set a field in block-body which is then
         // used to tell dynamic-scope that it is a dynamic scope for a thread body.  Anyway, to be revisited later!
         Visibility oldVis = binding.getFrame().getVisibility();
         RubyModule currentModule = getStaticScope().getModule();
 
         Frame prevFrame = context.preYieldNoScope(bindingklass);
         if (klass == nullself = prepareSelf(binding);
         try {
             DynamicScope prevScope = binding.getDynamicScope();
             DynamicScope newScope  = .isForLoopBody() ? prevScope : DynamicScope.newDynamicScope(getStaticScope(), prevScope);
             context.pushScope(newScope);
             return Interpreter.INTERPRET_BLOCK(contextselfargsbinding.getMethod(), blocktype);
         }
         finally {
             binding.getFrame().setVisibility(oldVis);
             context.postYield(bindingprevFrame);
        }
    }
    protected void blockArgWarning(Ruby rubyint length) {
        ruby.getWarnings().warn(."multiple values for a block parameter (" +
                    length + " for 1)");
    }
    
    private IRubyObject prepareArrayArgsForCall(Ruby rubyIRubyObject value) {
        int length = (value instanceof RubyArray) ? ((RubyArray)value).getLength() : 0;
        switch (length) {
        case 0: return ruby.getNil();
        case 1: return ((RubyArray)value).eltInternal(0);
        defaultblockArgWarning(rubylength);
        }
        return value;
    }
    private IRubyObject[] assignArrayToBlockArgs(Ruby rubyIRubyObject value) {
        switch () {
        case :
            return .;
        case :
        case :
            return (value == null) ? . : ((value instanceof RubyArray) ? ((RubyArray)value).toJavaArrayMaybeUnsafe() : new IRubyObject[] { value } );
        default:
            return new IRubyObject[] {prepareArrayArgsForCall(rubyvalue)};
        }
    }
    protected IRubyObject[] convertToRubyArray(ThreadContext contextIRubyObject[] args) {
        return (args.length == 0) ? context.runtime.getSingleNilArray()
                                  : new IRubyObject[] {context.runtime.newArrayNoCopy(args)};
    }
    protected IRubyObject[] prepareArgumentsForYield(ThreadContext contextIRubyObject[] argsBlock.Type type) {
        // SSS FIXME: Hmm .. yield can yield to blocks other than NORMAL block type as well.
        int blockArity = arity().getValue();
        if (args.length == 1) {
            IRubyObject soleArg = args[0];
            if (soleArg instanceof RubyArray) {
                if ( == args = ((RubyArraysoleArg).toJavaArray();
            } else if (blockArity > 1) {
                IRubyObject toAryArg = Helpers.aryToAry(soleArg);
                if (toAryArg instanceof RubyArrayargs = ((RubyArray)toAryArg).toJavaArray();
                else {
                    throw context.runtime.newTypeError(soleArg.getType().getName() + "#to_ary should return Array");
                }
            }
        } else if ( == ) {
            args = convertToRubyArray(contextargs);
        }
        return args;
    }
    @Override
    public IRubyObject[] prepareArgumentsForCall(ThreadContext contextIRubyObject[] argsBlock.Type type) {
        int blockArity = arity().getValue();
        switch (type) {
        // SSS FIXME: How is it even possible to "call" a block?  
        // I thought only procs & lambdas can be called, and blocks are yielded to.
        case 
        case : {
            if (args.length == 1) {
                IRubyObject soleArg = args[0];
                if (soleArg instanceof RubyArray) {
                    if (( == ) || (( == ) && (type == ..))) {
                        args = ((RubyArraysoleArg).toJavaArray();
                    }
                } else if (blockArity > 1) {
                    IRubyObject toAryArg = Helpers.aryToAry(soleArg);
                    if (toAryArg instanceof RubyArrayargs = ((RubyArray)toAryArg).toJavaArray();
                    else {
                        throw context.runtime.newTypeError(soleArg.getType().getName() + "#to_ary should return Array");
                    }
                }
            } else if ( == ) {
                args = convertToRubyArray(contextargs);
            }
            break;
        }
        case :
            if ( ==  && args.length != 1) {
                if (blockArity != args.length) {
                    context.runtime.getWarnings().warn(."multiple values for a block parameter (" + args.length + " for " + blockArity + ")");
                }
                args = convertToRubyArray(contextargs);
            } else {
                arity().checkArity(context.runtimeargs);
            }
            break;
        }
        return args;
    }
    @Override
    public String getFile() {
        return .getFileName();
    }
    @Override
    public int getLine() {
        return .getLineNumber();
    }
New to GrepCode? Check out our FAQ X