forked from mozilla/rhino
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathNativeWith.java
More file actions
231 lines (195 loc) · 5.84 KB
/
Copy pathNativeWith.java
File metadata and controls
231 lines (195 loc) · 5.84 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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
package org.mozilla.javascript;
import java.io.Serializable;
/**
* This class implements the object lookup required for the
* <code>with</code> statement.
* It simply delegates every action to its prototype except
* for operations on its parent.
*/
public class NativeWith implements Scriptable, SymbolScriptable, IdFunctionCall, Serializable {
private static final long serialVersionUID = 1L;
static void init(Scriptable scope, boolean sealed) {
NativeWith obj = new NativeWith();
obj.setParentScope(scope);
obj.setPrototype(ScriptableObject.getObjectPrototype(scope));
IdFunctionObject ctor = new IdFunctionObject(obj, FTAG, Id_constructor,
"With", 0, scope);
ctor.markAsConstructor(obj);
if (sealed) {
ctor.sealObject();
}
ctor.exportAsScopeProperty();
}
private NativeWith() {
}
protected NativeWith(Scriptable parent, Scriptable prototype) {
this.parent = parent;
this.prototype = prototype;
}
@Override
public String getClassName() {
return "With";
}
@Override
public boolean has(String id, Scriptable start)
{
return prototype.has(id, prototype);
}
@Override
public boolean has(Symbol key, Scriptable start)
{
if (prototype instanceof SymbolScriptable) {
return ((SymbolScriptable)prototype).has(key, prototype);
}
return false;
}
@Override
public boolean has(int index, Scriptable start)
{
return prototype.has(index, prototype);
}
@Override
public Object get(String id, Scriptable start)
{
if (start == this) {
start = prototype;
}
return prototype.get(id, start);
}
@Override
public Object get(Symbol key, Scriptable start)
{
if (start == this) {
start = prototype;
}
if (prototype instanceof SymbolScriptable) {
return ((SymbolScriptable)prototype).get(key, start);
}
return Scriptable.NOT_FOUND;
}
@Override
public Object get(int index, Scriptable start)
{
if (start == this) {
start = prototype;
}
return prototype.get(index, start);
}
@Override
public void put(String id, Scriptable start, Object value)
{
if (start == this)
start = prototype;
prototype.put(id, start, value);
}
@Override
public void put(Symbol symbol, Scriptable start, Object value)
{
if (start == this) {
start = prototype;
}
if (prototype instanceof SymbolScriptable) {
((SymbolScriptable)prototype).put(symbol, start, value);
}
}
@Override
public void put(int index, Scriptable start, Object value)
{
if (start == this)
start = prototype;
prototype.put(index, start, value);
}
@Override
public void delete(String id)
{
prototype.delete(id);
}
@Override
public void delete(Symbol key)
{
if (prototype instanceof SymbolScriptable) {
((SymbolScriptable)prototype).delete(key);
}
}
@Override
public void delete(int index)
{
prototype.delete(index);
}
@Override
public Scriptable getPrototype() {
return prototype;
}
@Override
public void setPrototype(Scriptable prototype) {
this.prototype = prototype;
}
@Override
public Scriptable getParentScope() {
return parent;
}
@Override
public void setParentScope(Scriptable parent) {
this.parent = parent;
}
@Override
public Object[] getIds() {
return prototype.getIds();
}
@Override
public Object getDefaultValue(Class<?> typeHint) {
return prototype.getDefaultValue(typeHint);
}
@Override
public boolean hasInstance(Scriptable value) {
return prototype.hasInstance(value);
}
/**
* Must return null to continue looping or the final collection result.
*/
protected Object updateDotQuery(boolean value)
{
// NativeWith itself does not support it
throw new IllegalStateException();
}
@Override
public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope,
Scriptable thisObj, Object[] args)
{
if (f.hasTag(FTAG)) {
if (f.methodId() == Id_constructor) {
throw Context.reportRuntimeError1("msg.cant.call.indirect", "With");
}
}
throw f.unknown();
}
static boolean isWithFunction(Object functionObj)
{
if (functionObj instanceof IdFunctionObject) {
IdFunctionObject f = (IdFunctionObject)functionObj;
return f.hasTag(FTAG) && f.methodId() == Id_constructor;
}
return false;
}
static Object newWithSpecial(Context cx, Scriptable scope, Object[] args)
{
ScriptRuntime.checkDeprecated(cx, "With");
scope = ScriptableObject.getTopLevelScope(scope);
NativeWith thisObj = new NativeWith();
thisObj.setPrototype(args.length == 0
? ScriptableObject.getObjectPrototype(scope)
: ScriptRuntime.toObject(cx, scope, args[0]));
thisObj.setParentScope(scope);
return thisObj;
}
private static final Object FTAG = "With";
private static final int
Id_constructor = 1;
protected Scriptable prototype;
protected Scriptable parent;
}