Reduce memory use for static property maps
[WebKit-https.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 throwVMTypeError(exec);
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     putDirect(vm, vm.propertyNames->prototype, 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 void JSTestTypedefs::finishCreation(VM& vm)
231 {
232     Base::finishCreation(vm);
233     ASSERT(inherits(info()));
234 }
235
236 JSObject* JSTestTypedefs::createPrototype(VM& vm, JSGlobalObject* globalObject)
237 {
238     return JSTestTypedefsPrototype::create(vm, globalObject, JSTestTypedefsPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
239 }
240
241 void JSTestTypedefs::destroy(JSC::JSCell* cell)
242 {
243     JSTestTypedefs* thisObject = static_cast<JSTestTypedefs*>(cell);
244     thisObject->JSTestTypedefs::~JSTestTypedefs();
245 }
246
247 JSTestTypedefs::~JSTestTypedefs()
248 {
249     releaseImplIfNotNull();
250 }
251
252 bool JSTestTypedefs::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
253 {
254     JSTestTypedefs* thisObject = jsCast<JSTestTypedefs*>(object);
255     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
256     return getStaticValueSlot<JSTestTypedefs, Base>(exec, JSTestTypedefsTable, thisObject, propertyName, slot);
257 }
258
259 EncodedJSValue jsTestTypedefsUnsignedLongLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
260 {
261     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
262     UNUSED_PARAM(slotBase);
263     if (UNLIKELY(!castedThis)) {
264         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase)) {
265             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
266             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'unsignedLongLongAttr' on a non-TestTypedefs object."));
267             return JSValue::encode(jsUndefined());
268         }
269         return throwVMTypeError(exec);
270     }
271     UNUSED_PARAM(exec);
272     TestTypedefs& impl = castedThis->impl();
273     JSValue result = jsNumber(impl.unsignedLongLongAttr());
274     return JSValue::encode(result);
275 }
276
277
278 EncodedJSValue jsTestTypedefsImmutableSerializedScriptValue(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
279 {
280     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
281     UNUSED_PARAM(slotBase);
282     if (UNLIKELY(!castedThis)) {
283         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase)) {
284             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
285             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'immutableSerializedScriptValue' on a non-TestTypedefs object."));
286             return JSValue::encode(jsUndefined());
287         }
288         return throwVMTypeError(exec);
289     }
290     UNUSED_PARAM(exec);
291     TestTypedefs& impl = castedThis->impl();
292     JSValue result = impl.immutableSerializedScriptValue() ? impl.immutableSerializedScriptValue()->deserialize(exec, castedThis->globalObject(), 0) : jsNull();
293     return JSValue::encode(result);
294 }
295
296
297 EncodedJSValue jsTestTypedefsConstructorTestSubObj(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
298 {
299     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
300     UNUSED_PARAM(slotBase);
301     if (UNLIKELY(!castedThis)) {
302         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase)) {
303             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
304             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'TestSubObj' on a non-TestTypedefs object."));
305             return JSValue::encode(jsUndefined());
306         }
307         return throwVMTypeError(exec);
308     }
309     return JSValue::encode(JSTestSubObj::getConstructor(exec->vm(), castedThis->globalObject()));
310 }
311
312
313 EncodedJSValue jsTestTypedefsAttrWithGetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
314 {
315     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
316     UNUSED_PARAM(slotBase);
317     if (UNLIKELY(!castedThis)) {
318         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase)) {
319             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
320             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'attrWithGetterException' on a non-TestTypedefs object."));
321             return JSValue::encode(jsUndefined());
322         }
323         return throwVMTypeError(exec);
324     }
325     ExceptionCode ec = 0;
326     TestTypedefs& impl = castedThis->impl();
327     JSValue result = jsNumber(impl.attrWithGetterException(ec));
328     setDOMException(exec, ec);
329     return JSValue::encode(result);
330 }
331
332
333 EncodedJSValue jsTestTypedefsAttrWithSetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
334 {
335     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
336     UNUSED_PARAM(slotBase);
337     if (UNLIKELY(!castedThis)) {
338         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase)) {
339             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
340             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'attrWithSetterException' on a non-TestTypedefs object."));
341             return JSValue::encode(jsUndefined());
342         }
343         return throwVMTypeError(exec);
344     }
345     UNUSED_PARAM(exec);
346     TestTypedefs& impl = castedThis->impl();
347     JSValue result = jsNumber(impl.attrWithSetterException());
348     return JSValue::encode(result);
349 }
350
351
352 EncodedJSValue jsTestTypedefsStringAttrWithGetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
353 {
354     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
355     UNUSED_PARAM(slotBase);
356     if (UNLIKELY(!castedThis)) {
357         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase)) {
358             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
359             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'stringAttrWithGetterException' on a non-TestTypedefs object."));
360             return JSValue::encode(jsUndefined());
361         }
362         return throwVMTypeError(exec);
363     }
364     ExceptionCode ec = 0;
365     TestTypedefs& impl = castedThis->impl();
366     JSValue result = jsStringWithCache(exec, impl.stringAttrWithGetterException(ec));
367     setDOMException(exec, ec);
368     return JSValue::encode(result);
369 }
370
371
372 EncodedJSValue jsTestTypedefsStringAttrWithSetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
373 {
374     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
375     UNUSED_PARAM(slotBase);
376     if (UNLIKELY(!castedThis)) {
377         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase)) {
378             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
379             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'stringAttrWithSetterException' on a non-TestTypedefs object."));
380             return JSValue::encode(jsUndefined());
381         }
382         return throwVMTypeError(exec);
383     }
384     UNUSED_PARAM(exec);
385     TestTypedefs& impl = castedThis->impl();
386     JSValue result = jsStringWithCache(exec, impl.stringAttrWithSetterException());
387     return JSValue::encode(result);
388 }
389
390
391 EncodedJSValue jsTestTypedefsConstructor(ExecState* exec, JSObject* baseValue, EncodedJSValue thisValue, PropertyName)
392 {
393     UNUSED_PARAM(baseValue);
394     UNUSED_PARAM(thisValue);
395     JSTestTypedefsPrototype* domObject = jsDynamicCast<JSTestTypedefsPrototype*>(baseValue);
396     if (!domObject)
397         return throwVMTypeError(exec);
398     return JSValue::encode(JSTestTypedefs::getConstructor(exec->vm(), domObject->globalObject()));
399 }
400
401 void setJSTestTypedefsUnsignedLongLongAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
402 {
403     JSValue value = JSValue::decode(encodedValue);
404     UNUSED_PARAM(exec);
405     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
406     if (UNLIKELY(!castedThis)) {
407         throwVMTypeError(exec);
408         return;
409     }
410     TestTypedefs& impl = castedThis->impl();
411     unsigned long long nativeValue(toUInt64(exec, value, NormalConversion));
412     if (UNLIKELY(exec->hadException()))
413         return;
414     impl.setUnsignedLongLongAttr(nativeValue);
415 }
416
417
418 void setJSTestTypedefsImmutableSerializedScriptValue(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
419 {
420     JSValue value = JSValue::decode(encodedValue);
421     UNUSED_PARAM(exec);
422     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
423     if (UNLIKELY(!castedThis)) {
424         throwVMTypeError(exec);
425         return;
426     }
427     TestTypedefs& impl = castedThis->impl();
428     RefPtr<SerializedScriptValue> nativeValue(SerializedScriptValue::create(exec, value, 0, 0));
429     if (UNLIKELY(exec->hadException()))
430         return;
431     impl.setImmutableSerializedScriptValue(nativeValue);
432 }
433
434
435 void setJSTestTypedefsAttrWithGetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
436 {
437     JSValue value = JSValue::decode(encodedValue);
438     UNUSED_PARAM(exec);
439     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
440     if (UNLIKELY(!castedThis)) {
441         throwVMTypeError(exec);
442         return;
443     }
444     TestTypedefs& impl = castedThis->impl();
445     int nativeValue(toInt32(exec, value, NormalConversion));
446     if (UNLIKELY(exec->hadException()))
447         return;
448     impl.setAttrWithGetterException(nativeValue);
449 }
450
451
452 void setJSTestTypedefsAttrWithSetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
453 {
454     JSValue value = JSValue::decode(encodedValue);
455     UNUSED_PARAM(exec);
456     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
457     if (UNLIKELY(!castedThis)) {
458         throwVMTypeError(exec);
459         return;
460     }
461     TestTypedefs& impl = castedThis->impl();
462     ExceptionCode ec = 0;
463     int nativeValue(toInt32(exec, value, NormalConversion));
464     if (UNLIKELY(exec->hadException()))
465         return;
466     impl.setAttrWithSetterException(nativeValue, ec);
467     setDOMException(exec, ec);
468 }
469
470
471 void setJSTestTypedefsStringAttrWithGetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
472 {
473     JSValue value = JSValue::decode(encodedValue);
474     UNUSED_PARAM(exec);
475     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
476     if (UNLIKELY(!castedThis)) {
477         throwVMTypeError(exec);
478         return;
479     }
480     TestTypedefs& impl = castedThis->impl();
481     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
482     if (UNLIKELY(exec->hadException()))
483         return;
484     impl.setStringAttrWithGetterException(nativeValue);
485 }
486
487
488 void setJSTestTypedefsStringAttrWithSetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
489 {
490     JSValue value = JSValue::decode(encodedValue);
491     UNUSED_PARAM(exec);
492     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
493     if (UNLIKELY(!castedThis)) {
494         throwVMTypeError(exec);
495         return;
496     }
497     TestTypedefs& impl = castedThis->impl();
498     ExceptionCode ec = 0;
499     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
500     if (UNLIKELY(exec->hadException()))
501         return;
502     impl.setStringAttrWithSetterException(nativeValue, ec);
503     setDOMException(exec, ec);
504 }
505
506
507 JSValue JSTestTypedefs::getConstructor(VM& vm, JSGlobalObject* globalObject)
508 {
509     return getDOMConstructor<JSTestTypedefsConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
510 }
511
512 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionFunc(ExecState* exec)
513 {
514     JSValue thisValue = exec->hostThisValue();
515     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
516     if (UNLIKELY(!castedThis))
517         return throwVMTypeError(exec);
518     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
519     TestTypedefs& impl = castedThis->impl();
520
521     size_t argsCount = exec->argumentCount();
522     if (argsCount <= 0) {
523         impl.func();
524         return JSValue::encode(jsUndefined());
525     }
526
527     Vector<int> x(toNativeArray<int>(exec, exec->argument(0)));
528     if (UNLIKELY(exec->hadException()))
529         return JSValue::encode(jsUndefined());
530     impl.func(x);
531     return JSValue::encode(jsUndefined());
532 }
533
534 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionSetShadow(ExecState* exec)
535 {
536     JSValue thisValue = exec->hostThisValue();
537     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
538     if (UNLIKELY(!castedThis))
539         return throwVMTypeError(exec);
540     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
541     TestTypedefs& impl = castedThis->impl();
542     if (exec->argumentCount() < 3)
543         return throwVMError(exec, createNotEnoughArgumentsError(exec));
544     float width(exec->argument(0).toFloat(exec));
545     if (UNLIKELY(exec->hadException()))
546         return JSValue::encode(jsUndefined());
547     float height(exec->argument(1).toFloat(exec));
548     if (UNLIKELY(exec->hadException()))
549         return JSValue::encode(jsUndefined());
550     float blur(exec->argument(2).toFloat(exec));
551     if (UNLIKELY(exec->hadException()))
552         return JSValue::encode(jsUndefined());
553
554     size_t argsCount = exec->argumentCount();
555     if (argsCount <= 3) {
556         impl.setShadow(width, height, blur);
557         return JSValue::encode(jsUndefined());
558     }
559
560     const String& color(exec->argument(3).isEmpty() ? String() : exec->argument(3).toString(exec)->value(exec));
561     if (UNLIKELY(exec->hadException()))
562         return JSValue::encode(jsUndefined());
563     if (argsCount <= 4) {
564         impl.setShadow(width, height, blur, color);
565         return JSValue::encode(jsUndefined());
566     }
567
568     float alpha(exec->argument(4).toFloat(exec));
569     if (UNLIKELY(exec->hadException()))
570         return JSValue::encode(jsUndefined());
571     impl.setShadow(width, height, blur, color, alpha);
572     return JSValue::encode(jsUndefined());
573 }
574
575 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionMethodWithSequenceArg(ExecState* exec)
576 {
577     JSValue thisValue = exec->hostThisValue();
578     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
579     if (UNLIKELY(!castedThis))
580         return throwVMTypeError(exec);
581     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
582     TestTypedefs& impl = castedThis->impl();
583     if (exec->argumentCount() < 1)
584         return throwVMError(exec, createNotEnoughArgumentsError(exec));
585     Vector<RefPtr<SerializedScriptValue>> sequenceArg((toRefPtrNativeArray<SerializedScriptValue, JSSerializedScriptValue>(exec, exec->argument(0), &toSerializedScriptValue)));
586     if (UNLIKELY(exec->hadException()))
587         return JSValue::encode(jsUndefined());
588     JSValue result = jsNumber(impl.methodWithSequenceArg(sequenceArg));
589     return JSValue::encode(result);
590 }
591
592 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionNullableArrayArg(ExecState* exec)
593 {
594     JSValue thisValue = exec->hostThisValue();
595     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
596     if (UNLIKELY(!castedThis))
597         return throwVMTypeError(exec);
598     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
599     TestTypedefs& impl = castedThis->impl();
600     if (exec->argumentCount() < 1)
601         return throwVMError(exec, createNotEnoughArgumentsError(exec));
602     Vector<String> arrayArg(toNativeArray<String>(exec, exec->argument(0)));
603     if (UNLIKELY(exec->hadException()))
604         return JSValue::encode(jsUndefined());
605     impl.nullableArrayArg(arrayArg);
606     return JSValue::encode(jsUndefined());
607 }
608
609 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionFuncWithClamp(ExecState* exec)
610 {
611     JSValue thisValue = exec->hostThisValue();
612     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
613     if (UNLIKELY(!castedThis))
614         return throwVMTypeError(exec);
615     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
616     TestTypedefs& impl = castedThis->impl();
617     if (exec->argumentCount() < 1)
618         return throwVMError(exec, createNotEnoughArgumentsError(exec));
619     unsigned long long arg1 = 0;
620     double arg1NativeValue = exec->argument(0).toNumber(exec);
621     if (UNLIKELY(exec->hadException()))
622         return JSValue::encode(jsUndefined());
623
624     if (!std::isnan(arg1NativeValue))
625         arg1 = clampTo<unsigned long long>(arg1NativeValue);
626
627
628     size_t argsCount = exec->argumentCount();
629     if (argsCount <= 1) {
630         impl.funcWithClamp(arg1);
631         return JSValue::encode(jsUndefined());
632     }
633
634     unsigned long long arg2 = 0;
635     double arg2NativeValue = exec->argument(1).toNumber(exec);
636     if (UNLIKELY(exec->hadException()))
637         return JSValue::encode(jsUndefined());
638
639     if (!std::isnan(arg2NativeValue))
640         arg2 = clampTo<unsigned long long>(arg2NativeValue);
641
642     impl.funcWithClamp(arg1, arg2);
643     return JSValue::encode(jsUndefined());
644 }
645
646 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionImmutablePointFunction(ExecState* exec)
647 {
648     JSValue thisValue = exec->hostThisValue();
649     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
650     if (UNLIKELY(!castedThis))
651         return throwVMTypeError(exec);
652     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
653     TestTypedefs& impl = castedThis->impl();
654     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePointFunction())));
655     return JSValue::encode(result);
656 }
657
658 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionStringArrayFunction(ExecState* exec)
659 {
660     JSValue thisValue = exec->hostThisValue();
661     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
662     if (UNLIKELY(!castedThis))
663         return throwVMTypeError(exec);
664     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
665     TestTypedefs& impl = castedThis->impl();
666     if (exec->argumentCount() < 1)
667         return throwVMError(exec, createNotEnoughArgumentsError(exec));
668     ExceptionCode ec = 0;
669     Vector<String> values(toNativeArray<String>(exec, exec->argument(0)));
670     if (UNLIKELY(exec->hadException()))
671         return JSValue::encode(jsUndefined());
672     JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction(values, ec));
673
674     setDOMException(exec, ec);
675     return JSValue::encode(result);
676 }
677
678 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionStringArrayFunction2(ExecState* exec)
679 {
680     JSValue thisValue = exec->hostThisValue();
681     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
682     if (UNLIKELY(!castedThis))
683         return throwVMTypeError(exec);
684     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
685     TestTypedefs& impl = castedThis->impl();
686     if (exec->argumentCount() < 1)
687         return throwVMError(exec, createNotEnoughArgumentsError(exec));
688     ExceptionCode ec = 0;
689     Vector<String> values(toNativeArray<String>(exec, exec->argument(0)));
690     if (UNLIKELY(exec->hadException()))
691         return JSValue::encode(jsUndefined());
692     JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction2(values, ec));
693
694     setDOMException(exec, ec);
695     return JSValue::encode(result);
696 }
697
698 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionCallWithSequenceThatRequiresInclude(ExecState* exec)
699 {
700     JSValue thisValue = exec->hostThisValue();
701     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
702     if (UNLIKELY(!castedThis))
703         return throwVMTypeError(exec);
704     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
705     TestTypedefs& impl = castedThis->impl();
706     if (exec->argumentCount() < 1)
707         return throwVMError(exec, createNotEnoughArgumentsError(exec));
708     Vector<RefPtr<TestEventTarget>> sequenceArg((toRefPtrNativeArray<TestEventTarget, JSTestEventTarget>(exec, exec->argument(0), &toTestEventTarget)));
709     if (UNLIKELY(exec->hadException()))
710         return JSValue::encode(jsUndefined());
711     JSValue result = jsBoolean(impl.callWithSequenceThatRequiresInclude(sequenceArg));
712     return JSValue::encode(result);
713 }
714
715 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionMethodWithException(ExecState* exec)
716 {
717     JSValue thisValue = exec->hostThisValue();
718     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
719     if (UNLIKELY(!castedThis))
720         return throwVMTypeError(exec);
721     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
722     TestTypedefs& impl = castedThis->impl();
723     ExceptionCode ec = 0;
724     impl.methodWithException(ec);
725     setDOMException(exec, ec);
726     return JSValue::encode(jsUndefined());
727 }
728
729 bool JSTestTypedefsOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
730 {
731     UNUSED_PARAM(handle);
732     UNUSED_PARAM(visitor);
733     return false;
734 }
735
736 void JSTestTypedefsOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
737 {
738     JSTestTypedefs* jsTestTypedefs = jsCast<JSTestTypedefs*>(handle.get().asCell());
739     DOMWrapperWorld& world = *static_cast<DOMWrapperWorld*>(context);
740     uncacheWrapper(world, &jsTestTypedefs->impl(), jsTestTypedefs);
741     jsTestTypedefs->releaseImpl();
742 }
743
744 #if ENABLE(BINDING_INTEGRITY)
745 #if PLATFORM(WIN)
746 #pragma warning(disable: 4483)
747 extern "C" { extern void (*const __identifier("??_7TestTypedefs@WebCore@@6B@")[])(); }
748 #else
749 extern "C" { extern void* _ZTVN7WebCore12TestTypedefsE[]; }
750 #endif
751 #endif
752 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestTypedefs* impl)
753 {
754     if (!impl)
755         return jsNull();
756     if (JSValue result = getExistingWrapper<JSTestTypedefs>(exec, impl))
757         return result;
758
759 #if ENABLE(BINDING_INTEGRITY)
760     void* actualVTablePointer = *(reinterpret_cast<void**>(impl));
761 #if PLATFORM(WIN)
762     void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7TestTypedefs@WebCore@@6B@"));
763 #else
764     void* expectedVTablePointer = &_ZTVN7WebCore12TestTypedefsE[2];
765 #if COMPILER(CLANG)
766     // If this fails TestTypedefs does not have a vtable, so you need to add the
767     // ImplementationLacksVTable attribute to the interface definition
768     COMPILE_ASSERT(__is_polymorphic(TestTypedefs), TestTypedefs_is_not_polymorphic);
769 #endif
770 #endif
771     // If you hit this assertion you either have a use after free bug, or
772     // TestTypedefs has subclasses. If TestTypedefs has subclasses that get passed
773     // to toJS() we currently require TestTypedefs you to opt out of binding hardening
774     // by adding the SkipVTableValidation attribute to the interface IDL definition
775     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
776 #endif
777     return createNewWrapper<JSTestTypedefs>(exec, globalObject, impl);
778 }
779
780 TestTypedefs* toTestTypedefs(JSC::JSValue value)
781 {
782     return value.inherits(JSTestTypedefs::info()) ? &jsCast<JSTestTypedefs*>(value)->impl() : 0;
783 }
784
785 }