Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.runtime;
  
  
     public InterpretedIRBlockBody19(IRClosure closureArity arityint argumentType) {
         super(closurearity, -1);
     }
 
     @Override
     public String[] getParameterList() {
         return this..getParameterList();
     }
 
     private IRubyObject[] convertValueIntoArgArray(ThreadContext contextIRubyObject valueboolean passArrayArgboolean argIsArray) {
         // SSS FIXME: But this should not happen -- so, some places in the runtime library are breaking this contract.
         if (argIsArray && !(value instanceof RubyArray)) argIsArray = false;
 
         int blockArity = arity().getValue();
         switch (blockArity) {
             case 0  : return new IRubyObject[] { value };
             case -1 : return argIsArray ? ((RubyArray)value).toJavaArray() : new IRubyObject[] { value };
             case 1  : {
                if (argIsArray) {
                    RubyArray valArray = ((RubyArray)value);
                    if (valArray.size() == 0) {
                        value = passArrayArg ? RubyArray.newEmptyArray(context.runtime) : context.nil;
                    }
                    else if (!passArrayArgvalue = valArray.eltInternal(0);
                }
                return new IRubyObject[] { value };
             }
             default : 
                 if (argIsArray) {
                     RubyArray valArray = (RubyArray)value;
                     if (valArray.size() == 1) value = valArray.eltInternal(0);
                     value = RuntimeHelpers.aryToAry(value);
                     return (value instanceof RubyArray) ? ((RubyArray)value).toJavaArray() : new IRubyObject[] { value };
                 } else {
                     value = RuntimeHelpers.aryToAry(value);
                     if (!(value instanceof RubyArray)) {
                         throw context.runtime.newTypeError(value.getType().getName() + "#to_ary should return Array");
                     }
                     return ((RubyArray)value).toJavaArray();
                 }
         }
     }
 
     private IRubyObject[] getLambdaArgs(ThreadContext contextIRubyObject valueboolean passArrayArgboolean argIsArray) {
         IRubyObject[] args = (value == null) ? . : (argIsArray ? ((RubyArray)value).toJavaArray() : new IRubyObject[] { value });
         arity().checkArity(context.runtimeargs);
         return args;
     }
 
     private IRubyObject[] getYieldArgs(ThreadContext contextIRubyObject valueboolean passArrayArgboolean argIsArrayType type) {
         if (type == ..) {
             return getLambdaArgs(contextvaluepassArrayArgargIsArray);
         } else {
             return (value == null) ? . : convertValueIntoArgArray(contextvaluepassArrayArgargIsArray);
         }
     }
 
     // SSS: Looks like yieldSpecific and yieldArray need to treat array unwrapping differently.
     // This is a little baffling to me.  I think the runtime library code needs to turn off 
     // the argIsArray flag if it wants an array and not create this artificial distinction
     // between the two.  In any case, it looks like in certain contexts, argIsArray flag is being
     // passed in as true even when the argument is not an array.
     @Override
     public IRubyObject yieldSpecific(ThreadContext contextBinding bindingBlock.Type type) {
         return yieldSpecificInternal(contextnullnullnulltruebindingtype);
     }
     @Override
     public IRubyObject yieldSpecific(ThreadContext contextIRubyObject arg0Binding bindingBlock.Type type) {
         return yieldSpecificInternal(contextarg0nullnulltruebindingtype);
     }
     @Override
     public IRubyObject yieldSpecific(ThreadContext contextIRubyObject arg0IRubyObject arg1Binding bindingBlock.Type type) {
         return yieldSpecificInternal(contextcontext.runtime.newArrayNoCopyLight(arg0arg1), nullnulltruebindingtype);
     }
     @Override
     public IRubyObject yieldSpecific(ThreadContext contextIRubyObject arg0IRubyObject arg1IRubyObject arg2Binding bindingBlock.Type type) {
         return yieldSpecificInternal(contextcontext.runtime.newArrayNoCopyLight(arg0arg1arg2), nullnulltruebindingtype);
     }
 
     private IRubyObject yieldSpecificInternal(ThreadContext contextIRubyObject valueIRubyObject selfRubyModule klassboolean argIsArrayBinding bindingType type) {
 		  // Do not unwrap the array arg
         IRubyObject[] args = getYieldArgs(contextvaluetrueargIsArraytype);
         return commonYieldPath(contextargsselfklassbindingtype.);
     }
 
     @Override
     public IRubyObject yield(ThreadContext contextIRubyObject valueIRubyObject selfRubyModule klassboolean argIsArrayBinding bindingType type) {
 		  // Unwrap the array arg
         IRubyObject[] args = getYieldArgs(contextvaluefalseargIsArraytype);
        return commonYieldPath(contextargsselfklassbindingtype.);
    }
    @Override
    public IRubyObject[] prepareArgumentsForCall(ThreadContext contextIRubyObject[] argsBlock.Type type) {
        if (type == ..) {
            arity().checkArity(context.runtimeargs);
        } else {
            // SSS FIXME: How is it even possible to "call" a NORMAL block?  
            // I thought only procs & lambdas can be called, and blocks are yielded to.
            if (args.length == 1) {
                // Convert value to arg-array, unwrapping where necessary
                args = convertValueIntoArgArray(contextargs[0], true, (type == ..) && (args[0] instanceof RubyArray));
            } else if (arity().getValue() == 1) {
               // discard excess arguments
                args = (args.length == 0) ? context.runtime.getSingleNilArray() : new IRubyObject[] { args[0] };
            }
        }
        return args;
    }
New to GrepCode? Check out our FAQ X