org.jruby.runtime.Block Maven / Gradle / Ivy
/*
***** BEGIN LICENSE BLOCK *****
* Version: EPL 2.0/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Eclipse Public
* License Version 2.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/epl-v20.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
* Copyright (C) 2001-2004 Jan Arne Petersen
* Copyright (C) 2002 Benoit Cerrina
* Copyright (C) 2004-2007 Thomas E Enebo
* Copyright (C) 2004 Stefan Matthias Aust
*
* 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 EPL, 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 EPL, the GPL or the LGPL.
***** END LICENSE BLOCK *****/
////////////////////////////////////////////////////////////////////////////////
// NOTE: THIS FILE IS GENERATED! DO NOT EDIT THIS FILE!
// generated from: src/org/jruby/runtime/Block.erb
// using arities: src/org/jruby/runtime/Block.arities.erb
////////////////////////////////////////////////////////////////////////////////
package org.jruby.runtime;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import org.jruby.EvalType;
import org.jruby.RubyProc;
import org.jruby.ir.runtime.IRRuntimeHelpers;
import org.jruby.runtime.builtin.IRubyObject;
import org.jruby.util.func.FunctionOneOrTwoOrThree;
import org.jruby.util.func.TriFunction;
/**
* Internal live representation of a block ({...} or do ... end).
*/
public class Block implements FunctionOneOrTwoOrThree {
public enum Type {
NORMAL(false), PROC(false), LAMBDA(true), THREAD(false);
Type(boolean checkArity) {
this.checkArity = checkArity;
}
public final boolean checkArity;
}
/**
* The Proc that this block is associated with. When we reference blocks via variable
* reference they are converted to Proc objects. We store a reference of the associated
* Proc object for easy conversion.
*/
private RubyProc proc = null;
public final Type type;
private final Binding binding;
private final BlockBody body;
/** Whether this block and any clones of it should be considered "escaped" */
private boolean escaped;
/** What block to use for determining escape; defaults to this */
private final Block escapeBlock;
private final EvalType evalType;
/**
* All Block variables should either refer to a real block or this NULL_BLOCK.
*/
public static final Block NULL_BLOCK = new Block(BlockBody.NULL_BODY, new Binding(null, new Frame(), Visibility.PUBLIC));
static {
// Ensure dummy frame is updated with NULL_BLOCK since it may clinit first.
NULL_BLOCK.getBinding().getFrame().updateFrame(null, null, "", NULL_BLOCK);
}
private Block(BlockBody body, Binding binding, Type type, Block escapeBlock, EvalType evalType) {
assert binding != null;
this.body = body;
this.binding = binding;
this.type = type;
this.escapeBlock = escapeBlock;
this.evalType = evalType;
}
public Block(BlockBody body, Binding binding, Type type) {
assert binding != null;
this.body = body;
this.binding = binding;
this.type = type;
this.escapeBlock = this;
this.evalType = EvalType.NONE;
}
public Block(BlockBody body, Binding binding) {
this(body, binding, Type.NORMAL);
}
public Block(BlockBody body) {
this(body, Block.NULL_BLOCK.getBinding(), Type.NORMAL);
}
public DynamicScope allocScope(DynamicScope parentScope) {
// 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!
DynamicScope newScope = DynamicScope.newDynamicScope(body.getStaticScope(), parentScope, evalType);
if (type == Block.Type.LAMBDA) newScope.setLambda(true);
return newScope;
}
public EvalType getEvalType() {
return evalType;
}
public IRubyObject call(ThreadContext context, IRubyObject[] args) {
return body.call(context, this, args);
}
public IRubyObject call(ThreadContext context, IRubyObject[] args, Block blockArg) {
return body.call(context, this, args, blockArg);
}
public IRubyObject call(ThreadContext context) {
return body.call(context, this);
}
public IRubyObject call(ThreadContext context, Block blockArg) {
return body.call(context, this, blockArg);
}
public IRubyObject yieldSpecific(ThreadContext context) {
return body.yieldSpecific(context, this);
}
public IRubyObject call(ThreadContext context, IRubyObject arg0) {
return body.call(context, this, arg0);
}
public IRubyObject call(ThreadContext context, IRubyObject arg0, Block blockArg) {
return body.call(context, this, arg0, blockArg);
}
public IRubyObject yieldSpecific(ThreadContext context, IRubyObject arg0) {
return body.yieldSpecific(context, this, arg0);
}
public IRubyObject call(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
return body.call(context, this, arg0, arg1);
}
public IRubyObject call(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block blockArg) {
return body.call(context, this, arg0, arg1, blockArg);
}
public IRubyObject yieldSpecific(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
return body.yieldSpecific(context, this, arg0, arg1);
}
public IRubyObject call(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2) {
return body.call(context, this, arg0, arg1, arg2);
}
public IRubyObject call(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block blockArg) {
return body.call(context, this, arg0, arg1, arg2, blockArg);
}
public IRubyObject yieldSpecific(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2) {
return body.yieldSpecific(context, this, arg0, arg1, arg2);
}
public IRubyObject yield(ThreadContext context, IRubyObject value) {
return body.yield(context, this, value);
}
/**
* @see Function#apply(Object)
*/
public IRubyObject apply(ThreadContext context) {
return call(context);
}
/**
* @see BiFunction#apply(Object, Object)
*/
public IRubyObject apply(ThreadContext context, IRubyObject arg0) {
return call(context, arg0);
}
/**
* @see TriFunction#apply(Object, Object, Object)
*/
public IRubyObject apply(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
return call(context, arg0, arg1);
}
// PROC/NORMAL/THREAD will spread a single argument array if the block expects more than one required argument.
// This should be the only argument massaging in yield. This handles all argument conversion logic except
// for the generic Block#yield(IRubyObject value).
private static IRubyObject[] maybeSpreadArgs(ThreadContext context, IRubyObject[] args, Block block) {
return block.type != Type.LAMBDA && args.length == 1 && block.getSignature().isSpreadable() ?
IRRuntimeHelpers.toAry(context, args) :
args;
}
public IRubyObject yieldNonArray(ThreadContext context, IRubyObject value, IRubyObject self) {
IRubyObject[] args = maybeSpreadArgs(context, new IRubyObject[] { value }, this);
return body.yield(context, this, args, self);
}
public IRubyObject yieldArray(ThreadContext context, IRubyObject value, IRubyObject self) {
IRubyObject[] args = maybeSpreadArgs(context, IRRuntimeHelpers.singleBlockArgToArray(value), this);
return body.yield(context, this, args, self);
}
public IRubyObject yieldValues(ThreadContext context, IRubyObject[] args) {
return body.yield(context, this, maybeSpreadArgs(context, args, this), null);
}
public Block cloneBlock() {
return cloneBlockAsType(type);
}
public Block cloneBlockAsType(Type newType) {
return new Block(body, binding, newType, this, evalType);
}
public Block cloneBlockAndBinding() {
return cloneBlockAndBinding(evalType);
}
public Block cloneBlockAndBinding(EvalType evalType) {
return new Block(body, binding.clone(), type, this, evalType);
}
public Block cloneBlockAndFrame() {
return cloneBlockAndFrame(EvalType.NONE);
}
public Block cloneBlockAndFrame(EvalType evalType) {
Binding oldBinding = binding;
Binding binding = new Binding(
oldBinding.getSelf(),
oldBinding.getFrame().duplicate(),
oldBinding.getVisibility(),
oldBinding.getDynamicScope(),
oldBinding.getMethod(),
oldBinding.getFile(),
oldBinding.getLine());
return new Block(body, binding, type, this, evalType);
}
public Block cloneBlockForEval(IRubyObject self, EvalType evalType) {
Block block = new Block(body, binding, type, this, evalType);
block.getBinding().setSelf(self);
block.getBinding().getFrame().setSelf(self);
return block;
}
public Block deepCloneBlockForEval(IRubyObject self, EvalType evalType) {
Block block = cloneBlockAndBinding(evalType);
block.getBinding().setSelf(self);
block.getBinding().getFrame().setSelf(self);
return block;
}
/**
* What is the arity of this block?
*
* @return the arity
*/
@Deprecated
public Arity arity() {
return getSignature().arity();
}
public Signature getSignature() {
return body.getSignature();
}
/**
* Retrieve the proc object associated with this block
*
* @return the proc or null if this has no proc associated with it
*/
public RubyProc getProcObject() {
return proc;
}
/**
* Set the proc object associated with this block
*
* @param procObject
*/
public void setProcObject(RubyProc procObject) {
this.proc = procObject;
}
/**
* Is the current block a real yield'able block instead a null one
*
* @return true if this is a valid block or false otherwise
*/
public final boolean isGiven() {
return this != NULL_BLOCK;
}
public Binding getBinding() {
return binding;
}
public BlockBody getBody() {
return body;
}
/**
* Gets the frame.
*
* @return Returns a RubyFrame
*/
public Frame getFrame() {
return binding.getFrame();
}
public boolean isEscaped() {
return escapeBlock.escaped;
}
public void escape() {
escapeBlock.escaped = true;
}
public Visibility getVisibility() {
return binding.getFrame().getVisibility();
}
public void setVisibility(Visibility vis) {
binding.getFrame().setVisibility(vis);
}
@Override
public boolean equals(Object other) {
if ( this == other ) return true;
if ( ! ( other instanceof Block ) ) return false;
final Block that = (Block) other;
return this.binding.equals(that.binding) && this.body == that.body;
}
@Override
public int hashCode() {
int hash = 11;
hash = 13 * hash + Objects.hashCode(this.binding);
hash = 17 * hash + Objects.hashCode(this.body);
return hash;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy