Example #1
0
  /** 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();
  }
Example #3
0
  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;
  }