Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   ***** BEGIN LICENSE BLOCK *****
   * Version: CPL 1.0/GPL 2.0/LGPL 2.1
   *
   * The contents of this file are subject to the Common Public
   * License Version 1.0 (the "License"); you may not use this file
   * except in compliance with the License. You may obtain a copy of
   * the License at http://www.eclipse.org/legal/cpl-v10.html
   *
  * Software distributed under the License is distributed on an "AS
  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  * implied. See the License for the specific language governing
  * rights and limitations under the License.
  *
  * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
  * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
  * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr>
  * Copyright (C) 2004-2007 Thomas E Enebo <enebo@acm.org>
  * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
  * 
  * Alternatively, the contents of this file may be used under the terms of
  * either of the GNU General Public License Version 2 or later (the "GPL"),
  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the CPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the CPL, the GPL or the LGPL.
  ***** END LICENSE BLOCK *****/
 
 package org.jruby.runtime;
 
The executable body portion of a closure.
 
 public abstract class BlockBody {
     // FIXME: Maybe not best place, but move it to a good home
     public static final int ZERO_ARGS = 0;
     public static final int MULTIPLE_ASSIGNMENT = 1;
     public static final int ARRAY = 2;
     public static final int SINGLE_RESTARG = 3;
 
     public static final String[] EMPTY_PARAMETER_LIST = new String[0];
     
     protected final int argumentType;
 
     public BlockBody(int argumentType) {
         this. = argumentType;
     }
 
     public IRubyObject call(ThreadContext contextIRubyObject[] argsBinding bindingBlock.Type type) {
         args = prepareArgumentsForCall(contextargstype);
 
         return yield(context, RubyArray.newArrayNoCopy(context.runtimeargs), nullnulltruebindingtype);
     }
 
     public IRubyObject call(ThreadContext contextIRubyObject[] argsBinding binding,
             Block.Type typeBlock block) {
         args = prepareArgumentsForCall(contextargstype);
 
         return yield(context, RubyArray.newArrayNoCopy(context.runtimeargs), nullnulltruebindingtypeblock);
     }
 
     public abstract IRubyObject yield(ThreadContext contextIRubyObject valueBinding bindingBlock.Type type);
 
     public abstract IRubyObject yield(ThreadContext contextIRubyObject valueIRubyObject self,
             RubyModule klassboolean aValueBinding bindingBlock.Type type);
 
     // FIXME: This should replace blockless abstract versions of yield above and become abstract.
     // Here to allow incremental replacement. Overriden by subclasses which support it.
     public IRubyObject yield(ThreadContext contextIRubyObject valueIRubyObject self,
             RubyModule klassboolean aValueBinding bindingBlock.Type typeBlock block) {
         return yield(contextvalueselfklassaValuebindingtype);
     }
 
     // FIXME: This should replace blockless abstract versions of yield above and become abstract.
     // Here to allow incremental replacement. Overriden by subclasses which support it.
     public IRubyObject yield(ThreadContext contextIRubyObject value,
             Binding bindingBlock.Type typeBlock block) {
         return yield(contextvaluebindingtype);
     }
 
     public int getArgumentType() {
         return ;
     }
 
     public IRubyObject call(ThreadContext contextBinding bindingBlock.Type type) {
        IRubyObject[] args = .;
        args = prepareArgumentsForCall(contextargstype);
        return yield(context, RubyArray.newArrayNoCopy(context.runtimeargs), nullnulltruebindingtype);
    }
    public IRubyObject call(ThreadContext contextBinding binding,
            Block.Type typeBlock unusedBlock) {
        return call(contextbindingtype);
    }
    public IRubyObject yieldSpecific(ThreadContext contextBinding bindingBlock.Type type) {
        return yield(contextnullnullnulltruebindingtype);
    }
    public IRubyObject call(ThreadContext contextIRubyObject arg0Binding bindingBlock.Type type) {
        IRubyObject[] args = new IRubyObject[] {arg0};
        args = prepareArgumentsForCall(contextargstype);
        return yield(context, RubyArray.newArrayNoCopy(context.runtimeargs), nullnulltruebindingtype);
    }
    public IRubyObject call(ThreadContext contextIRubyObject arg0Binding binding,
            Block.Type typeBlock unusedBlock) {
        return call(contextarg0bindingtype);
    }
    public IRubyObject yieldSpecific(ThreadContext contextIRubyObject arg0Binding bindingBlock.Type type) {
        return yield(contextarg0nullnulltruebindingtype);
    }
    public IRubyObject call(ThreadContext contextIRubyObject arg0IRubyObject arg1Binding bindingBlock.Type type) {
        IRubyObject[] args = new IRubyObject[] {arg0arg1};
        args = prepareArgumentsForCall(contextargstype);
        return yield(context, RubyArray.newArrayNoCopy(context.runtimeargs), nullnulltruebindingtype);
    }
    public IRubyObject call(ThreadContext contextIRubyObject arg0IRubyObject arg1Binding binding,
            Block.Type typeBlock unusedBlock) {
        return call(contextarg0arg1bindingtype);
    }
    public IRubyObject yieldSpecific(ThreadContext contextIRubyObject arg0IRubyObject arg1Binding bindingBlock.Type type) {
        return yield(contextcontext.runtime.newArrayNoCopyLight(arg0arg1), nullnulltruebindingtype);
    }
    public IRubyObject call(ThreadContext contextIRubyObject arg0IRubyObject arg1IRubyObject arg2Binding bindingBlock.Type type) {
        IRubyObject[] args = new IRubyObject[] {arg0arg1arg2};
        args = prepareArgumentsForCall(contextargstype);
        return yield(context, RubyArray.newArrayNoCopy(context.runtimeargs), nullnulltruebindingtype);
    }
    public IRubyObject call(ThreadContext contextIRubyObject arg0IRubyObject arg1IRubyObject arg2Binding binding,
            Block.Type typeBlock unusedBlock) {
        return call(contextarg0arg1arg2bindingtype);
    }
    public IRubyObject yieldSpecific(ThreadContext contextIRubyObject arg0IRubyObject arg1IRubyObject arg2Binding bindingBlock.Type type) {
        return yield(contextcontext.runtime.newArrayNoCopyLight(arg0arg1arg2), nullnulltruebindingtype);
    }
    public abstract StaticScope getStaticScope();
    public abstract void setStaticScope(StaticScope newScope);
    public abstract Block cloneBlock(Binding binding);

    
What is the arity of this block?

Returns:
the arity
    public abstract Arity arity();

    
Is the current block a real yield'able block instead a null one

Returns:
true if this is a valid block or false otherwise
    public boolean isGiven() {
        return true;
    }

    
Get the filename for this block
    public abstract String getFile();

    
get The line number for this block
    public abstract int getLine();

    
Compiled codes way of examining arguments

Parameters:
nodeId to be considered
Returns:
something not linked to AST and a constant to make compiler happy
    public static int asArgumentType(NodeType nodeId) {
        if (nodeId == nullreturn ;
        switch (nodeId) {
        case return ;
        case return ;
        case return ;
        }
        return ;
    }
    public IRubyObject[] prepareArgumentsForCall(ThreadContext contextIRubyObject[] argsBlock.Type type) {
        switch (type) {
        case : {
//            assert false : "can this happen?";
            if (args.length == 1 && args[0] instanceof RubyArray) {
                if ( ==  ||  == ) {
                    args = ((RubyArrayargs[0]).toJavaArray();
                }
                break;
            }
        }
        case : {
            if (args.length == 1 && args[0] instanceof RubyArray) {
                if ( ==  &&  != ) {
                    args = ((RubyArrayargs[0]).toJavaArray();
                }
            }
            break;
        }
        case :
            if ( ==  && args.length != 1) {
                context.runtime.getWarnings().warn(."multiple values for a block parameter (" + args.length + " for " + arity().getValue() + ")");
                if (args.length == 0) {
                    args = context.runtime.getSingleNilArray();
                } else {
                    args = new IRubyObject[] {context.runtime.newArrayNoCopy(args)};
                }
            } else {
                arity().checkArity(context.runtimeargs);
            }
            break;
        }
        return args;
    }
    public String[] getParameterList() {
        return ;
    }
    public static NodeType getArgumentTypeWackyHack(IterNode iterNode) {
        NodeType argsNodeId = null;
        if (iterNode.getVarNode() != null && iterNode.getVarNode().getNodeType() != .) {
            // if we have multiple asgn with just *args, need a special type for that
            argsNodeId = iterNode.getVarNode().getNodeType();
            if (argsNodeId == .) {
                MultipleAsgnNode multipleAsgnNode = (MultipleAsgnNode)iterNode.getVarNode();
                if (multipleAsgnNode.getHeadNode() == null && multipleAsgnNode.getArgsNode() != null) {
                    // FIXME: This is gross. Don't do this.
                    argsNodeId = .;
                }
            }
        }
        return argsNodeId;
    }
    public static final BlockBody NULL_BODY = new NullBlockBody();
New to GrepCode? Check out our FAQ X