Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   ***** BEGIN LICENSE BLOCK *****
   * Version: EPL 1.0/GPL 2.0/LGPL 2.1
   *
   * The contents of this file are subject to the Eclipse 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/epl-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.
  *
  * 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 *****/
 
 package org.jruby.runtime;
 
 import org.jruby.Ruby;
 
 public abstract class DynamicScope {
     // Static scoping information for this scope
     protected final StaticScope staticScope;
 
     // Captured dynamic scopes
     protected final DynamicScope parent;
 
     // A place to store that special hiding space that bindings need to implement things like:
     // eval("a = 1", binding); eval("p a").  All binding instances must get access to this
     // hidden shared scope.  We store it here.  This will be null if no binding has yet
     // been called.
     protected DynamicScope evalScope;
 
     protected DynamicScope(StaticScope staticScopeDynamicScope parent) {
         this. = staticScope;
         this. = parent;
     }
 
     protected DynamicScope(StaticScope staticScope) {
         this(staticScopenull);
     }
 
     public static DynamicScope newDynamicScope(StaticScope staticScopeDynamicScope parent) {
         switch (staticScope.getNumberOfVariables()) {
         case 0:
             return new NoVarsDynamicScope(staticScopeparent);
         case 1:
             return new OneVarDynamicScope(staticScopeparent);
         case 2:
             return new TwoVarDynamicScope(staticScopeparent);
         case 3:
             return new ThreeVarDynamicScope(staticScopeparent);
         case 4:
             return new FourVarDynamicScope(staticScopeparent);
         default:
             return new ManyVarsDynamicScope(staticScopeparent);
         }
     }
 
     public static DynamicScope newDummyScope(StaticScope staticScopeDynamicScope parent) {
         return new DummyDynamicScope(staticScopeparent);
     }

    
Returns the n-th parent scope of this scope. May return null.

Parameters:
n - number of levels above to look.
Returns:
The n-th parent scope or null.
 
     public DynamicScope getNthParentScope(int n) {
         DynamicScope scope = this;
         for (int i = 0; i < ni++) {
             if (scope != null) {
                 scope = scope.getNextCapturedScope();
             } else {
                 break;
             }
         }
         return scope;
    }
    public static DynamicScope newDynamicScope(StaticScope staticScope) {
        return newDynamicScope(staticScopenull);
    }
    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 binding scope so we should create one
        if ( == 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 = getNextCapturedScope();
            if (parent != null && parent.getEvalScope(runtime) == this) {
                 = this;
            } else {
                // bindings scopes must always be ManyVars scopes since evals can grow them
                 = new ManyVarsDynamicScope(runtime.getStaticScopeFactory().newEvalScope(getStaticScope()), this);
            }
        }
        return ;
    }

    
Find the scope to use for flip-flops. Flip-flops live either in the topmost "method scope" or in their nearest containing "eval scope".

Returns:
The scope to use for flip-flops
    public DynamicScope getFlipScope() {
        if (.getLocalScope() == ) {
            return this;
        } else {
            return .getFlipScope();
        }
    }

    
Get next 'captured' scope.

Returns:
the scope captured by this scope for implementing closures
    public final DynamicScope getNextCapturedScope() {
        return ;
    }

    
Get the static scope associated with this DynamicScope.

Returns:
static complement to this scope
    public final StaticScope getStaticScope() {
        return ;
    }

    
Get all variable names captured (visible) by this scope (sans $~ and $_).

Returns:
a list of variable names
    public final String[] getAllNamesInScope() {
        return .getAllNamesInScope();
    }
    public abstract void growIfNeeded();
    public abstract DynamicScope cloneScope();
    public abstract IRubyObject[] getValues();

    
Get value from current scope or one of its captured scopes. FIXME: block variables are not getting primed to nil so we need to null check those until we prime them properly. Also add assert back in.

Parameters:
offset zero-indexed value that represents where variable lives
depth how many captured scopes down this variable should be set
Returns:
the value here
    public abstract IRubyObject getValue(int offsetint depth);

    
Variation of getValue that checks for nulls, returning and setting the given value (presumably nil)
    public abstract IRubyObject getValueOrNil(int offsetint depthIRubyObject nil);

    
getValueOrNil for depth 0
    public abstract IRubyObject getValueDepthZeroOrNil(int offsetIRubyObject nil);

    
getValueOrNil for index 0, depth 0
    public abstract IRubyObject getValueZeroDepthZeroOrNil(IRubyObject nil);

    
getValueOrNil for index 1, depth 0
    public abstract IRubyObject getValueOneDepthZeroOrNil(IRubyObject nil);

    
getValueOrNil for index 2, depth 0
    public abstract IRubyObject getValueTwoDepthZeroOrNil(IRubyObject nil);

    
getValueOrNil for index 3, depth 0
    public abstract IRubyObject getValueThreeDepthZeroOrNil(IRubyObject nil);

    
Set value in current dynamic scope or one of its captured scopes.

Parameters:
offset zero-indexed value that represents where variable lives
value to set
depth how many captured scopes down this variable should be set
    public abstract IRubyObject setValue(int offsetIRubyObject valueint depth);

    
Set value in current dynamic scope or one of its captured scopes.

Parameters:
offset zero-indexed value that represents where variable lives
value to set
depth how many captured scopes down this variable should be set
    public IRubyObject setValue(IRubyObject valueint offsetint depth) {
        return setValue(offsetvaluedepth);
    }

    
