Rewrite Function.bind as a builtin
[WebKit.git] / Source / WebCore / bindings / scripts / test / JS / JSTestTypedefs.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 "JSTestTypedefs.h"
23
24 #include "DOMStringList.h"
25 #include "ExceptionCode.h"
26 #include "JSDOMBinding.h"
27 #include "JSDOMStringList.h"
28 #include "JSSVGPoint.h"
29 #include "JSSerializedScriptValue.h"
30 #include "JSTestCallback.h"
31 #include "JSTestEventTarget.h"
32 #include "JSTestSubObj.h"
33 #include "SVGPoint.h"
34 #include "ScriptExecutionContext.h"
35 #include "SerializedScriptValue.h"
36 #include "TestTypedefs.h"
37 #include "URL.h"
38 #include <runtime/Error.h>
39 #include <runtime/JSArray.h>
40 #include <runtime/JSString.h>
41 #include <wtf/GetPtr.h>
42
43 using namespace JSC;
44
45 namespace WebCore {
46
47 /* Hash table */
48
49 static const struct CompactHashIndex JSTestTypedefsTableIndex[2] = {
50     { -1, -1 },
51     { -1, -1 },
52 };
53
54
55 static const HashTableValue JSTestTypedefsTableValues[] =
56 {
57     { 0, 0, NoIntrinsic, 0, 0 }
58 };
59
60 static const HashTable JSTestTypedefsTable = { 0, 1, false, JSTestTypedefsTableValues, 0, JSTestTypedefsTableIndex };
61 /* Hash table for constructor */
62
63 static const struct CompactHashIndex JSTestTypedefsConstructorTableIndex[1] = {
64     { 0, -1 },
65 };
66
67
68 static const HashTableValue JSTestTypedefsConstructorTableValues[] =
69 {
70     { "TestSubObj", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsConstructorTestSubObj), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
71 };
72
73 static const HashTable JSTestTypedefsConstructorTable = { 1, 0, true, JSTestTypedefsConstructorTableValues, 0, JSTestTypedefsConstructorTableIndex };
74 EncodedJSValue JSC_HOST_CALL JSTestTypedefsConstructor::constructJSTestTypedefs(ExecState* exec)
75 {
76     JSTestTypedefsConstructor* castedThis = jsCast<JSTestTypedefsConstructor*>(exec->callee());
77     if (exec->argumentCount() < 2)
78         return throwVMError(exec, createNotEnoughArgumentsError(exec));
79     const String& hello(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
80     if (UNLIKELY(exec->hadException()))
81         return JSValue::encode(jsUndefined());
82     if (!exec->argument(1).isFunction())
83         return throwArgumentMustBeFunctionError(*exec, 1, "testCallback", "TestTypedefs", nullptr);
84     RefPtr<TestCallback> testCallback = JSTestCallback::create(asObject(exec->uncheckedArgument(1)), castedThis->globalObject());
85     RefPtr<TestTypedefs> object = TestTypedefs::create(hello, testCallback);
86     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
87 }
88
89 const ClassInfo JSTestTypedefsConstructor::s_info = { "TestTypedefsConstructor", &Base::s_info, &JSTestTypedefsConstructorTable, 0, CREATE_METHOD_TABLE(JSTestTypedefsConstructor) };
90
91 JSTestTypedefsConstructor::JSTestTypedefsConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
92     : DOMConstructorObject(structure, globalObject)
93 {
94 }
95
96 void JSTestTypedefsConstructor::finishCreation(VM& vm, JSDOMGlobalObject* globalObject)
97 {
98     Base::finishCreation(vm);
99     ASSERT(inherits(info()));
100     putDirectPrototypeProperty(vm, JSTestTypedefsPrototype::self(vm, globalObject), DontDelete | ReadOnly);
101     putDirect(vm, vm.propertyNames->length, jsNumber(2), ReadOnly | DontDelete | DontEnum);
102 }
103
104 bool JSTestTypedefsConstructor::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
105 {
106     return getStaticValueSlot<JSTestTypedefsConstructor, JSDOMWrapper>(exec, JSTestTypedefsConstructorTable, jsCast<JSTestTypedefsConstructor*>(object), propertyName, slot);
107 }
108
109 ConstructType JSTestTypedefsConstructor::getConstructData(JSCell*, ConstructData& constructData)
110 {
111     constructData.native.function = constructJSTestTypedefs;
112     return ConstructTypeHost;
113 }
114
115 /* Hash table for prototype */
116
117 static const struct CompactHashIndex JSTestTypedefsPrototypeTableIndex[66] = {
118     { -1, -1 },
119     { -1, -1 },
120     { -1, -1 },
121     { -1, -1 },
122     { 9, -1 },
123     { -1, -1 },
124     { -1, -1 },
125     { -1, -1 },
126     { -1, -1 },
127     { -1, -1 },
128     { -1, -1 },
129     { -1, -1 },
130     { -1, -1 },
131     { -1, -1 },
132     { -1, -1 },
133     { -1, -1 },
134     { -1, -1 },
135     { -1, -1 },
136     { -1, -1 },
137     { 16, -1 },
138     { -1, -1 },
139     { -1, -1 },
140     { 2, -1 },
141     { -1, -1 },
142     { -1, -1 },
143     { 0, 64 },
144     { -1, -1 },
145     { -1, -1 },
146     { -1, -1 },
147     { -1, -1 },
148     { 11, -1 },
149     { -1, -1 },
150     { -1, -1 },
151     { 5, -1 },
152     { -1, -1 },
153     { 8, -1 },
154     { -1, -1 },
155     { 12, -1 },
156     { -1, -1 },
157     { -1, -1 },
158     { -1, -1 },
159     { -1, -1 },
160     { -1, -1 },
161     { 15, -1 },
162     { -1, -1 },
163     { -1, -1 },
164     { -1, -1 },
165     { -1, -1 },
166     { -1, -1 },
167     { -1, -1 },
168     { -1, -1 },
169     { 14, -1 },
170     { -1, -1 },
171     { 1, -1 },
172     { 3, -1 },
173     { 4, 65 },
174     { -1, -1 },
175     { -1, -1 },
176     { 10, -1 },
177     { -1, -1 },
178     { -1, -1 },
179     { 13, -1 },
180     { -1, -1 },
181     { -1, -1 },
182     { 6, -1 },
183     { 7, -1 },
184 };
185
186
187 static const HashTableValue JSTestTypedefsPrototypeTableValues[] =
188 {
189     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
190     { "unsignedLongLongAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsUnsignedLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsUnsignedLongLongAttr) },
191     { "immutableSerializedScriptValue", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsImmutableSerializedScriptValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsImmutableSerializedScriptValue) },
192     { "attrWithGetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsAttrWithGetterException) },
193     { "attrWithSetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsAttrWithSetterException) },
194     { "stringAttrWithGetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsStringAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsStringAttrWithGetterException) },
195     { "stringAttrWithSetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsStringAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsStringAttrWithSetterException) },
196     { "func", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionFunc), (intptr_t) (0) },
197     { "setShadow", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionSetShadow), (intptr_t) (3) },
198     { "methodWithSequenceArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionMethodWithSequenceArg), (intptr_t) (1) },
199     { "nullableArrayArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionNullableArrayArg), (intptr_t) (1) },
200     { "funcWithClamp", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionFuncWithClamp), (intptr_t) (1) },
201     { "immutablePointFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionImmutablePointFunction), (intptr_t) (0) },
202     { "stringArrayFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionStringArrayFunction), (intptr_t) (1) },
203     { "stringArrayFunction2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionStringArrayFunction2), (intptr_t) (1) },
204     { "callWithSequenceThatRequiresInclude", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionCallWithSequenceThatRequiresInclude), (intptr_t) (1) },
205     { "methodWithException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionMethodWithException), (intptr_t) (0) },
206 };
207
208 static const HashTable JSTestTypedefsPrototypeTable = { 17, 63, true, JSTestTypedefsPrototypeTableValues, 0, JSTestTypedefsPrototypeTableIndex };
209 const ClassInfo JSTestTypedefsPrototype::s_info = { "TestTypedefsPrototype", &Base::s_info, &JSTestTypedefsPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestTypedefsPrototype) };
210
211 JSObject* JSTestTypedefsPrototype::self(VM& vm, JSGlobalObject* globalObject)
212 {
213     return getDOMPrototype<JSTestTypedefs>(vm, globalObject);
214 }
215
216 bool JSTestTypedefsPrototype::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
217 {
218     JSTestTypedefsPrototype* thisObject = jsCast<JSTestTypedefsPrototype*>(object);
219     return getStaticPropertySlot<JSTestTypedefsPrototype, JSObject>(exec, JSTestTypedefsPrototypeTable, thisObject, propertyName, slot);
220 }
221
222 const ClassInfo JSTestTypedefs::s_info = { "TestTypedefs", &Base::s_info, &JSTestTypedefsTable, 0 , CREATE_METHOD_TABLE(JSTestTypedefs) };
223
224 JSTestTypedefs::JSTestTypedefs(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestTypedefs> impl)
225     : JSDOMWrapper(structure, globalObject)
226     , m_impl(impl.leakRef())
227 {
228 }
229
230 JSObject* JSTestTypedefs::createPrototype(VM& vm, JSGlobalObject* globalObject)
231 {
232     return JSTestTypedefsPrototype::create(vm, globalObject, JSTestTypedefsPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
233 }
234
235 void JSTestTypedefs::destroy(JSC::JSCell* cell)
236 {
237     JSTestTypedefs* thisObject = static_cast<JSTestTypedefs*>(cell);
238     thisObject->JSTestTypedefs::~JSTestTypedefs();
239 }
240
241 JSTestTypedefs::~JSTestTypedefs()
242 {
243     releaseImplIfNotNull();
244 }
245
246 bool JSTestTypedefs::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
247 {
248     JSTestTypedefs* thisObject = jsCast<JSTestTypedefs*>(object);
249     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
250     return getStaticValueSlot<JSTestTypedefs, Base>(exec, JSTestTypedefsTable, thisObject, propertyName, slot);
251 }
252
253 EncodedJSValue jsTestTypedefsUnsignedLongLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
254 {
255     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
256     if (UNLIKELY(!castedThis)) {
257         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
258             return reportDeprecatedGetterError(*exec, "TestTypedefs", "unsignedLongLongAttr");
259         return throwGetterTypeError(*exec, "TestTypedefs", "unsignedLongLongAttr");
260     }
261     TestTypedefs& impl = castedThis->impl();
262     JSValue result = jsNumber(impl.unsignedLongLongAttr());
263     return JSValue::encode(result);
264 }
265
266
267 EncodedJSValue jsTestTypedefsImmutableSerializedScriptValue(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
268 {
269     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
270     if (UNLIKELY(!castedThis)) {
271         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
272             return reportDeprecatedGetterError(*exec, "TestTypedefs", "immutableSerializedScriptValue");
273         return throwGetterTypeError(*exec, "TestTypedefs", "immutableSerializedScriptValue");
274     }
275     TestTypedefs& impl = castedThis->impl();
276     JSValue result = impl.immutableSerializedScriptValue() ? impl.immutableSerializedScriptValue()->deserialize(exec, castedThis->globalObject(), 0) : jsNull();
277     return JSValue::encode(result);
278 }
279
280
281 EncodedJSValue jsTestTypedefsConstructorTestSubObj(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
282 {
283     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
284     if (UNLIKELY(!castedThis)) {
285         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
286             return reportDeprecatedGetterError(*exec, "TestTypedefs", "TestSubObj");
287         return throwGetterTypeError(*exec, "TestTypedefs", "TestSubObj");
288     }
289     return JSValue::encode(JSTestSubObj::getConstructor(exec->vm(), castedThis->globalObject()));
290 }
291
292
293 EncodedJSValue jsTestTypedefsAttrWithGetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
294 {
295     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
296     if (UNLIKELY(!castedThis)) {
297         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
298             return reportDeprecatedGetterError(*exec, "TestTypedefs", "attrWithGetterException");
299         return throwGetterTypeError(*exec, "TestTypedefs", "attrWithGetterException");
300     }
301     ExceptionCode ec = 0;
302     TestTypedefs& impl = castedThis->impl();
303     JSValue result = jsNumber(impl.attrWithGetterException(ec));
304     setDOMException(exec, ec);
305     return JSValue::encode(result);
306 }
307
308
309 EncodedJSValue jsTestTypedefsAttrWithSetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
310 {
311     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
312     if (UNLIKELY(!castedThis)) {
313         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
314             return reportDeprecatedGetterError(*exec, "TestTypedefs", "attrWithSetterException");
315         return throwGetterTypeError(*exec, "TestTypedefs", "attrWithSetterException");
316     }
317     TestTypedefs& impl = castedThis->impl();
318     JSValue result = jsNumber(impl.attrWithSetterException());
319     return JSValue::encode(result);
320 }
321
322
323 EncodedJSValue jsTestTypedefsStringAttrWithGetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
324 {
325     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
326     if (UNLIKELY(!castedThis)) {
327         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
328             return reportDeprecatedGetterError(*exec, "TestTypedefs", "stringAttrWithGetterException");
329         return throwGetterTypeError(*exec, "TestTypedefs", "stringAttrWithGetterException");
330     }
331     ExceptionCode ec = 0;
332     TestTypedefs& impl = castedThis->impl();
333     JSValue result = jsStringWithCache(exec, impl.stringAttrWithGetterException(ec));
334     setDOMException(exec, ec);
335     return JSValue::encode(result);
336 }
337
338
339 EncodedJSValue jsTestTypedefsStringAttrWithSetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
340 {
341     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
342     if (UNLIKELY(!castedThis)) {
343         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
344             return reportDeprecatedGetterError(*exec, "TestTypedefs", "stringAttrWithSetterException");
345         return throwGetterTypeError(*exec, "TestTypedefs", "stringAttrWithSetterException");
346     }
347     TestTypedefs& impl = castedThis->impl();
348     JSValue result = jsStringWithCache(exec, impl.stringAttrWithSetterException());
349     return JSValue::encode(result);
350 }
351
352
353 EncodedJSValue jsTestTypedefsConstructor(ExecState* exec, JSObject* baseValue, EncodedJSValue, PropertyName)
354 {
355     JSTestTypedefsPrototype* domObject = jsDynamicCast<JSTestTypedefsPrototype*>(baseValue);
356     if (!domObject)
357         return throwVMTypeError(exec);
358     return JSValue::encode(JSTestTypedefs::getConstructor(exec->vm(), domObject->globalObject()));
359 }
360
361 void setJSTestTypedefsUnsignedLongLongAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
362 {
363     JSValue value = JSValue::decode(encodedValue);
364     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
365     if (UNLIKELY(!castedThis)) {
366         throwSetterTypeError(*exec, "TestTypedefs", "unsignedLongLongAttr");
367         return;
368     }
369     TestTypedefs& impl = castedThis->impl();
370     unsigned long long nativeValue(toUInt64(exec, value, NormalConversion));
371     if (UNLIKELY(exec->hadException()))
372         return;
373     impl.setUnsignedLongLongAttr(nativeValue);
374 }
375
376
377 void setJSTestTypedefsImmutableSerializedScriptValue(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
378 {
379     JSValue value = JSValue::decode(encodedValue);
380     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
381     if (UNLIKELY(!castedThis)) {
382         throwSetterTypeError(*exec, "TestTypedefs", "immutableSerializedScriptValue");
383         return;
384     }
385     TestTypedefs& impl = castedThis->impl();
386     RefPtr<SerializedScriptValue> nativeValue(SerializedScriptValue::create(exec, value, 0, 0));
387     if (UNLIKELY(exec->hadException()))
388         return;
389     impl.setImmutableSerializedScriptValue(nativeValue);
390 }
391
392
393 void setJSTestTypedefsAttrWithGetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
394 {
395     JSValue value = JSValue::decode(encodedValue);
396     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
397     if (UNLIKELY(!castedThis)) {
398         throwSetterTypeError(*exec, "TestTypedefs", "attrWithGetterException");
399         return;
400     }
401     TestTypedefs& impl = castedThis->impl();
402     int nativeValue(toInt32(exec, value, NormalConversion));
403     if (UNLIKELY(exec->hadException()))
404         return;
405     impl.setAttrWithGetterException(nativeValue);
406 }
407
408
409 void setJSTestTypedefsAttrWithSetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
410 {
411     JSValue value = JSValue::decode(encodedValue);
412     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
413     if (UNLIKELY(!castedThis)) {
414         throwSetterTypeError(*exec, "TestTypedefs", "attrWithSetterException");
415         return;
416     }
417     TestTypedefs& impl = castedThis->impl();
418     ExceptionCode ec = 0;
419     int nativeValue(toInt32(exec, value, NormalConversion));
420     if (UNLIKELY(exec->hadException()))
421         return;
422     impl.setAttrWithSetterException(nativeValue, ec);
423     setDOMException(exec, ec);
424 }
425
426
427 void setJSTestTypedefsStringAttrWithGetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
428 {
429     JSValue value = JSValue::decode(encodedValue);
430     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
431     if (UNLIKELY(!castedThis)) {
432         throwSetterTypeError(*exec, "TestTypedefs", "stringAttrWithGetterException");
433         return;
434     }
435     TestTypedefs& impl = castedThis->impl();
436     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
437     if (UNLIKELY(exec->hadException()))
438         return;
439     impl.setStringAttrWithGetterException(nativeValue);
440 }
441
442
443 void setJSTestTypedefsStringAttrWithSetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
444 {
445     JSValue value = JSValue::decode(encodedValue);
446     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
447     if (UNLIKELY(!castedThis)) {
448         throwSetterTypeError(*exec, "TestTypedefs", "stringAttrWithSetterException");
449         return;
450     }
451     TestTypedefs& impl = castedThis->impl();
452     ExceptionCode ec = 0;
453     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
454     if (UNLIKELY(exec->hadException()))
455         return;
456     impl.setStringAttrWithSetterException(nativeValue, ec);
457     setDOMException(exec, ec);
458 }
459
460
461 JSValue JSTestTypedefs::getConstructor(VM& vm, JSGlobalObject* globalObject)
462 {
463     return getDOMConstructor<JSTestTypedefsConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
464 }
465
466 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionFunc(ExecState* exec)
467 {
468     JSValue thisValue = exec->thisValue();
469     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
470     if (UNLIKELY(!castedThis))
471         return throwThisTypeError(*exec, "TestTypedefs", "func");
472     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
473     TestTypedefs& impl = castedThis->impl();
474
475     size_t argsCount = exec->argumentCount();
476     if (argsCount <= 0) {
477         impl.func();
478         return JSValue::encode(jsUndefined());
479     }
480
481     Vector<int> x(toNativeArray<int>(exec, exec->argument(0)));
482     if (UNLIKELY(exec->hadException()))
483         return JSValue::encode(jsUndefined());
484     impl.func(x);
485     return JSValue::encode(jsUndefined());
486 }
487
488 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionSetShadow(ExecState* exec)
489 {
490     JSValue thisValue = exec->thisValue();
491     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
492     if (UNLIKELY(!castedThis))
493         return throwThisTypeError(*exec, "TestTypedefs", "setShadow");
494     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
495     TestTypedefs& impl = castedThis->impl();
496     if (exec->argumentCount() < 3)
497         return throwVMError(exec, createNotEnoughArgumentsError(exec));
498     float width(exec->argument(0).toFloat(exec));
499     if (UNLIKELY(exec->hadException()))
500         return JSValue::encode(jsUndefined());
501     float height(exec->argument(1).toFloat(exec));
502     if (UNLIKELY(exec->hadException()))
503         return JSValue::encode(jsUndefined());
504     float blur(exec->argument(2).toFloat(exec));
505     if (UNLIKELY(exec->hadException()))
506         return JSValue::encode(jsUndefined());
507
508     size_t argsCount = exec->argumentCount();
509     if (argsCount <= 3) {
510         impl.setShadow(width, height, blur);
511         return JSValue::encode(jsUndefined());
512     }
513
514     const String& color(exec->argument(3).isEmpty() ? String() : exec->argument(3).toString(exec)->value(exec));
515     if (UNLIKELY(exec->hadException()))
516         return JSValue::encode(jsUndefined());
517     if (argsCount <= 4) {
518         impl.setShadow(width, height, blur, color);
519         return JSValue::encode(jsUndefined());
520     }
521
522     float alpha(exec->argument(4).toFloat(exec));
523     if (UNLIKELY(exec->hadException()))
524         return JSValue::encode(jsUndefined());
525     impl.setShadow(width, height, blur, color, alpha);
526     return JSValue::encode(jsUndefined());
527 }
528
529 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionMethodWithSequenceArg(ExecState* exec)
530 {
531     JSValue thisValue = exec->thisValue();
532     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
533     if (UNLIKELY(!castedThis))
534         return throwThisTypeError(*exec, "TestTypedefs", "methodWithSequenceArg");
535     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
536     TestTypedefs& impl = castedThis->impl();
537     if (exec->argumentCount() < 1)
538         return throwVMError(exec, createNotEnoughArgumentsError(exec));
539     Vector<RefPtr<SerializedScriptValue>> sequenceArg((toRefPtrNativeArray<SerializedScriptValue, JSSerializedScriptValue>(exec, exec->argument(0), &toSerializedScriptValue)));
540     if (UNLIKELY(exec->hadException()))
541         return JSValue::encode(jsUndefined());
542     JSValue result = jsNumber(impl.methodWithSequenceArg(sequenceArg));
543     return JSValue::encode(result);
544 }
545
546 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionNullableArrayArg(ExecState* exec)
547 {
548     JSValue thisValue = exec->thisValue();
549     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
550     if (UNLIKELY(!castedThis))
551         return throwThisTypeError(*exec, "TestTypedefs", "nullableArrayArg");
552     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
553     TestTypedefs& impl = castedThis->impl();
554     if (exec->argumentCount() < 1)
555         return throwVMError(exec, createNotEnoughArgumentsError(exec));
556     Vector<String> arrayArg(toNativeArray<String>(exec, exec->argument(0)));
557     if (UNLIKELY(exec->hadException()))
558         return JSValue::encode(jsUndefined());
559     impl.nullableArrayArg(arrayArg);
560     return JSValue::encode(jsUndefined());
561 }
562
563 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionFuncWithClamp(ExecState* exec)
564 {
565     JSValue thisValue = exec->thisValue();
566     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
567     if (UNLIKELY(!castedThis))
568         return throwThisTypeError(*exec, "TestTypedefs", "funcWithClamp");
569     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
570     TestTypedefs& impl = castedThis->impl();
571     if (exec->argumentCount() < 1)
572         return throwVMError(exec, createNotEnoughArgumentsError(exec));
573     unsigned long long arg1 = 0;
574     double arg1NativeValue = exec->argument(0).toNumber(exec);
575     if (UNLIKELY(exec->hadException()))
576         return JSValue::encode(jsUndefined());
577
578     if (!std::isnan(arg1NativeValue))
579         arg1 = clampTo<unsigned long long>(arg1NativeValue);
580
581
582     size_t argsCount = exec->argumentCount();
583     if (argsCount <= 1) {
584         impl.funcWithClamp(arg1);
585         return JSValue::encode(jsUndefined());
586     }
587
588     unsigned long long arg2 = 0;
589     double arg2NativeValue = exec->argument(1).toNumber(exec);
590     if (UNLIKELY(exec->hadException()))
591         return JSValue::encode(jsUndefined());
592
593     if (!std::isnan(arg2NativeValue))
594         arg2 = clampTo<unsigned long long>(arg2NativeValue);
595
596     impl.funcWithClamp(arg1, arg2);
597     return JSValue::encode(jsUndefined());
598 }
599
600 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionImmutablePointFunction(ExecState* exec)
601 {
602     JSValue thisValue = exec->thisValue();
603     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
604     if (UNLIKELY(!castedThis))
605         return throwThisTypeError(*exec, "TestTypedefs", "immutablePointFunction");
606     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
607     TestTypedefs& impl = castedThis->impl();
608     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePointFunction())));
609     return JSValue::encode(result);
610 }
611
612 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionStringArrayFunction(ExecState* exec)
613 {
614     JSValue thisValue = exec->thisValue();
615     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
616     if (UNLIKELY(!castedThis))
617         return throwThisTypeError(*exec, "TestTypedefs", "stringArrayFunction");
618     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
619     TestTypedefs& impl = castedThis->impl();
620     if (exec->argumentCount() < 1)
621         return throwVMError(exec, createNotEnoughArgumentsError(exec));
622     ExceptionCode ec = 0;
623     Vector<String> values(toNativeArray<String>(exec, exec->argument(0)));
624     if (UNLIKELY(exec->hadException()))
625         return JSValue::encode(jsUndefined());
626     JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction(values, ec));
627
628     setDOMException(exec, ec);
629     return JSValue::encode(result);
630 }
631
632 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionStringArrayFunction2(ExecState* exec)
633 {
634     JSValue thisValue = exec->thisValue();
635     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
636     if (UNLIKELY(!castedThis))
637         return throwThisTypeError(*exec, "TestTypedefs", "stringArrayFunction2");
638     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
639     TestTypedefs& impl = castedThis->impl();
640     if (exec->argumentCount() < 1)
641         return throwVMError(exec, createNotEnoughArgumentsError(exec));
642     ExceptionCode ec = 0;
643     Vector<String> values(toNativeArray<String>(exec, exec->argument(0)));
644     if (UNLIKELY(exec->hadException()))
645         return JSValue::encode(jsUndefined());
646     JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction2(values, ec));
647
648     setDOMException(exec, ec);
649     return JSValue::encode(result);
650 }
651
652 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionCallWithSequenceThatRequiresInclude(ExecState* exec)
653 {
654     JSValue thisValue = exec->thisValue();
655     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
656     if (UNLIKELY(!castedThis))
657         return throwThisTypeError(*exec, "TestTypedefs", "callWithSequenceThatRequiresInclude");
658     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
659     TestTypedefs& impl = castedThis->impl();
660     if (exec->argumentCount() < 1)
661         return throwVMError(exec, createNotEnoughArgumentsError(exec));
662     Vector<RefPtr<TestEventTarget>> sequenceArg((toRefPtrNativeArray<TestEventTarget, JSTestEventTarget>(exec, exec->argument(0), &toTestEventTarget)));
663     if (UNLIKELY(exec->hadException()))
664         return JSValue::encode(jsUndefined());
665     JSValue result = jsBoolean(impl.callWithSequenceThatRequiresInclude(sequenceArg));
666     return JSValue::encode(result);
667 }
668
669 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionMethodWithException(ExecState* exec)
670 {
671     JSValue thisValue = exec->thisValue();
672     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
673     if (UNLIKELY(!castedThis))
674         return throwThisTypeError(*exec, "TestTypedefs", "methodWithException");
675     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
676     TestTypedefs& impl = castedThis->impl();
677     ExceptionCode ec = 0;
678     impl.methodWithException(ec);
679     setDOMException(exec, ec);
680     return JSValue::encode(jsUndefined());
681 }
682
683 bool JSTestTypedefsOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
684 {
685     UNUSED_PARAM(handle);
686     UNUSED_PARAM(visitor);
687     return false;
688 }
689
690 void JSTestTypedefsOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
691 {
692     JSTestTypedefs* jsTestTypedefs = jsCast<JSTestTypedefs*>(handle.slot()->asCell());
693     DOMWrapperWorld& world = *static_cast<DOMWrapperWorld*>(context);
694     uncacheWrapper(world, &jsTestTypedefs->impl(), jsTestTypedefs);
695     jsTestTypedefs->releaseImpl();
696 }
697
698 #if ENABLE(BINDING_INTEGRITY)
699 #if PLATFORM(WIN)
700 #pragma warning(disable: 4483)
701 extern "C" { extern void (*const __identifier("??_7TestTypedefs@WebCore@@6B@")[])(); }
702 #else
703 extern "C" { extern void* _ZTVN7WebCore12TestTypedefsE[]; }
704 #endif
705 #endif
706 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestTypedefs* impl)
707 {
708     if (!impl)
709         return jsNull();
710     if (JSValue result = getExistingWrapper<JSTestTypedefs>(globalObject, impl))
711         return result;
712
713 #if ENABLE(BINDING_INTEGRITY)
714     void* actualVTablePointer = *(reinterpret_cast<void**>(impl));
715 #if PLATFORM(WIN)
716     void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7TestTypedefs@WebCore@@6B@"));
717 #else
718     void* expectedVTablePointer = &_ZTVN7WebCore12TestTypedefsE[2];
719 #if COMPILER(CLANG)
720     // If this fails TestTypedefs does not have a vtable, so you need to add the
721     // ImplementationLacksVTable attribute to the interface definition
722     COMPILE_ASSERT(__is_polymorphic(TestTypedefs), TestTypedefs_is_not_polymorphic);
723 #endif
724 #endif
725     // If you hit this assertion you either have a use after free bug, or
726     // TestTypedefs has subclasses. If TestTypedefs has subclasses that get passed
727     // to toJS() we currently require TestTypedefs you to opt out of binding hardening
728     // by adding the SkipVTableValidation attribute to the interface IDL definition
729     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
730 #endif
731     return createNewWrapper<JSTestTypedefs>(globalObject, impl);
732 }
733
734 TestTypedefs* toTestTypedefs(JSC::JSValue value)
735 {
736     if (auto* wrapper = jsDynamicCast<JSTestTypedefs*>(value))
737         return &wrapper->impl();
738     return nullptr;
739 }
740
741 }