/** For blocks which cannot be executed in parallel. */ public JavaInternalBlockBody( Ruby runtime, ThreadContext originalContext, String methodName, Signature signature) { super(signature); this.originalContext = originalContext; this.methodName = methodName; this.dummyScope = runtime.getStaticScopeFactory().getDummyScope(); }
/** * For blocks which cannot be executed in parallel. * * @param methodName * @param arity */ public JavaInternalBlockBody( Ruby runtime, ThreadContext originalContext, String methodName, Arity arity) { super(BlockBody.SINGLE_RESTARG); this.arity = arity; this.originalContext = originalContext; this.methodName = methodName; this.dummyScope = runtime.getStaticScopeFactory().getDummyScope(); }
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; }