Update binding test expectation for http://trac.webkit.org/changeset/128400
[WebKit.git] / Source / WebCore / bindings / scripts / test / JS / JSFloat64Array.cpp
1 /*
2     This file is part of the WebKit open source project.
3     This file has been generated by generate-bindings.pl. DO NOT MODIFY!
4
5     This library is free software; you can redistribute it and/or
6     modify it under the terms of the GNU Library General Public
7     License as published by the Free Software Foundation; either
8     version 2 of the License, or (at your option) any later version.
9
10     This library is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13     Library General Public License for more details.
14
15     You should have received a copy of the GNU Library General Public License
16     along with this library; see the file COPYING.LIB.  If not, write to
17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18     Boston, MA 02110-1301, USA.
19 */
20
21 #include "config.h"
22 #include "JSFloat64Array.h"
23
24 #include "ExceptionCode.h"
25 #include "JSArrayBufferViewHelper.h"
26 #include "JSDOMBinding.h"
27 #include "JSFloat32Array.h"
28 #include "JSInt32Array.h"
29 #include <runtime/Error.h>
30 #include <runtime/PropertyNameArray.h>
31 #include <wtf/Float64Array.h>
32 #include <wtf/GetPtr.h>
33 #include <wtf/Int32Array.h>
34
35 using namespace JSC;
36
37 namespace WebCore {
38
39 ASSERT_CLASS_FITS_IN_CELL(JSFloat64Array);
40 /* Hash table */
41
42 static const HashTableValue JSFloat64ArrayTableValues[] =
43 {
44     { "constructor", DontEnum | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsFloat64ArrayConstructor), (intptr_t)0, NoIntrinsic },
45     { 0, 0, 0, 0, NoIntrinsic }
46 };
47
48 static const HashTable JSFloat64ArrayTable = { 2, 1, JSFloat64ArrayTableValues, 0 };
49 /* Hash table for constructor */
50
51 static const HashTableValue JSFloat64ArrayConstructorTableValues[] =
52 {
53     { 0, 0, 0, 0, NoIntrinsic }
54 };
55
56 static const HashTable JSFloat64ArrayConstructorTable = { 1, 0, JSFloat64ArrayConstructorTableValues, 0 };
57 const ClassInfo JSFloat64ArrayConstructor::s_info = { "Float64ArrayConstructor", &Base::s_info, &JSFloat64ArrayConstructorTable, 0, CREATE_METHOD_TABLE(JSFloat64ArrayConstructor) };
58
59 JSFloat64ArrayConstructor::JSFloat64ArrayConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
60     : DOMConstructorObject(structure, globalObject)
61 {
62 }
63
64 void JSFloat64ArrayConstructor::finishCreation(ExecState* exec, JSDOMGlobalObject* globalObject)
65 {
66     Base::finishCreation(exec->globalData());
67     ASSERT(inherits(&s_info));
68     putDirect(exec->globalData(), exec->propertyNames().prototype, JSFloat64ArrayPrototype::self(exec, globalObject), DontDelete | ReadOnly);
69     putDirect(exec->globalData(), exec->propertyNames().length, jsNumber(123), ReadOnly | DontDelete | DontEnum);
70 }
71
72 bool JSFloat64ArrayConstructor::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
73 {
74     return getStaticValueSlot<JSFloat64ArrayConstructor, JSDOMWrapper>(exec, &JSFloat64ArrayConstructorTable, jsCast<JSFloat64ArrayConstructor*>(cell), propertyName, slot);
75 }
76
77 bool JSFloat64ArrayConstructor::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
78 {
79     return getStaticValueDescriptor<JSFloat64ArrayConstructor, JSDOMWrapper>(exec, &JSFloat64ArrayConstructorTable, jsCast<JSFloat64ArrayConstructor*>(object), propertyName, descriptor);
80 }
81
82 EncodedJSValue JSC_HOST_CALL JSFloat64ArrayConstructor::constructJSFloat64Array(ExecState* exec)
83 {
84     JSFloat64ArrayConstructor* jsConstructor = jsCast<JSFloat64ArrayConstructor*>(exec->callee());
85     RefPtr<Float64Array> array = constructArrayBufferView<Float64Array, double>(exec);
86     if (!array.get())
87         // Exception has already been thrown.
88         return JSValue::encode(JSValue());
89     return JSValue::encode(asObject(toJS(exec, jsConstructor->globalObject(), array.get())));
90 }
91
92 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, Float64Array* object)
93 {
94     return toJSArrayBufferView<JSFloat64Array>(exec, globalObject, object);
95 }
96
97 void JSFloat64Array::indexSetter(JSC::ExecState* exec, unsigned index, JSC::JSValue value)
98 {
99     impl()->set(index, value.toNumber(exec));
100 }
101
102 ConstructType JSFloat64ArrayConstructor::getConstructData(JSCell*, ConstructData& constructData)
103 {
104     constructData.native.function = constructJSFloat64Array;
105     return ConstructTypeHost;
106 }
107
108 /* Hash table for prototype */
109
110 static const HashTableValue JSFloat64ArrayPrototypeTableValues[] =
111 {
112     { "foo", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsFloat64ArrayPrototypeFunctionFoo), (intptr_t)1, NoIntrinsic },
113     { "set", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsFloat64ArrayPrototypeFunctionSet), (intptr_t)0, NoIntrinsic },
114     { 0, 0, 0, 0, NoIntrinsic }
115 };
116
117 static const HashTable JSFloat64ArrayPrototypeTable = { 4, 3, JSFloat64ArrayPrototypeTableValues, 0 };
118 static const HashTable* getJSFloat64ArrayPrototypeTable(ExecState* exec)
119 {
120     return getHashTableForGlobalData(exec->globalData(), &JSFloat64ArrayPrototypeTable);
121 }
122
123 const ClassInfo JSFloat64ArrayPrototype::s_info = { "Float64ArrayPrototype", &Base::s_info, 0, getJSFloat64ArrayPrototypeTable, CREATE_METHOD_TABLE(JSFloat64ArrayPrototype) };
124
125 JSObject* JSFloat64ArrayPrototype::self(ExecState* exec, JSGlobalObject* globalObject)
126 {
127     return getDOMPrototype<JSFloat64Array>(exec, globalObject);
128 }
129
130 bool JSFloat64ArrayPrototype::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
131 {
132     JSFloat64ArrayPrototype* thisObject = jsCast<JSFloat64ArrayPrototype*>(cell);
133     return getStaticFunctionSlot<JSObject>(exec, getJSFloat64ArrayPrototypeTable(exec), thisObject, propertyName, slot);
134 }
135
136 bool JSFloat64ArrayPrototype::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
137 {
138     JSFloat64ArrayPrototype* thisObject = jsCast<JSFloat64ArrayPrototype*>(object);
139     return getStaticFunctionDescriptor<JSObject>(exec, getJSFloat64ArrayPrototypeTable(exec), thisObject, propertyName, descriptor);
140 }
141
142 static const HashTable* getJSFloat64ArrayTable(ExecState* exec)
143 {
144     return getHashTableForGlobalData(exec->globalData(), &JSFloat64ArrayTable);
145 }
146
147 const ClassInfo JSFloat64Array::s_info = { "Float64Array", &Base::s_info, 0, getJSFloat64ArrayTable , CREATE_METHOD_TABLE(JSFloat64Array) };
148
149 JSFloat64Array::JSFloat64Array(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<Float64Array> impl)
150     : JSArrayBufferView(structure, globalObject, impl)
151 {
152 }
153
154 void JSFloat64Array::finishCreation(JSGlobalData& globalData)
155 {
156     Base::finishCreation(globalData);
157     TypedArrayDescriptor descriptor(&JSFloat64Array::s_info, OBJECT_OFFSETOF(JSFloat64Array, m_storage), OBJECT_OFFSETOF(JSFloat64Array, m_storageLength));
158     globalData.registerTypedArrayDescriptor(impl(), descriptor);
159     m_storage = impl()->data();
160     m_storageLength = impl()->length();
161     ASSERT(inherits(&s_info));
162 }
163
164 JSObject* JSFloat64Array::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
165 {
166     return JSFloat64ArrayPrototype::create(exec->globalData(), globalObject, JSFloat64ArrayPrototype::createStructure(exec->globalData(), globalObject, JSArrayBufferViewPrototype::self(exec, globalObject)));
167 }
168
169 bool JSFloat64Array::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
170 {
171     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(cell);
172     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
173     unsigned index = propertyName.asIndex();
174     if (index != PropertyName::NotAnIndex && index < static_cast<Float64Array*>(thisObject->impl())->length()) {
175         slot.setValue(thisObject->getByIndex(exec, index));
176         return true;
177     }
178     return getStaticValueSlot<JSFloat64Array, Base>(exec, getJSFloat64ArrayTable(exec), thisObject, propertyName, slot);
179 }
180
181 bool JSFloat64Array::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
182 {
183     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(object);
184     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
185     unsigned index = propertyName.asIndex();
186     if (index != PropertyName::NotAnIndex && index < static_cast<Float64Array*>(thisObject->impl())->length()) {
187         descriptor.setDescriptor(thisObject->getByIndex(exec, index), DontDelete);
188         return true;
189     }
190     return getStaticValueDescriptor<JSFloat64Array, Base>(exec, getJSFloat64ArrayTable(exec), thisObject, propertyName, descriptor);
191 }
192
193 bool JSFloat64Array::getOwnPropertySlotByIndex(JSCell* cell, ExecState* exec, unsigned index, PropertySlot& slot)
194 {
195     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(cell);
196     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
197     if (index < static_cast<Float64Array*>(thisObject->impl())->length()) {
198         slot.setValue(thisObject->getByIndex(exec, index));
199         return true;
200     }
201     return Base::getOwnPropertySlotByIndex(thisObject, exec, index, slot);
202 }
203
204 JSValue jsFloat64ArrayConstructor(ExecState* exec, JSValue slotBase, PropertyName)
205 {
206     JSFloat64Array* domObject = jsCast<JSFloat64Array*>(asObject(slotBase));
207     return JSFloat64Array::getConstructor(exec, domObject->globalObject());
208 }
209
210 void JSFloat64Array::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
211 {
212     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(cell);
213     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
214     unsigned index = propertyName.asIndex();
215     if (index != PropertyName::NotAnIndex) {
216         thisObject->indexSetter(exec, index, value);
217         return;
218     }
219     Base::put(thisObject, exec, propertyName, value, slot);
220 }
221
222 void JSFloat64Array::putByIndex(JSCell* cell, ExecState* exec, unsigned index, JSValue value, bool shouldThrow)
223 {
224     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(cell);
225     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
226     if (index <= MAX_ARRAY_INDEX) {
227         UNUSED_PARAM(shouldThrow);
228         thisObject->indexSetter(exec, index, value);
229         return;
230     }
231     Base::putByIndex(cell, exec, index, value, shouldThrow);
232 }
233
234 void JSFloat64Array::getOwnPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
235 {
236     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(object);
237     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
238     for (unsigned i = 0; i < static_cast<Float64Array*>(thisObject->impl())->length(); ++i)
239         propertyNames.add(Identifier::from(exec, i));
240      Base::getOwnPropertyNames(thisObject, exec, propertyNames, mode);
241 }
242
243 JSValue JSFloat64Array::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
244 {
245     return getDOMConstructor<JSFloat64ArrayConstructor>(exec, jsCast<JSDOMGlobalObject*>(globalObject));
246 }
247
248 EncodedJSValue JSC_HOST_CALL jsFloat64ArrayPrototypeFunctionFoo(ExecState* exec)
249 {
250     JSValue thisValue = exec->hostThisValue();
251     if (!thisValue.inherits(&JSFloat64Array::s_info))
252         return throwVMTypeError(exec);
253     JSFloat64Array* castedThis = jsCast<JSFloat64Array*>(asObject(thisValue));
254     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSFloat64Array::s_info);
255     Float64Array* impl = static_cast<Float64Array*>(castedThis->impl());
256     if (exec->argumentCount() < 1)
257         return throwVMError(exec, createNotEnoughArgumentsError(exec));
258     Float32Array* array(toFloat32Array(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined)));
259     if (exec->hadException())
260         return JSValue::encode(jsUndefined());
261
262     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->foo(array)));
263     return JSValue::encode(result);
264 }
265
266 EncodedJSValue JSC_HOST_CALL jsFloat64ArrayPrototypeFunctionSet(ExecState* exec)
267 {
268     JSValue thisValue = exec->hostThisValue();
269     if (!thisValue.inherits(&JSFloat64Array::s_info))
270         return throwVMTypeError(exec);
271     JSFloat64Array* castedThis = jsCast<JSFloat64Array*>(asObject(thisValue));
272     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSFloat64Array::s_info);
273     return JSValue::encode(setWebGLArrayHelper<Float64Array, double>(exec, castedThis->impl()));
274 }
275
276
277 JSValue JSFloat64Array::getByIndex(ExecState*, unsigned index)
278 {
279     ASSERT_GC_OBJECT_INHERITS(this, &s_info);
280     double result = static_cast<Float64Array*>(impl())->item(index);
281     if (isnan(result))
282         return jsNaN();
283     return JSValue(result);
284 }
285
286 Float64Array* toFloat64Array(JSC::JSValue value)
287 {
288     return value.inherits(&JSFloat64Array::s_info) ? jsCast<JSFloat64Array*>(asObject(value))->impl() : 0;
289 }
290
291 }