Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.runtime.scope;
  
Represents the the dynamic portion of scoping information. The variableValues are the values of assigned local or block variables. The staticScope identifies which sort of scope this is (block or local). Properties of Dynamic Scopes: 1. static and dynamic scopes have the same number of names to values 2. size of variables (and thus names) is determined during parsing. So those structured do not need to change FIXME: When creating dynamic scopes we sometimes accidentally pass in extra parents. This is harmless (other than wasting memory), but we should not do that. We can fix this in two ways: 1. Fix all callers 2. Check parent that is passed in and make if new instance is local, then its parent is not local
 
 public class ManyVarsDynamicScope extends DynamicScope {
     // Our values holder (name of variables are kept in staticScope)
     private IRubyObject[] variableValues;
 
     public ManyVarsDynamicScope(StaticScope staticScopeDynamicScope parent) {
         super(staticScopeparent);
         allocate();
     }
 
     public ManyVarsDynamicScope(StaticScope staticScope) {
         super(staticScope);
         allocate();
     }
 
     private void allocate() {
         if( == null) {
             int size = .getNumberOfVariables();
              = new IRubyObject[size];
         }
     }
     
     public DynamicScope cloneScope() {
         return new ManyVarsDynamicScope();
     }
 
     public IRubyObject[] getValues() {
         return ;
     }
    
    
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 IRubyObject getValue(int offsetint depth) {
         if (depth > 0) {
             return .getValue(offsetdepth - 1);
         }
         assertGetValue(offsetdepth);
         // &foo are not getting set from somewhere...I want the following assert to be true though
         //assert variableValues[offset] != null : "Getting unassigned: " + staticScope.getVariables()[offset];
         return [offset];
     }
    
    
Variation of getValue that checks for nulls, returning and setting the given value (presumably nil)
 
     public IRubyObject getValueOrNil(int offsetint depthIRubyObject nil) {
         if (depth > 0) {
             return .getValueOrNil(offsetdepth - 1, nil);
         } else {
             return getValueDepthZeroOrNil(offsetnil);
         }
     }
     
     public IRubyObject getValueDepthZeroOrNil(int offsetIRubyObject nil) {
         assertGetValueDepthZeroOrNil(offset);
         // &foo are not getting set from somewhere...I want the following assert to be true though
         //assert variableValues[offset] != null : "Getting unassigned: " + staticScope.getVariables()[offset];
         IRubyObject value = [offset];
         return value == null ? setValueDepthZero(niloffset) : value;
     }
     
         // &foo are not getting set from somewhere...I want the following assert to be true though
         //assert variableValues[offset] != null : "Getting unassigned: " + staticScope.getVariables()[offset];
         IRubyObject value = [0];
         return value == null ? setValueZeroDepthZero(nil) : value;
     }
    
        // &foo are not getting set from somewhere...I want the following assert to be true though
        //assert variableValues[offset] != null : "Getting unassigned: " + staticScope.getVariables()[offset];
        IRubyObject value = [1];
        return value == null ? setValueOneDepthZero(nil) : value;
    }
    
        // &foo are not getting set from somewhere...I want the following assert to be true though
        //assert variableValues[offset] != null : "Getting unassigned: " + staticScope.getVariables()[offset];
        IRubyObject value = [2];
        return value == null ? setValueTwoDepthZero(nil) : value;
    }
    
        // &foo are not getting set from somewhere...I want the following assert to be true though
        //assert variableValues[offset] != null : "Getting unassigned: " + staticScope.getVariables()[offset];
        IRubyObject value = [3];
        return value == null ? setValueThreeDepthZero(nil) : value;
    }

    
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(int offsetIRubyObject valueint depth) {
        if (depth > 0) {
            assertParent();
            
            return .setValue(offsetvaluedepth - 1);
        } else {
            assertSetValue(offsetvalue);
            
            return setValueDepthZero(valueoffset);
        }
    }
    public IRubyObject setValueDepthZero(IRubyObject valueint offset) {
        assertSetValueDepthZero(offsetvalue);
        return [offset] = value;
    }
        assertSetValueZeroDepthZero(value);
        return [0] = value;
    }
    public IRubyObject setValueOneDepthZero(IRubyObject value) {
        assertSetValueOneDepthZero(value);
        return [1] = value;
    }
    public IRubyObject setValueTwoDepthZero(IRubyObject value) {
        assertSetValueTwoDepthZero(value);
        return [2] = value;
    }
        assertSetValueThreeDepthZero(value);
        return [3] = 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 void setArgValues(IRubyObject[] valuesint size) {
        System.arraycopy(values, 0, , 0, size);
    }
    @Override
    public void setArgValues(IRubyObject arg0) {
        [0] = arg0;
    }
    
    @Override
    public void setArgValues(IRubyObject arg0IRubyObject arg1) {
        [0] = arg0;
        [1] = arg1;
    }
    
    @Override
    public void setArgValues(IRubyObject arg0IRubyObject arg1IRubyObject arg2) {
        [0] = arg0;
        [1] = arg1;
        [2] = arg2;
    }
    
    public void setEndArgValues(IRubyObject[] valuesint indexint size) {
        System.arraycopy(valuesvalues.length - sizeindexsize);
    }

    