setValue for depth zero

Parameters:
offset zero-indexed value that represents where variable lives
value to set
depth how many captured scopes down this variable should be set
    public abstract IRubyObject setValueDepthZero(IRubyObject valueint offset);

    
Set value zero in this scope;
    public abstract IRubyObject setValueZeroDepthZero(IRubyObject value);

    
Set value one in this scope.
    public abstract IRubyObject setValueOneDepthZero(IRubyObject value);

    
Set value two in this scope.
    public abstract IRubyObject setValueTwoDepthZero(IRubyObject value);

    
Set value three in this scope.
    public abstract IRubyObject setValueThreeDepthZero(IRubyObject value);

    
Set all values which represent 'normal' parameters in a call list to this dynamic scope. Function calls bind to local scopes by assuming that the indexes or the arg list correspond to that of the local scope (plus 2 since $_ and $~ always take the first two slots). We pass in a second argument because we sometimes get more values than we are expecting. The rest get compacted by original caller into rest args.

Parameters:
values up to size specified to be mapped as ordinary parm values
size is the number of values to assign as ordinary parm values
    public abstract void setArgValues(IRubyObject[] valuesint size);
    public void setArgValues() {
        setArgValues(., 0);
    }
    public void setArgValues(IRubyObject arg0) {
        setArgValues(new IRubyObject[] {arg0}, 1);
    }
    public void setArgValues(IRubyObject arg0IRubyObject arg1) {
        setArgValues(new IRubyObject[] {arg0arg1}, 2);
    }
    public void setArgValues(IRubyObject arg0IRubyObject arg1IRubyObject arg2) {
        setArgValues(new IRubyObject[] {arg0arg1arg2}, 3);
    }
    public void setArgValues(IRubyObject arg0IRubyObject arg1IRubyObject arg2IRubyObject arg3) {
        setArgValues(new IRubyObject[] {arg0arg1arg2arg3}, 4);
    }
    public void setArgValues(IRubyObject arg0IRubyObject arg1IRubyObject arg2IRubyObject arg3IRubyObject arg4) {
        setArgValues(new IRubyObject[] {arg0arg1arg2arg3arg4}, 5);
    }
    public void setArgValues(IRubyObject arg0IRubyObject arg1IRubyObject arg2IRubyObject arg3IRubyObject arg4IRubyObject arg5) {
        setArgValues(new IRubyObject[] {arg0arg1arg2arg3arg4arg5}, 6);
    }
    public void setArgValues(IRubyObject arg0IRubyObject arg1IRubyObject arg2IRubyObject arg3IRubyObject arg4IRubyObject arg5IRubyObject arg6) {
        setArgValues(new IRubyObject[] {arg0arg1arg2arg3arg4arg5arg6}, 7);
    }
    public void setArgValues(IRubyObject arg0IRubyObject arg1IRubyObject arg2IRubyObject arg3IRubyObject arg4IRubyObject arg5IRubyObject arg6IRubyObject arg7) {
        setArgValues(new IRubyObject[] {arg0arg1arg2arg3arg4arg5arg6arg7}, 8);
    }
    public void setArgValues(IRubyObject arg0IRubyObject arg1IRubyObject arg2IRubyObject arg3IRubyObject arg4IRubyObject arg5IRubyObject arg6IRubyObject arg7IRubyObject arg8) {
        setArgValues(new IRubyObject[] {arg0arg1arg2arg3arg4arg5arg6arg7arg8}, 9);
    }
    public void setArgValues(IRubyObject arg0IRubyObject arg1IRubyObject arg2IRubyObject arg3IRubyObject arg4IRubyObject arg5IRubyObject arg6IRubyObject arg7IRubyObject arg8IRubyObject arg9) {
        setArgValues(new IRubyObject[] {arg0arg1arg2arg3arg4arg5arg6arg7arg8arg9}, 10);
    }


    

Parameters:
values group where last n(size) values are used
index index in the dynamic scope to start setting these values
size which of the last size arguments of values parameter to set
    public abstract void setEndArgValues(IRubyObject[] valuesint indexint size);

    
Copy variable values back for ZSuper call.
    public abstract IRubyObject[] getArgValues();
    @Override
    public String toString() {
        return toString(new StringBuffer(), "");
    }
    // Helper function to give a good view of current dynamic scope with captured scopes
    public String toString(StringBuffer bufString indent) {
        buf.append(indent).append("Static Type[" + hashCode() + "]: " +
                (.isBlockScope() ? "block" : "local")+" [");
        int size = .getNumberOfVariables();
        IRubyObject[] variableValues = getValues();
        if (size != 0) {
            String names[] = .getVariables();
            for (int i = 0; i < size-1; i++) {
                buf.append(names[i]).append("=");
                if (variableValues[i] == null) {
                    buf.append("null");
                } else {
                    buf.append(variableValues[i]);
                }
                buf.append(",");
            }
            buf.append(names[size-1]).append("=");
            assert variableValues.length == names.length : "V: " + variableValues.length +
                " != N: " + names.length + " for " + buf;
            if (variableValues[size-1] == null) {
                buf.append("null");
            } else {
                buf.append(variableValues[size-1]);
            }
        }
        buf.append("]");
        if ( != null) {
            buf.append("\n");
            .toString(bufindent + "  ");
        }
        return buf.toString();
    }
New to GrepCode? Check out our FAQ X