Unreviewed, rebaselined run-bindings-tests results.
[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 "JSDOMBinding.h"
26 #include "JSFloat32Array.h"
27 #include "JSInt32Array.h"
28 #include <runtime/Error.h>
29 #include <runtime/PropertyNameArray.h>
30 #include <wtf/Float64Array.h>
31 #include <wtf/GetPtr.h>
32 #include <wtf/Int32Array.h>
33
34 using namespace JSC;
35
36 namespace WebCore {
37
38 ASSERT_CLASS_FITS_IN_CELL(JSFloat64Array);
39 /* Hash table */
40
41 static const HashTableValue JSFloat64ArrayTableValues[] =
42 {
43     { "constructor", DontEnum | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsFloat64ArrayConstructor), (intptr_t)0, NoIntrinsic },
44     { 0, 0, 0, 0, NoIntrinsic }
45 };
46
47 static const HashTable JSFloat64ArrayTable = { 2, 1, JSFloat64ArrayTableValues, 0 };
48 /* Hash table for constructor */
49
50 static const HashTableValue JSFloat64ArrayConstructorTableValues[] =
51 {
52     { 0, 0, 0, 0, NoIntrinsic }
53 };
54
55 static const HashTable JSFloat64ArrayConstructorTable = { 1, 0, JSFloat64ArrayConstructorTableValues, 0 };
56 const ClassInfo JSFloat64ArrayConstructor::s_info = { "Float64ArrayConstructor", &Base::s_info, &JSFloat64ArrayConstructorTable, 0, CREATE_METHOD_TABLE(JSFloat64ArrayConstructor) };
57
58 JSFloat64ArrayConstructor::JSFloat64ArrayConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
59     : DOMConstructorObject(structure, globalObject)
60 {
61 }
62
63 void JSFloat64ArrayConstructor::finishCreation(ExecState* exec, JSDOMGlobalObject* globalObject)
64 {
65     Base::finishCreation(exec->globalData());
66     ASSERT(inherits(&s_info));
67     putDirect(exec->globalData(), exec->propertyNames().prototype, JSFloat64ArrayPrototype::self(exec, globalObject), DontDelete | ReadOnly);
68     putDirect(exec->globalData(), exec->propertyNames().length, jsNumber(123), ReadOnly | DontDelete | DontEnum);
69 }
70
71 bool JSFloat64ArrayConstructor::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
72 {
73     return getStaticValueSlot<JSFloat64ArrayConstructor, JSDOMWrapper>(exec, &JSFloat64ArrayConstructorTable, jsCast<JSFloat64ArrayConstructor*>(cell), propertyName, slot);
74 }
75
76 bool JSFloat64ArrayConstructor::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
77 {
78     return getStaticValueDescriptor<JSFloat64ArrayConstructor, JSDOMWrapper>(exec, &JSFloat64ArrayConstructorTable, jsCast<JSFloat64ArrayConstructor*>(object), propertyName, descriptor);
79 }
80
81 ConstructType JSFloat64ArrayConstructor::getConstructData(JSCell*, ConstructData& constructData)
82 {
83     constructData.native.function = constructJSFloat64Array;
84     return ConstructTypeHost;
85 }
86
87 /* Hash table for prototype */
88
89 static const HashTableValue JSFloat64ArrayPrototypeTableValues[] =
90 {
91     { "foo", DontDelete | JSC::Function, (intptr_t)static_cast<NativeFunction>(jsFloat64ArrayPrototypeFunctionFoo), (intptr_t)1, NoIntrinsic },
92     { 0, 0, 0, 0, NoIntrinsic }
93 };
94
95 static const HashTable JSFloat64ArrayPrototypeTable = { 2, 1, JSFloat64ArrayPrototypeTableValues, 0 };
96 static const HashTable* getJSFloat64ArrayPrototypeTable(ExecState* exec)
97 {
98     return getHashTableForGlobalData(exec->globalData(), &JSFloat64ArrayPrototypeTable);
99 }
100
101 const ClassInfo JSFloat64ArrayPrototype::s_info = { "Float64ArrayPrototype", &Base::s_info, 0, getJSFloat64ArrayPrototypeTable, CREATE_METHOD_TABLE(JSFloat64ArrayPrototype) };
102
103 JSObject* JSFloat64ArrayPrototype::self(ExecState* exec, JSGlobalObject* globalObject)
104 {
105     return getDOMPrototype<JSFloat64Array>(exec, globalObject);
106 }
107
108 bool JSFloat64ArrayPrototype::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
109 {
110     JSFloat64ArrayPrototype* thisObject = jsCast<JSFloat64ArrayPrototype*>(cell);
111     return getStaticFunctionSlot<JSObject>(exec, getJSFloat64ArrayPrototypeTable(exec), thisObject, propertyName, slot);
112 }
113
114 bool JSFloat64ArrayPrototype::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
115 {
116     JSFloat64ArrayPrototype* thisObject = jsCast<JSFloat64ArrayPrototype*>(object);
117     return getStaticFunctionDescriptor<JSObject>(exec, getJSFloat64ArrayPrototypeTable(exec), thisObject, propertyName, descriptor);
118 }
119
120 static const HashTable* getJSFloat64ArrayTable(ExecState* exec)
121 {
122     return getHashTableForGlobalData(exec->globalData(), &JSFloat64ArrayTable);
123 }
124
125 const ClassInfo JSFloat64Array::s_info = { "Float64Array", &Base::s_info, 0, getJSFloat64ArrayTable , CREATE_METHOD_TABLE(JSFloat64Array) };
126
127 JSFloat64Array::JSFloat64Array(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<Float64Array> impl)
128     : JSArrayBufferView(structure, globalObject, impl)
129 {
130 }
131
132 void JSFloat64Array::finishCreation(JSGlobalData& globalData)
133 {
134     Base::finishCreation(globalData);
135     TypedArrayDescriptor descriptor(&JSFloat64Array::s_info, OBJECT_OFFSETOF(JSFloat64Array, m_storage), OBJECT_OFFSETOF(JSFloat64Array, m_storageLength));
136     globalData.registerTypedArrayDescriptor(impl(), descriptor);
137     m_storage = impl()->data();
138     m_storageLength = impl()->length();
139     ASSERT(inherits(&s_info));
140 }
141
142 JSObject* JSFloat64Array::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
143 {
144     return JSFloat64ArrayPrototype::create(exec->globalData(), globalObject, JSFloat64ArrayPrototype::createStructure(exec->globalData(), globalObject, JSArrayBufferViewPrototype::self(exec, globalObject)));
145 }
146
147 bool JSFloat64Array::getOwnPropertySlot(JSCell* cell, ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
148 {
149     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(cell);
150     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
151     bool ok;
152     unsigned index = propertyName.toUInt32(ok);
153     if (ok && index < static_cast<Float64Array*>(thisObject->impl())->length()) {
154         slot.setValue(thisObject->getByIndex(exec, index));
155         return true;
156     }
157     return getStaticValueSlot<JSFloat64Array, Base>(exec, getJSFloat64ArrayTable(exec), thisObject, propertyName, slot);
158 }
159
160 bool JSFloat64Array::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
161 {
162     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(object);
163     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
164     bool ok;
165     unsigned index = propertyName.toUInt32(ok);
166     if (ok && index < static_cast<Float64Array*>(thisObject->impl())->length()) {
167         descriptor.setDescriptor(thisObject->getByIndex(exec, index), DontDelete);
168         return true;
169     }
170     return getStaticValueDescriptor<JSFloat64Array, Base>(exec, getJSFloat64ArrayTable(exec), thisObject, propertyName, descriptor);
171 }
172
173 bool JSFloat64Array::getOwnPropertySlotByIndex(JSCell* cell, ExecState* exec, unsigned propertyName, PropertySlot& slot)
174 {
175     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(cell);
176     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
177     if (propertyName < static_cast<Float64Array*>(thisObject->impl())->length()) {
178         slot.setValue(thisObject->getByIndex(exec, propertyName));
179         return true;
180     }
181     return thisObject->methodTable()->getOwnPropertySlot(thisObject, exec, Identifier::from(exec, propertyName), slot);
182 }
183
184 JSValue jsFloat64ArrayConstructor(ExecState* exec, JSValue slotBase, const Identifier&)
185 {
186     JSFloat64Array* domObject = jsCast<JSFloat64Array*>(asObject(slotBase));
187     return JSFloat64Array::getConstructor(exec, domObject->globalObject());
188 }
189
190 void JSFloat64Array::put(JSCell* cell, ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
191 {
192     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(cell);
193     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
194     bool ok;
195     unsigned index = propertyName.toUInt32(ok);
196     if (ok) {
197         thisObject->indexSetter(exec, index, value);
198         return;
199     }
200     Base::put(thisObject, exec, propertyName, value, slot);
201 }
202
203 void JSFloat64Array::putByIndex(JSCell* cell, ExecState* exec, unsigned propertyName, JSValue value, bool)
204 {
205     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(cell);
206     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
207     thisObject->indexSetter(exec, propertyName, value);
208     return;
209 }
210
211 void JSFloat64Array::getOwnPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
212 {
213     JSFloat64Array* thisObject = jsCast<JSFloat64Array*>(object);
214     ASSERT_GC_OBJECT_INHERITS(thisObject, &s_info);
215     for (unsigned i = 0; i < static_cast<Float64Array*>(thisObject->impl())->length(); ++i)
216         propertyNames.add(Identifier::from(exec, i));
217      Base::getOwnPropertyNames(thisObject, exec, propertyNames, mode);
218 }
219
220 JSValue JSFloat64Array::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
221 {
222     return getDOMConstructor<JSFloat64ArrayConstructor>(exec, jsCast<JSDOMGlobalObject*>(globalObject));
223 }
224
225 EncodedJSValue JSC_HOST_CALL jsFloat64ArrayPrototypeFunctionFoo(ExecState* exec)
226 {
227     JSValue thisValue = exec->hostThisValue();
228     if (!thisValue.inherits(&JSFloat64Array::s_info))
229         return throwVMTypeError(exec);
230     JSFloat64Array* castedThis = jsCast<JSFloat64Array*>(asObject(thisValue));
231     ASSERT_GC_OBJECT_INHERITS(castedThis, &JSFloat64Array::s_info);
232     Float64Array* impl = static_cast<Float64Array*>(castedThis->impl());
233     if (exec->argumentCount() < 1)
234         return throwVMError(exec, createTypeError(exec, "Not enough arguments"));
235     Float32Array* array(toFloat32Array(MAYBE_MISSING_PARAMETER(exec, 0, DefaultIsUndefined)));
236     if (exec->hadException())
237         return JSValue::encode(jsUndefined());
238
239     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl->foo(array)));
240     return JSValue::encode(result);
241 }
242
243
244 JSValue JSFloat64Array::getByIndex(ExecState*, unsigned index)
245 {
246     ASSERT_GC_OBJECT_INHERITS(this, &s_info);
247     double result = static_cast<Float64Array*>(impl())->item(index);
248     if (isnan(result))
249         return jsNaN();
250     return JSValue(result);
251 }
252
253 Float64Array* toFloat64Array(JSC::JSValue value)
254 {
255     return value.inherits(&JSFloat64Array::s_info) ? jsCast<JSFloat64Array*>(asObject(value))->impl() : 0;
256 }
257
258 }