Copy variable values back for ZSuper call.
    public IRubyObject[] getArgValues() {
        // if we're not the "argument scope" for zsuper, try our parent
        if (!.isArgumentScope()) {
            return .getArgValues();
        }
        int totalArgs = .getRequiredArgs() + .getOptionalArgs();
        
        // copy and splat arguments out of the scope to use for zsuper call
        if (.getRestArg() < 0) {
            // required and optional only
            IRubyObject[] argValues = new IRubyObject[totalArgs];
            System.arraycopy(, 0, argValues, 0, totalArgs);
            
            return argValues;
        } else {
            // rest arg must be splatted
            IRubyObject restArg = getValue(.getRestArg(), 0);
            assert restArg != null;
            
            // FIXME: not very efficient
            RubyArray splattedArgs = Helpers.splatValue(restArg);
            IRubyObject[] argValues = new IRubyObject[totalArgs + splattedArgs.size()];
            System.arraycopy(, 0, argValues, 0, totalArgs);
            System.arraycopy(splattedArgs.toJavaArray(), 0, argValuestotalArgssplattedArgs.size());
            
            return argValues;
        }
    }

    
Make a larger dynamic scope if the static scope grew. Eval's with bindings require us to possibly change the size of the dynamic scope if things like 'eval "b = 2", binding' happens.
    public void growIfNeeded() {
        int dynamicSize =  == null ? 0: .;
        
        if (.getNumberOfVariables() > dynamicSize) {
            IRubyObject values[] = new IRubyObject[.getNumberOfVariables()];
            
            if (dynamicSize > 0) {
                System.arraycopy(, 0, values, 0, dynamicSize);
            }
            
             = values;
        }
    }
    private void assertGetValue(int offsetint depth) {
        IRubyObject[] values = ;
        assert values != null && offset < values.length : "No variables or index to big for getValue off: " + offset + ", Dep: " + depth + ", O: " + this;
    }
    private void assertGetValueDepthZeroOrNil(int offset) {
        IRubyObject[] values = ;
        assert values != null && offset < values.length : "No variables or index too big for getValue off: " + offset + ", Dep: " + 0 + ", O: " + this;
    }
    private void assertGetValueZeroDepthZeroOrNil() {
        IRubyObject[] values = ;
        assert values != null && 0 < values.length : "No variables or index to big for getValue off: " + 0 + ", Dep: " + 0 + ", O: " + this;
    }
    private void assertGetValueOneDepthZeroOrNil() {
        IRubyObject[] values = ;
        assert values != null && 1 < values.length : "No variables or index to big for getValue off: " + 1 + ", Dep: " + 0 + ", O: " + this;
    }
    private void assertGetValueTwoDepthZeroOrNil() {
        IRubyObject[] values = ;
        assert values != null && 3 < values.length : "No variables or index to big for getValue off: " + 3 + ", Dep: " + 0 + ", O: " + this;
    }
    private void assertGetValueThreeDepthZeroOrNil() {
        IRubyObject[] values = ;
        assert values != null && 2 < values.length : "No variables or index to big for getValue off: " + 2 + ", Dep: " + 0 + ", O: " + this;
    }
    private void assertParent() {
        assert  != null : "If depth > 0, then parent should not ever be null";
    }
    private void assertSetValue(int offsetIRubyObject value) {
        assert offset < . : "Setting " + offset + " to " + value + ", O: " + this;
    }
    private void assertSetValueDepthZero(int offsetIRubyObject value) {
        assert offset < . : "Setting " + offset + " to " + value + ", O: " + this;
    }
    private void assertSetValueZeroDepthZero(IRubyObject value) {
        assert 0 < . : "Setting " + 0 + " to " + value + ", O: " + this;
    }
    private void assertSetValueOneDepthZero(IRubyObject value) {
        assert 1 < . : "Setting " + 1 + " to " + value + ", O: " + this;
    }
    private void assertSetValueThreeDepthZero(IRubyObject value) {
        assert 3 < . : "Setting " + 3 + " to " + value + ", O: " + this;
    }
    private void assertSetValueTwoDepthZero(IRubyObject value) {
        assert 2 < . : "Setting " + 2 + " to " + value + ", O: " + this;
    }
New to GrepCode? Check out our FAQ X