Repository navigation
Expand file tree
/
Copy pathOneVarDynamicScope.java
More file actions
178 lines (156 loc) · 5.93 KB
/
Copy pathOneVarDynamicScope.java
File metadata and controls
178 lines (156 loc) · 5.93 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
package org.jruby.runtime.scope;
import org.jruby.RubyArray;
import org.jruby.javasupport.util.RuntimeHelpers;
import org.jruby.parser.StaticScope;
import org.jruby.runtime.DynamicScope;
import org.jruby.runtime.builtin.IRubyObject;
/**
* This is a DynamicScope that supports exactly three variables.
*/
public class OneVarDynamicScope extends NoVarsDynamicScope {
private static final int SIZE = 1;
private static final String SIZE_ERROR = "OneVarDynamicScope only supports scopes with one variable";
private static final String GROW_ERROR = "OneVarDynamicScope cannot be grown; use ManyVarsDynamicScope";
protected IRubyObject variableValueZero;
public OneVarDynamicScope(StaticScope staticScope, DynamicScope parent) {
super(staticScope, parent);
}
public OneVarDynamicScope(StaticScope staticScope) {
super(staticScope);
}
@Override
public void growIfNeeded() {
growIfNeeded(SIZE, GROW_ERROR);
}
@Override
public DynamicScope cloneScope() {
return new OneVarDynamicScope(staticScope, parent);
}
@Override
public IRubyObject[] getValues() {
return new IRubyObject[] {variableValueZero};
}
/**
* 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.
*
* @param offset zero-indexed value that represents where variable lives
* @param depth how many captured scopes down this variable should be set
* @return the value here
*/
@Override
public IRubyObject getValue(int offset, int depth) {
if (depth > 0) {
return parent.getValue(offset, depth - 1);
}
assert offset < SIZE : SIZE_ERROR;
return variableValueZero;
}
/**
* Variation of getValue that checks for nulls, returning and setting the given value (presumably nil)
*/
@Override
public IRubyObject getValueOrNil(int offset, int depth, IRubyObject nil) {
if (depth > 0) {
return parent.getValueOrNil(offset, depth - 1, nil);
} else {
return getValueDepthZeroOrNil(offset, nil);
}
}
@Override
public IRubyObject getValueDepthZeroOrNil(int offset, IRubyObject nil) {
IRubyObject value = variableValueZero;
if (value == null) return variableValueZero = nil;
return value;
}
@Override
public IRubyObject getValueZeroDepthZeroOrNil(IRubyObject nil) {
IRubyObject value = variableValueZero;
if (value == null) return variableValueZero = nil;
return value;
}
/**
* Set value in current dynamic scope or one of its captured scopes.
*
* @param offset zero-indexed value that represents where variable lives
* @param value to set
* @param depth how many captured scopes down this variable should be set
*/
@Override
public IRubyObject setValue(int offset, IRubyObject value, int depth) {
if (depth > 0) {
return parent.setValue(offset, value, depth - 1);
} else {
return variableValueZero = value;
}
}
@Override
public IRubyObject setValueDepthZero(IRubyObject value, int offset) {
return variableValueZero = value;
}
@Override
public IRubyObject setValueZeroDepthZero(IRubyObject value) {
return variableValueZero = 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.
*
* @param values up to size specified to be mapped as ordinary parm values
* @param size is the number of values to assign as ordinary parm values
*/
@Override
public void setArgValues(IRubyObject[] values, int size) {
if (size == 1) {
variableValueZero = values[0];
}
}
@Override
public void setArgValues(IRubyObject arg0) {
variableValueZero = arg0;
}
/*
* If we are setting post arguments we can assume there are no pre or others
*/
@Override
public void setEndArgValues(IRubyObject[] values, int index, int size) {
assert index == 0;
assert size <= 1;
if (size == 1) {
variableValueZero = values[values.length - 1];
}
}
@Override
public IRubyObject[] getArgValues() {
// if we're not the "argument scope" for zsuper, try our parent
if (!staticScope.isArgumentScope()) {
return parent.getArgValues();
}
int totalArgs = staticScope.getRequiredArgs() + staticScope.getOptionalArgs();
// copy and splat arguments out of the scope to use for zsuper call
if (staticScope.getRestArg() < 0) {
if (totalArgs == 1) {
return new IRubyObject[] {variableValueZero};
} else {
return IRubyObject.NULL_ARRAY;
}
} else {
// rest arg must be splatted
IRubyObject restArg = getValue(staticScope.getRestArg(), 0);
// FIXME: not very efficient
RubyArray splattedArgs = RuntimeHelpers.splatValue(restArg);
IRubyObject[] argValues = new IRubyObject[totalArgs + splattedArgs.size()];
System.arraycopy(splattedArgs.toJavaArray(), 0, argValues, totalArgs, splattedArgs.size());
if (totalArgs == 1) {
argValues[0] = variableValueZero;
}
return argValues;
}
}
}