// XXX: Again, screwy evaling under previous frame's scope
public void preExecuteUnder(RubyModule executeUnderClass, Block block) {
Frame frame = getCurrentFrame();
pushRubyClass(executeUnderClass);
DynamicScope scope = getCurrentScope();
StaticScope sScope = new BlockStaticScope(scope.getStaticScope());
sScope.setModule(executeUnderClass);
pushScope(DynamicScope.newDynamicScope(sScope, scope));
pushCallFrame(frame.getKlazz(), frame.getName(), frame.getSelf(), block);
getCurrentFrame().setVisibility(getPreviousFrame().getVisibility());
}
public void preClassEval(StaticScope staticScope, RubyModule type) {
pushRubyClass(type);
pushFrameCopy();
getCurrentFrame().setSelf(type);
getCurrentFrame().setVisibility(Visibility.PUBLIC);
pushScope(DynamicScope.newDynamicScope(staticScope, null));
}
public void preCompiledClass(RubyModule type, StaticScope staticScope) {
pushRubyClass(type);
pushFrameCopy();
getCurrentFrame().setSelf(type);
getCurrentFrame().setVisibility(Visibility.PUBLIC);
staticScope.setModule(type);
pushScope(DynamicScope.newDynamicScope(staticScope));
}
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!
EvalType evalType = ((IRBlockBody) body).getEvalType();
DynamicScope newScope =
DynamicScope.newDynamicScope(body.getStaticScope(), parentScope, evalType);
if (type == Block.Type.LAMBDA) newScope.setLambda(true);
return newScope;
}
public void preMethodScopeOnly(RubyModule clazz, StaticScope staticScope) {
RubyModule implementationClass = staticScope.getModule();
// FIXME: This is currently only here because of some problems with IOOutputStream writing to a
// "bare" runtime without a proper scope
if (implementationClass == null) {
implementationClass = clazz;
}
pushScope(DynamicScope.newDynamicScope(staticScope));
pushRubyClass(implementationClass);
}
public void preMethodFrameAndScope(
RubyModule clazz, String name, IRubyObject self, Block block, StaticScope staticScope) {
RubyModule implementationClass = staticScope.getModule();
// FIXME: This is currently only here because of some problems with IOOutputStream writing to a
// "bare" runtime without a proper scope
if (implementationClass == null) {
implementationClass = clazz;
}
pushCallFrame(clazz, name, self, block);
pushScope(DynamicScope.newDynamicScope(staticScope));
pushRubyClass(implementationClass);
}
public final DynamicScope getEvalScope(Ruby runtime) {
// We create one extra dynamicScope on a binding so that when we 'eval "b=1", binding' the
// 'b' will get put into this new dynamic scope. The original scope does not see the new
// 'b' and successive evals with this binding will. I take it having the ability to have
// succesive binding evals be able to share same scope makes sense from a programmers
// perspective. One crappy outcome of this design is it requires Dynamic and Static
// scopes to be mutable for this one case.
// Note: In Ruby 1.9 all of this logic can go away since they will require explicit
// bindings for evals.
// We only define one special dynamic scope per 'logical' binding. So all bindings for
// the same scope should share the same dynamic scope. This allows multiple evals with
// different different bindings in the same scope to see the same stuff.
// No eval scope set, so we create one
if (evalScopeBinding.evalScope == null) {
// If the next scope out has the same binding scope as this scope it means
// we are evaling within an eval and in that case we should be sharing the same
// binding scope.
DynamicScope parent = dynamicScope.getNextCapturedScope();
if (parent != null && parent.getEvalScope(runtime) == dynamicScope) {
evalScopeBinding.evalScope = dynamicScope;
} else {
// bindings scopes must always be ManyVars scopes since evals can grow them
evalScopeBinding.evalScope =
new ManyVarsDynamicScope(
runtime.getStaticScopeFactory().newEvalScope(dynamicScope.getStaticScope()),
dynamicScope);
}
}
return evalScopeBinding.evalScope;
}
public Frame preYieldSpecificBlock(Binding binding, StaticScope scope, RubyModule klass) {
Frame lastFrame = preYieldNoScope(binding, klass);
// new scope for this invocation of the block, based on parent scope
pushScope(DynamicScope.newDynamicScope(scope, binding.getDynamicScope()));
return lastFrame;
}
public void preScopeNode(StaticScope staticScope) {
pushScope(DynamicScope.newDynamicScope(staticScope, getCurrentScope()));
}
public DynamicScope getDummyScope(StaticScope staticScope) {
if (dummyScope == null || dummyScope.getStaticScope() != staticScope) {
return dummyScope = DynamicScope.newDummyScope(staticScope, dynamicScope);
}
return dummyScope;
}
public Binding deepClone() {
return new Binding(this, dynamicScope.cloneScope(), this);
}
