JSGenerateToNativeObject should use fast JSNode/JSElement casts.
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestInterface.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
23 #if ENABLE(Condition1) || ENABLE(Condition2)
24
25 #include "JSTestInterface.h"
26
27 #include "ExceptionCode.h"
28 #include "JSDOMBinding.h"
29 #include "JSTestObj.h"
30 #include "ScriptExecutionContext.h"
31 #include "TestInterface.h"
32 #include "TestObj.h"
33 #include "TestSupplemental.h"
34 #include <runtime/Error.h>
35 #include <wtf/GetPtr.h>
36
37 #if ENABLE(Condition11) || ENABLE(Condition12) || ENABLE(Condition22) || ENABLE(Condition23)
38 #include "JSNode.h"
39 #include "URL.h"
40 #include <runtime/JSString.h>
41 #endif
42
43 #if ENABLE(Condition11) || ENABLE(Condition12) || ENABLE(Condition22) || ENABLE(Condition23)
44 #include "Node.h"
45 #endif
46
47 using namespace JSC;
48
49 namespace WebCore {
50
51 /* Hash table */
52
53 static const struct CompactHashIndex JSTestInterfaceTableIndex[4] = {
54     { -1, -1 },
55     { 0, -1 },
56     { -1, -1 },
57     { 1, -1 },
58 };
59
60
61 static const HashTableValue JSTestInterfaceTableValues[] =
62 {
63 #if ENABLE(Condition22) || ENABLE(Condition23)
64     { "implementsStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr3) },
65 #else
66     { 0, 0, NoIntrinsic, 0, 0 },
67 #endif
68 #if ENABLE(Condition11) || ENABLE(Condition12)
69     { "supplementalStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr3) },
70 #else
71     { 0, 0, NoIntrinsic, 0, 0 },
72 #endif
73 };
74
75 static const HashTable JSTestInterfaceTable = { 2, 3, true, JSTestInterfaceTableValues, 0, JSTestInterfaceTableIndex };
76 /* Hash table for constructor */
77
78 static const struct CompactHashIndex JSTestInterfaceConstructorTableIndex[11] = {
79     { 8, -1 },
80     { 5, -1 },
81     { -1, -1 },
82     { 0, 9 },
83     { 6, 10 },
84     { 7, -1 },
85     { 2, -1 },
86     { 1, 8 },
87     { 3, -1 },
88     { 4, -1 },
89     { 9, -1 },
90 };
91
92
93 static const HashTableValue JSTestInterfaceConstructorTableValues[] =
94 {
95 #if ENABLE(Condition22) || ENABLE(Condition23)
96     { "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
97 #else
98     { 0, 0, NoIntrinsic, 0, 0 },
99 #endif
100 #if ENABLE(Condition22) || ENABLE(Condition23)
101     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
102 #else
103     { 0, 0, NoIntrinsic, 0, 0 },
104 #endif
105 #if ENABLE(Condition11) || ENABLE(Condition12)
106     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
107 #else
108     { 0, 0, NoIntrinsic, 0, 0 },
109 #endif
110 #if ENABLE(Condition11) || ENABLE(Condition12)
111     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
112 #else
113     { 0, 0, NoIntrinsic, 0, 0 },
114 #endif
115 #if ENABLE(Condition22) || ENABLE(Condition23)
116     { "implementsStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
117 #else
118     { 0, 0, NoIntrinsic, 0, 0 },
119 #endif
120 #if ENABLE(Condition22) || ENABLE(Condition23)
121     { "implementsStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceConstructorImplementsStaticAttr) },
122 #else
123     { 0, 0, NoIntrinsic, 0, 0 },
124 #endif
125 #if ENABLE(Condition11) || ENABLE(Condition12)
126     { "supplementalStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
127 #else
128     { 0, 0, NoIntrinsic, 0, 0 },
129 #endif
130 #if ENABLE(Condition11) || ENABLE(Condition12)
131     { "supplementalStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceConstructorSupplementalStaticAttr) },
132 #else
133     { 0, 0, NoIntrinsic, 0, 0 },
134 #endif
135 #if ENABLE(Condition22) || ENABLE(Condition23)
136     { "implementsMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionImplementsMethod4), (intptr_t) (0) },
137 #else
138     { 0, 0, NoIntrinsic, 0, 0 },
139 #endif
140 #if ENABLE(Condition11) || ENABLE(Condition12)
141     { "supplementalMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionSupplementalMethod4), (intptr_t) (0) },
142 #else
143     { 0, 0, NoIntrinsic, 0, 0 },
144 #endif
145 };
146
147 static const HashTable JSTestInterfaceConstructorTable = { 10, 7, true, JSTestInterfaceConstructorTableValues, 0, JSTestInterfaceConstructorTableIndex };
148
149 #if ENABLE(Condition22) || ENABLE(Condition23)
150 COMPILE_ASSERT(1 == TestInterface::IMPLEMENTSCONSTANT1, TestInterfaceEnumIMPLEMENTSCONSTANT1IsWrongUseDoNotCheckConstants);
151 #endif
152 #if ENABLE(Condition22) || ENABLE(Condition23)
153 COMPILE_ASSERT(2 == TestInterface::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
154 #endif
155 #if ENABLE(Condition11) || ENABLE(Condition12)
156 COMPILE_ASSERT(1 == TestSupplemental::SUPPLEMENTALCONSTANT1, TestInterfaceEnumSUPPLEMENTALCONSTANT1IsWrongUseDoNotCheckConstants);
157 #endif
158 #if ENABLE(Condition11) || ENABLE(Condition12)
159 COMPILE_ASSERT(2 == TestSupplemental::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
160 #endif
161
162 EncodedJSValue JSC_HOST_CALL JSTestInterfaceConstructor::constructJSTestInterface(ExecState* exec)
163 {
164     JSTestInterfaceConstructor* castedThis = jsCast<JSTestInterfaceConstructor*>(exec->callee());
165     if (exec->argumentCount() < 1)
166         return throwVMError(exec, createNotEnoughArgumentsError(exec));
167     ExceptionCode ec = 0;
168     const String& str1(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
169     if (UNLIKELY(exec->hadException()))
170         return JSValue::encode(jsUndefined());
171     const String& str2(exec->argument(1).isEmpty() ? String() : exec->argument(1).toString(exec)->value(exec));
172     if (UNLIKELY(exec->hadException()))
173         return JSValue::encode(jsUndefined());
174     ScriptExecutionContext* context = castedThis->scriptExecutionContext();
175     if (!context)
176         return throwVMError(exec, createReferenceError(exec, "TestInterface constructor associated document is unavailable"));
177     RefPtr<TestInterface> object = TestInterface::create(*context, str1, str2, ec);
178     if (ec) {
179         setDOMException(exec, ec);
180         return JSValue::encode(JSValue());
181     }
182     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
183 }
184
185 const ClassInfo JSTestInterfaceConstructor::s_info = { "TestInterfaceConstructor", &Base::s_info, &JSTestInterfaceConstructorTable, 0, CREATE_METHOD_TABLE(JSTestInterfaceConstructor) };
186
187 JSTestInterfaceConstructor::JSTestInterfaceConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
188     : DOMConstructorObject(structure, globalObject)
189 {
190 }
191
192 void JSTestInterfaceConstructor::finishCreation(VM& vm, JSDOMGlobalObject* globalObject)
193 {
194     Base::finishCreation(vm);
195     ASSERT(inherits(info()));
196     putDirect(vm, vm.propertyNames->prototype, JSTestInterfacePrototype::self(vm, globalObject), DontDelete | ReadOnly);
197     putDirect(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontDelete | DontEnum);
198 }
199
200 bool JSTestInterfaceConstructor::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
201 {
202     return getStaticPropertySlot<JSTestInterfaceConstructor, JSDOMWrapper>(exec, JSTestInterfaceConstructorTable, jsCast<JSTestInterfaceConstructor*>(object), propertyName, slot);
203 }
204
205 #if ENABLE(TEST_INTERFACE)
206 ConstructType JSTestInterfaceConstructor::getConstructData(JSCell*, ConstructData& constructData)
207 {
208     constructData.native.function = constructJSTestInterface;
209     return ConstructTypeHost;
210 }
211 #endif // ENABLE(TEST_INTERFACE)
212
213 /* Hash table for prototype */
214
215 static const struct CompactHashIndex JSTestInterfacePrototypeTableIndex[65] = {
216     { -1, -1 },
217     { 3, 64 },
218     { 14, -1 },
219     { -1, -1 },
220     { -1, -1 },
221     { -1, -1 },
222     { -1, -1 },
223     { -1, -1 },
224     { -1, -1 },
225     { -1, -1 },
226     { -1, -1 },
227     { 13, -1 },
228     { -1, -1 },
229     { -1, -1 },
230     { -1, -1 },
231     { 10, -1 },
232     { -1, -1 },
233     { 5, -1 },
234     { -1, -1 },
235     { -1, -1 },
236     { -1, -1 },
237     { -1, -1 },
238     { -1, -1 },
239     { 4, -1 },
240     { -1, -1 },
241     { 0, -1 },
242     { -1, -1 },
243     { 7, -1 },
244     { -1, -1 },
245     { -1, -1 },
246     { 15, -1 },
247     { 1, -1 },
248     { 6, -1 },
249     { -1, -1 },
250     { -1, -1 },
251     { -1, -1 },
252     { -1, -1 },
253     { -1, -1 },
254     { -1, -1 },
255     { -1, -1 },
256     { -1, -1 },
257     { -1, -1 },
258     { 11, -1 },
259     { -1, -1 },
260     { -1, -1 },
261     { -1, -1 },
262     { -1, -1 },
263     { 8, -1 },
264     { -1, -1 },
265     { -1, -1 },
266     { -1, -1 },
267     { -1, -1 },
268     { -1, -1 },
269     { -1, -1 },
270     { -1, -1 },
271     { -1, -1 },
272     { -1, -1 },
273     { 16, -1 },
274     { -1, -1 },
275     { -1, -1 },
276     { -1, -1 },
277     { 2, -1 },
278     { 9, -1 },
279     { -1, -1 },
280     { 12, -1 },
281 };
282
283
284 static const HashTableValue JSTestInterfacePrototypeTableValues[] =
285 {
286     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
287 #if ENABLE(Condition22) || ENABLE(Condition23)
288     { "implementsStr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
289 #else
290     { 0, 0, NoIntrinsic, 0, 0 },
291 #endif
292 #if ENABLE(Condition22) || ENABLE(Condition23)
293     { "implementsStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr2) },
294 #else
295     { 0, 0, NoIntrinsic, 0, 0 },
296 #endif
297 #if ENABLE(Condition22) || ENABLE(Condition23)
298     { "implementsNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsNode) },
299 #else
300     { 0, 0, NoIntrinsic, 0, 0 },
301 #endif
302 #if ENABLE(Condition11) || ENABLE(Condition12)
303     { "supplementalStr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
304 #else
305     { 0, 0, NoIntrinsic, 0, 0 },
306 #endif
307 #if ENABLE(Condition11) || ENABLE(Condition12)
308     { "supplementalStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr2) },
309 #else
310     { 0, 0, NoIntrinsic, 0, 0 },
311 #endif
312 #if ENABLE(Condition11) || ENABLE(Condition12)
313     { "supplementalNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalNode) },
314 #else
315     { 0, 0, NoIntrinsic, 0, 0 },
316 #endif
317 #if ENABLE(Condition22) || ENABLE(Condition23)
318     { "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
319 #else
320     { 0, 0, NoIntrinsic, 0, 0 },
321 #endif
322 #if ENABLE(Condition22) || ENABLE(Condition23)
323     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
324 #else
325     { 0, 0, NoIntrinsic, 0, 0 },
326 #endif
327 #if ENABLE(Condition11) || ENABLE(Condition12)
328     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
329 #else
330     { 0, 0, NoIntrinsic, 0, 0 },
331 #endif
332 #if ENABLE(Condition11) || ENABLE(Condition12)
333     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
334 #else
335     { 0, 0, NoIntrinsic, 0, 0 },
336 #endif
337 #if ENABLE(Condition22) || ENABLE(Condition23)
338     { "implementsMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod1), (intptr_t) (0) },
339 #else
340     { 0, 0, NoIntrinsic, 0, 0 },
341 #endif
342 #if ENABLE(Condition22) || ENABLE(Condition23)
343     { "implementsMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod2), (intptr_t) (2) },
344 #else
345     { 0, 0, NoIntrinsic, 0, 0 },
346 #endif
347 #if ENABLE(Condition22) || ENABLE(Condition23)
348     { "implementsMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod3), (intptr_t) (0) },
349 #else
350     { 0, 0, NoIntrinsic, 0, 0 },
351 #endif
352 #if ENABLE(Condition11) || ENABLE(Condition12)
353     { "supplementalMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod1), (intptr_t) (0) },
354 #else
355     { 0, 0, NoIntrinsic, 0, 0 },
356 #endif
357 #if ENABLE(Condition11) || ENABLE(Condition12)
358     { "supplementalMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod2), (intptr_t) (2) },
359 #else
360     { 0, 0, NoIntrinsic, 0, 0 },
361 #endif
362 #if ENABLE(Condition11) || ENABLE(Condition12)
363     { "supplementalMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod3), (intptr_t) (0) },
364 #else
365     { 0, 0, NoIntrinsic, 0, 0 },
366 #endif
367 };
368
369 static const HashTable JSTestInterfacePrototypeTable = { 17, 63, true, JSTestInterfacePrototypeTableValues, 0, JSTestInterfacePrototypeTableIndex };
370 const ClassInfo JSTestInterfacePrototype::s_info = { "TestInterfacePrototype", &Base::s_info, &JSTestInterfacePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestInterfacePrototype) };
371
372 JSObject* JSTestInterfacePrototype::self(VM& vm, JSGlobalObject* globalObject)
373 {
374     return getDOMPrototype<JSTestInterface>(vm, globalObject);
375 }
376
377 bool JSTestInterfacePrototype::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
378 {
379     JSTestInterfacePrototype* thisObject = jsCast<JSTestInterfacePrototype*>(object);
380     return getStaticPropertySlot<JSTestInterfacePrototype, JSObject>(exec, JSTestInterfacePrototypeTable, thisObject, propertyName, slot);
381 }
382
383 const ClassInfo JSTestInterface::s_info = { "TestInterface", &Base::s_info, &JSTestInterfaceTable, 0 , CREATE_METHOD_TABLE(JSTestInterface) };
384
385 JSTestInterface::JSTestInterface(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestInterface> impl)
386     : JSDOMWrapper(structure, globalObject)
387     , m_impl(impl.leakRef())
388 {
389 }
390
391 JSObject* JSTestInterface::createPrototype(VM& vm, JSGlobalObject* globalObject)
392 {
393     return JSTestInterfacePrototype::create(vm, globalObject, JSTestInterfacePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
394 }
395
396 void JSTestInterface::destroy(JSC::JSCell* cell)
397 {
398     JSTestInterface* thisObject = static_cast<JSTestInterface*>(cell);
399     thisObject->JSTestInterface::~JSTestInterface();
400 }
401
402 JSTestInterface::~JSTestInterface()
403 {
404     releaseImplIfNotNull();
405 }
406
407 bool JSTestInterface::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
408 {
409     JSTestInterface* thisObject = jsCast<JSTestInterface*>(object);
410     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
411     return getStaticValueSlot<JSTestInterface, Base>(exec, JSTestInterfaceTable, thisObject, propertyName, slot);
412 }
413
414 #if ENABLE(Condition22) || ENABLE(Condition23)
415 EncodedJSValue jsTestInterfaceConstructorImplementsStaticReadOnlyAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
416 {
417     UNUSED_PARAM(thisValue);
418     UNUSED_PARAM(slotBase);
419     UNUSED_PARAM(exec);
420     JSValue result = jsNumber(TestInterface::implementsStaticReadOnlyAttr());
421     return JSValue::encode(result);
422 }
423
424 #endif
425
426 #if ENABLE(Condition22) || ENABLE(Condition23)
427 EncodedJSValue jsTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
428 {
429     UNUSED_PARAM(thisValue);
430     UNUSED_PARAM(slotBase);
431     UNUSED_PARAM(exec);
432     JSValue result = jsStringWithCache(exec, TestInterface::implementsStaticAttr());
433     return JSValue::encode(result);
434 }
435
436 #endif
437
438 #if ENABLE(Condition22) || ENABLE(Condition23)
439 EncodedJSValue jsTestInterfaceImplementsStr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
440 {
441     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
442     UNUSED_PARAM(slotBase);
443     if (UNLIKELY(!castedThis)) {
444         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
445             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
446             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'implementsStr1' on a non-TestInterface object."));
447             return JSValue::encode(jsUndefined());
448         }
449         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsStr1", " getter can only be used on instances of ", "TestInterface"));
450     }
451     UNUSED_PARAM(exec);
452     TestInterface& impl = castedThis->impl();
453     JSValue result = jsStringWithCache(exec, impl.implementsStr1());
454     return JSValue::encode(result);
455 }
456
457 #endif
458
459 #if ENABLE(Condition22) || ENABLE(Condition23)
460 EncodedJSValue jsTestInterfaceImplementsStr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
461 {
462     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
463     UNUSED_PARAM(slotBase);
464     if (UNLIKELY(!castedThis)) {
465         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
466             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
467             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'implementsStr2' on a non-TestInterface object."));
468             return JSValue::encode(jsUndefined());
469         }
470         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsStr2", " getter can only be used on instances of ", "TestInterface"));
471     }
472     UNUSED_PARAM(exec);
473     TestInterface& impl = castedThis->impl();
474     JSValue result = jsStringWithCache(exec, impl.implementsStr2());
475     return JSValue::encode(result);
476 }
477
478 #endif
479
480 #if ENABLE(Condition22) || ENABLE(Condition23)
481 EncodedJSValue jsTestInterfaceImplementsStr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
482 {
483     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
484     UNUSED_PARAM(slotBase);
485     if (UNLIKELY(!castedThis)) {
486         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
487             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
488             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'implementsStr3' on a non-TestInterface object."));
489             return JSValue::encode(jsUndefined());
490         }
491         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsStr3", " getter can only be used on instances of ", "TestInterface"));
492     }
493     return JSValue::encode(castedThis->implementsStr3(exec));
494 }
495
496 #endif
497
498 #if ENABLE(Condition22) || ENABLE(Condition23)
499 EncodedJSValue jsTestInterfaceImplementsNode(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
500 {
501     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
502     UNUSED_PARAM(slotBase);
503     if (UNLIKELY(!castedThis)) {
504         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
505             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
506             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'implementsNode' on a non-TestInterface object."));
507             return JSValue::encode(jsUndefined());
508         }
509         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsNode", " getter can only be used on instances of ", "TestInterface"));
510     }
511     UNUSED_PARAM(exec);
512     TestInterface& impl = castedThis->impl();
513     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsNode()));
514     return JSValue::encode(result);
515 }
516
517 #endif
518
519 #if ENABLE(Condition11) || ENABLE(Condition12)
520 EncodedJSValue jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
521 {
522     UNUSED_PARAM(thisValue);
523     UNUSED_PARAM(slotBase);
524     UNUSED_PARAM(exec);
525     JSValue result = jsNumber(TestSupplemental::supplementalStaticReadOnlyAttr());
526     return JSValue::encode(result);
527 }
528
529 #endif
530
531 #if ENABLE(Condition11) || ENABLE(Condition12)
532 EncodedJSValue jsTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
533 {
534     UNUSED_PARAM(thisValue);
535     UNUSED_PARAM(slotBase);
536     UNUSED_PARAM(exec);
537     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStaticAttr());
538     return JSValue::encode(result);
539 }
540
541 #endif
542
543 #if ENABLE(Condition11) || ENABLE(Condition12)
544 EncodedJSValue jsTestInterfaceSupplementalStr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
545 {
546     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
547     UNUSED_PARAM(slotBase);
548     if (UNLIKELY(!castedThis)) {
549         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
550             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
551             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'supplementalStr1' on a non-TestInterface object."));
552             return JSValue::encode(jsUndefined());
553         }
554         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalStr1", " getter can only be used on instances of ", "TestInterface"));
555     }
556     UNUSED_PARAM(exec);
557     TestInterface& impl = castedThis->impl();
558     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr1(&impl));
559     return JSValue::encode(result);
560 }
561
562 #endif
563
564 #if ENABLE(Condition11) || ENABLE(Condition12)
565 EncodedJSValue jsTestInterfaceSupplementalStr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
566 {
567     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
568     UNUSED_PARAM(slotBase);
569     if (UNLIKELY(!castedThis)) {
570         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
571             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
572             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'supplementalStr2' on a non-TestInterface object."));
573             return JSValue::encode(jsUndefined());
574         }
575         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalStr2", " getter can only be used on instances of ", "TestInterface"));
576     }
577     UNUSED_PARAM(exec);
578     TestInterface& impl = castedThis->impl();
579     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr2(&impl));
580     return JSValue::encode(result);
581 }
582
583 #endif
584
585 #if ENABLE(Condition11) || ENABLE(Condition12)
586 EncodedJSValue jsTestInterfaceSupplementalStr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
587 {
588     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
589     UNUSED_PARAM(slotBase);
590     if (UNLIKELY(!castedThis)) {
591         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
592             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
593             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'supplementalStr3' on a non-TestInterface object."));
594             return JSValue::encode(jsUndefined());
595         }
596         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalStr3", " getter can only be used on instances of ", "TestInterface"));
597     }
598     return JSValue::encode(castedThis->supplementalStr3(exec));
599 }
600
601 #endif
602
603 #if ENABLE(Condition11) || ENABLE(Condition12)
604 EncodedJSValue jsTestInterfaceSupplementalNode(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
605 {
606     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
607     UNUSED_PARAM(slotBase);
608     if (UNLIKELY(!castedThis)) {
609         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
610             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
611             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'supplementalNode' on a non-TestInterface object."));
612             return JSValue::encode(jsUndefined());
613         }
614         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalNode", " getter can only be used on instances of ", "TestInterface"));
615     }
616     UNUSED_PARAM(exec);
617     TestInterface& impl = castedThis->impl();
618     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalNode(&impl)));
619     return JSValue::encode(result);
620 }
621
622 #endif
623
624 EncodedJSValue jsTestInterfaceConstructor(ExecState* exec, JSObject* baseValue, EncodedJSValue thisValue, PropertyName)
625 {
626     UNUSED_PARAM(baseValue);
627     UNUSED_PARAM(thisValue);
628     JSTestInterfacePrototype* domObject = jsDynamicCast<JSTestInterfacePrototype*>(baseValue);
629     if (!domObject)
630         return throwVMTypeError(exec);
631     return JSValue::encode(JSTestInterface::getConstructor(exec->vm(), domObject->globalObject()));
632 }
633
634 void JSTestInterface::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
635 {
636     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
637     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
638     if (thisObject->putDelegate(exec, propertyName, value, slot))
639         return;
640     Base::put(thisObject, exec, propertyName, value, slot);
641 }
642
643 void JSTestInterface::putByIndex(JSCell* cell, ExecState* exec, unsigned index, JSValue value, bool shouldThrow)
644 {
645     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
646     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
647     PropertyName propertyName = Identifier::from(exec, index);
648     PutPropertySlot slot(thisObject, shouldThrow);
649     if (thisObject->putDelegate(exec, propertyName, value, slot))
650         return;
651     Base::putByIndex(cell, exec, index, value, shouldThrow);
652 }
653
654 #if ENABLE(Condition22) || ENABLE(Condition23)
655 void setJSTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue, EncodedJSValue encodedValue)
656 {
657     JSValue value = JSValue::decode(encodedValue);
658     UNUSED_PARAM(exec);
659     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
660     if (UNLIKELY(exec->hadException()))
661         return;
662     TestInterface::setImplementsStaticAttr(nativeValue);
663 }
664
665 #endif
666
667 #if ENABLE(Condition22) || ENABLE(Condition23)
668 void setJSTestInterfaceImplementsStr2(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
669 {
670     JSValue value = JSValue::decode(encodedValue);
671     UNUSED_PARAM(exec);
672     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
673     if (UNLIKELY(!castedThis)) {
674         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsStr2", " setter can only be used on instances of ", "TestInterface"));
675         return;
676     }
677     TestInterface& impl = castedThis->impl();
678     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
679     if (UNLIKELY(exec->hadException()))
680         return;
681     impl.setImplementsStr2(nativeValue);
682 }
683
684 #endif
685
686 #if ENABLE(Condition22) || ENABLE(Condition23)
687 void setJSTestInterfaceImplementsStr3(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
688 {
689     JSValue value = JSValue::decode(encodedValue);
690     UNUSED_PARAM(exec);
691     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
692     if (UNLIKELY(!castedThis)) {
693         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsStr3", " setter can only be used on instances of ", "TestInterface"));
694         return;
695     }
696     castedThis->setImplementsStr3(exec, value);
697 }
698
699 #endif
700
701 #if ENABLE(Condition22) || ENABLE(Condition23)
702 void setJSTestInterfaceImplementsNode(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
703 {
704     JSValue value = JSValue::decode(encodedValue);
705     UNUSED_PARAM(exec);
706     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
707     if (UNLIKELY(!castedThis)) {
708         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsNode", " setter can only be used on instances of ", "TestInterface"));
709         return;
710     }
711     TestInterface& impl = castedThis->impl();
712     Node* nativeValue(toNode(value));
713     if (UNLIKELY(exec->hadException()))
714         return;
715     impl.setImplementsNode(nativeValue);
716 }
717
718 #endif
719
720 #if ENABLE(Condition11) || ENABLE(Condition12)
721 void setJSTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue, EncodedJSValue encodedValue)
722 {
723     JSValue value = JSValue::decode(encodedValue);
724     UNUSED_PARAM(exec);
725     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
726     if (UNLIKELY(exec->hadException()))
727         return;
728     TestSupplemental::setSupplementalStaticAttr(nativeValue);
729 }
730
731 #endif
732
733 #if ENABLE(Condition11) || ENABLE(Condition12)
734 void setJSTestInterfaceSupplementalStr2(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
735 {
736     JSValue value = JSValue::decode(encodedValue);
737     UNUSED_PARAM(exec);
738     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
739     if (UNLIKELY(!castedThis)) {
740         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalStr2", " setter can only be used on instances of ", "TestInterface"));
741         return;
742     }
743     TestInterface& impl = castedThis->impl();
744     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
745     if (UNLIKELY(exec->hadException()))
746         return;
747     TestSupplemental::setSupplementalStr2(&impl, nativeValue);
748 }
749
750 #endif
751
752 #if ENABLE(Condition11) || ENABLE(Condition12)
753 void setJSTestInterfaceSupplementalStr3(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
754 {
755     JSValue value = JSValue::decode(encodedValue);
756     UNUSED_PARAM(exec);
757     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
758     if (UNLIKELY(!castedThis)) {
759         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalStr3", " setter can only be used on instances of ", "TestInterface"));
760         return;
761     }
762     castedThis->setSupplementalStr3(exec, value);
763 }
764
765 #endif
766
767 #if ENABLE(Condition11) || ENABLE(Condition12)
768 void setJSTestInterfaceSupplementalNode(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
769 {
770     JSValue value = JSValue::decode(encodedValue);
771     UNUSED_PARAM(exec);
772     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
773     if (UNLIKELY(!castedThis)) {
774         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalNode", " setter can only be used on instances of ", "TestInterface"));
775         return;
776     }
777     TestInterface& impl = castedThis->impl();
778     Node* nativeValue(toNode(value));
779     if (UNLIKELY(exec->hadException()))
780         return;
781     TestSupplemental::setSupplementalNode(&impl, nativeValue);
782 }
783
784 #endif
785
786 JSValue JSTestInterface::getConstructor(VM& vm, JSGlobalObject* globalObject)
787 {
788     return getDOMConstructor<JSTestInterfaceConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
789 }
790
791 #if ENABLE(Condition22) || ENABLE(Condition23)
792 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod1(ExecState* exec)
793 {
794     JSValue thisValue = exec->thisValue();
795     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
796     if (UNLIKELY(!castedThis))
797         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "implementsMethod1", " on instances of ", "TestInterface"));
798     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
799     TestInterface& impl = castedThis->impl();
800     impl.implementsMethod1();
801     return JSValue::encode(jsUndefined());
802 }
803
804 #endif
805
806 #if ENABLE(Condition22) || ENABLE(Condition23)
807 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod2(ExecState* exec)
808 {
809     JSValue thisValue = exec->thisValue();
810     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
811     if (UNLIKELY(!castedThis))
812         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "implementsMethod2", " on instances of ", "TestInterface"));
813     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
814     TestInterface& impl = castedThis->impl();
815     if (exec->argumentCount() < 2)
816         return throwVMError(exec, createNotEnoughArgumentsError(exec));
817     ExceptionCode ec = 0;
818     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
819     if (!scriptContext)
820         return JSValue::encode(jsUndefined());
821     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
822     if (UNLIKELY(exec->hadException()))
823         return JSValue::encode(jsUndefined());
824     TestObj* objArg(toTestObj(exec->argument(1)));
825     if (UNLIKELY(exec->hadException()))
826         return JSValue::encode(jsUndefined());
827     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsMethod2(scriptContext, strArg, objArg, ec)));
828
829     setDOMException(exec, ec);
830     return JSValue::encode(result);
831 }
832
833 #endif
834
835 #if ENABLE(Condition22) || ENABLE(Condition23)
836 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod3(ExecState* exec)
837 {
838     JSValue thisValue = exec->thisValue();
839     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
840     if (UNLIKELY(!castedThis))
841         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "implementsMethod3", " on instances of ", "TestInterface"));
842     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
843     return JSValue::encode(castedThis->implementsMethod3(exec));
844 }
845
846 #endif
847
848 #if ENABLE(Condition22) || ENABLE(Condition23)
849 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionImplementsMethod4(ExecState* exec)
850 {
851     TestInterface::implementsMethod4();
852     return JSValue::encode(jsUndefined());
853 }
854
855 #endif
856
857 #if ENABLE(Condition11) || ENABLE(Condition12)
858 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod1(ExecState* exec)
859 {
860     JSValue thisValue = exec->thisValue();
861     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
862     if (UNLIKELY(!castedThis))
863         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "supplementalMethod1", " on instances of ", "TestInterface"));
864     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
865     TestInterface& impl = castedThis->impl();
866     TestSupplemental::supplementalMethod1(&impl);
867     return JSValue::encode(jsUndefined());
868 }
869
870 #endif
871
872 #if ENABLE(Condition11) || ENABLE(Condition12)
873 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod2(ExecState* exec)
874 {
875     JSValue thisValue = exec->thisValue();
876     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
877     if (UNLIKELY(!castedThis))
878         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "supplementalMethod2", " on instances of ", "TestInterface"));
879     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
880     TestInterface& impl = castedThis->impl();
881     if (exec->argumentCount() < 2)
882         return throwVMError(exec, createNotEnoughArgumentsError(exec));
883     ExceptionCode ec = 0;
884     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
885     if (!scriptContext)
886         return JSValue::encode(jsUndefined());
887     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
888     if (UNLIKELY(exec->hadException()))
889         return JSValue::encode(jsUndefined());
890     TestObj* objArg(toTestObj(exec->argument(1)));
891     if (UNLIKELY(exec->hadException()))
892         return JSValue::encode(jsUndefined());
893     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalMethod2(&impl, scriptContext, strArg, objArg, ec)));
894
895     setDOMException(exec, ec);
896     return JSValue::encode(result);
897 }
898
899 #endif
900
901 #if ENABLE(Condition11) || ENABLE(Condition12)
902 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod3(ExecState* exec)
903 {
904     JSValue thisValue = exec->thisValue();
905     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
906     if (UNLIKELY(!castedThis))
907         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "supplementalMethod3", " on instances of ", "TestInterface"));
908     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
909     return JSValue::encode(castedThis->supplementalMethod3(exec));
910 }
911
912 #endif
913
914 #if ENABLE(Condition11) || ENABLE(Condition12)
915 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionSupplementalMethod4(ExecState* exec)
916 {
917     TestSupplemental::supplementalMethod4();
918     return JSValue::encode(jsUndefined());
919 }
920
921 #endif
922
923 // Constant getters
924
925 #if ENABLE(Condition22) || ENABLE(Condition23)
926 EncodedJSValue jsTestInterfaceIMPLEMENTSCONSTANT1(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
927 {
928     UNUSED_PARAM(exec);
929     return JSValue::encode(jsNumber(1));
930 }
931
932 #endif
933 #if ENABLE(Condition22) || ENABLE(Condition23)
934 EncodedJSValue jsTestInterfaceIMPLEMENTSCONSTANT2(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
935 {
936     UNUSED_PARAM(exec);
937     return JSValue::encode(jsNumber(2));
938 }
939
940 #endif
941 #if ENABLE(Condition11) || ENABLE(Condition12)
942 EncodedJSValue jsTestInterfaceSUPPLEMENTALCONSTANT1(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
943 {
944     UNUSED_PARAM(exec);
945     return JSValue::encode(jsNumber(1));
946 }
947
948 #endif
949 #if ENABLE(Condition11) || ENABLE(Condition12)
950 EncodedJSValue jsTestInterfaceSUPPLEMENTALCONSTANT2(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
951 {
952     UNUSED_PARAM(exec);
953     return JSValue::encode(jsNumber(2));
954 }
955
956 #endif
957 bool JSTestInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
958 {
959     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.slot()->asCell());
960     if (jsTestInterface->impl().hasPendingActivity())
961         return true;
962     UNUSED_PARAM(visitor);
963     return false;
964 }
965
966 void JSTestInterfaceOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
967 {
968     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.slot()->asCell());
969     DOMWrapperWorld& world = *static_cast<DOMWrapperWorld*>(context);
970     uncacheWrapper(world, &jsTestInterface->impl(), jsTestInterface);
971     jsTestInterface->releaseImpl();
972 }
973
974 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestInterface* impl)
975 {
976     if (!impl)
977         return jsNull();
978     if (JSValue result = getExistingWrapper<JSTestInterface>(globalObject, impl))
979         return result;
980 #if COMPILER(CLANG)
981     // If you hit this failure the interface definition has the ImplementationLacksVTable
982     // attribute. You should remove that attribute. If the class has subclasses
983     // that may be passed through this toJS() function you should use the SkipVTableValidation
984     // attribute to TestInterface.
985     COMPILE_ASSERT(!__is_polymorphic(TestInterface), TestInterface_is_polymorphic_but_idl_claims_not_to_be);
986 #endif
987     return createNewWrapper<JSTestInterface>(globalObject, impl);
988 }
989
990 TestInterface* toTestInterface(JSC::JSValue value)
991 {
992     if (auto* wrapper = jsDynamicCast<JSTestInterface*>(value))
993         return &wrapper->impl();
994     return nullptr;
995 }
996
997 }
998
999 #endif // ENABLE(Condition1) || ENABLE(Condition2)