6da947d0ad226ce750e45b907f4ea14d211c5c60
[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 void JSTestInterface::finishCreation(VM& vm)
392 {
393     Base::finishCreation(vm);
394     ASSERT(inherits(info()));
395 }
396
397 JSObject* JSTestInterface::createPrototype(VM& vm, JSGlobalObject* globalObject)
398 {
399     return JSTestInterfacePrototype::create(vm, globalObject, JSTestInterfacePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
400 }
401
402 void JSTestInterface::destroy(JSC::JSCell* cell)
403 {
404     JSTestInterface* thisObject = static_cast<JSTestInterface*>(cell);
405     thisObject->JSTestInterface::~JSTestInterface();
406 }
407
408 JSTestInterface::~JSTestInterface()
409 {
410     releaseImplIfNotNull();
411 }
412
413 bool JSTestInterface::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
414 {
415     JSTestInterface* thisObject = jsCast<JSTestInterface*>(object);
416     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
417     return getStaticValueSlot<JSTestInterface, Base>(exec, JSTestInterfaceTable, thisObject, propertyName, slot);
418 }
419
420 #if ENABLE(Condition22) || ENABLE(Condition23)
421 EncodedJSValue jsTestInterfaceConstructorImplementsStaticReadOnlyAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
422 {
423     UNUSED_PARAM(thisValue);
424     UNUSED_PARAM(slotBase);
425     UNUSED_PARAM(exec);
426     JSValue result = jsNumber(TestInterface::implementsStaticReadOnlyAttr());
427     return JSValue::encode(result);
428 }
429
430 #endif
431
432 #if ENABLE(Condition22) || ENABLE(Condition23)
433 EncodedJSValue jsTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
434 {
435     UNUSED_PARAM(thisValue);
436     UNUSED_PARAM(slotBase);
437     UNUSED_PARAM(exec);
438     JSValue result = jsStringWithCache(exec, TestInterface::implementsStaticAttr());
439     return JSValue::encode(result);
440 }
441
442 #endif
443
444 #if ENABLE(Condition22) || ENABLE(Condition23)
445 EncodedJSValue jsTestInterfaceImplementsStr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
446 {
447     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
448     UNUSED_PARAM(slotBase);
449     if (UNLIKELY(!castedThis)) {
450         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
451             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
452             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'implementsStr1' on a non-TestInterface object."));
453             return JSValue::encode(jsUndefined());
454         }
455         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsStr1", " getter can only be used on instances of ", "TestInterface"));
456     }
457     UNUSED_PARAM(exec);
458     TestInterface& impl = castedThis->impl();
459     JSValue result = jsStringWithCache(exec, impl.implementsStr1());
460     return JSValue::encode(result);
461 }
462
463 #endif
464
465 #if ENABLE(Condition22) || ENABLE(Condition23)
466 EncodedJSValue jsTestInterfaceImplementsStr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
467 {
468     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
469     UNUSED_PARAM(slotBase);
470     if (UNLIKELY(!castedThis)) {
471         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
472             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
473             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'implementsStr2' on a non-TestInterface object."));
474             return JSValue::encode(jsUndefined());
475         }
476         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsStr2", " getter can only be used on instances of ", "TestInterface"));
477     }
478     UNUSED_PARAM(exec);
479     TestInterface& impl = castedThis->impl();
480     JSValue result = jsStringWithCache(exec, impl.implementsStr2());
481     return JSValue::encode(result);
482 }
483
484 #endif
485
486 #if ENABLE(Condition22) || ENABLE(Condition23)
487 EncodedJSValue jsTestInterfaceImplementsStr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
488 {
489     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
490     UNUSED_PARAM(slotBase);
491     if (UNLIKELY(!castedThis)) {
492         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
493             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
494             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'implementsStr3' on a non-TestInterface object."));
495             return JSValue::encode(jsUndefined());
496         }
497         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsStr3", " getter can only be used on instances of ", "TestInterface"));
498     }
499     return JSValue::encode(castedThis->implementsStr3(exec));
500 }
501
502 #endif
503
504 #if ENABLE(Condition22) || ENABLE(Condition23)
505 EncodedJSValue jsTestInterfaceImplementsNode(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
506 {
507     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
508     UNUSED_PARAM(slotBase);
509     if (UNLIKELY(!castedThis)) {
510         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
511             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
512             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'implementsNode' on a non-TestInterface object."));
513             return JSValue::encode(jsUndefined());
514         }
515         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsNode", " getter can only be used on instances of ", "TestInterface"));
516     }
517     UNUSED_PARAM(exec);
518     TestInterface& impl = castedThis->impl();
519     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsNode()));
520     return JSValue::encode(result);
521 }
522
523 #endif
524
525 #if ENABLE(Condition11) || ENABLE(Condition12)
526 EncodedJSValue jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
527 {
528     UNUSED_PARAM(thisValue);
529     UNUSED_PARAM(slotBase);
530     UNUSED_PARAM(exec);
531     JSValue result = jsNumber(TestSupplemental::supplementalStaticReadOnlyAttr());
532     return JSValue::encode(result);
533 }
534
535 #endif
536
537 #if ENABLE(Condition11) || ENABLE(Condition12)
538 EncodedJSValue jsTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
539 {
540     UNUSED_PARAM(thisValue);
541     UNUSED_PARAM(slotBase);
542     UNUSED_PARAM(exec);
543     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStaticAttr());
544     return JSValue::encode(result);
545 }
546
547 #endif
548
549 #if ENABLE(Condition11) || ENABLE(Condition12)
550 EncodedJSValue jsTestInterfaceSupplementalStr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
551 {
552     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
553     UNUSED_PARAM(slotBase);
554     if (UNLIKELY(!castedThis)) {
555         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
556             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
557             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'supplementalStr1' on a non-TestInterface object."));
558             return JSValue::encode(jsUndefined());
559         }
560         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalStr1", " getter can only be used on instances of ", "TestInterface"));
561     }
562     UNUSED_PARAM(exec);
563     TestInterface& impl = castedThis->impl();
564     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr1(&impl));
565     return JSValue::encode(result);
566 }
567
568 #endif
569
570 #if ENABLE(Condition11) || ENABLE(Condition12)
571 EncodedJSValue jsTestInterfaceSupplementalStr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
572 {
573     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
574     UNUSED_PARAM(slotBase);
575     if (UNLIKELY(!castedThis)) {
576         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
577             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
578             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'supplementalStr2' on a non-TestInterface object."));
579             return JSValue::encode(jsUndefined());
580         }
581         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalStr2", " getter can only be used on instances of ", "TestInterface"));
582     }
583     UNUSED_PARAM(exec);
584     TestInterface& impl = castedThis->impl();
585     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr2(&impl));
586     return JSValue::encode(result);
587 }
588
589 #endif
590
591 #if ENABLE(Condition11) || ENABLE(Condition12)
592 EncodedJSValue jsTestInterfaceSupplementalStr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
593 {
594     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
595     UNUSED_PARAM(slotBase);
596     if (UNLIKELY(!castedThis)) {
597         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
598             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
599             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'supplementalStr3' on a non-TestInterface object."));
600             return JSValue::encode(jsUndefined());
601         }
602         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalStr3", " getter can only be used on instances of ", "TestInterface"));
603     }
604     return JSValue::encode(castedThis->supplementalStr3(exec));
605 }
606
607 #endif
608
609 #if ENABLE(Condition11) || ENABLE(Condition12)
610 EncodedJSValue jsTestInterfaceSupplementalNode(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
611 {
612     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
613     UNUSED_PARAM(slotBase);
614     if (UNLIKELY(!castedThis)) {
615         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase)) {
616             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
617             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'supplementalNode' on a non-TestInterface object."));
618             return JSValue::encode(jsUndefined());
619         }
620         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalNode", " getter can only be used on instances of ", "TestInterface"));
621     }
622     UNUSED_PARAM(exec);
623     TestInterface& impl = castedThis->impl();
624     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalNode(&impl)));
625     return JSValue::encode(result);
626 }
627
628 #endif
629
630 EncodedJSValue jsTestInterfaceConstructor(ExecState* exec, JSObject* baseValue, EncodedJSValue thisValue, PropertyName)
631 {
632     UNUSED_PARAM(baseValue);
633     UNUSED_PARAM(thisValue);
634     JSTestInterfacePrototype* domObject = jsDynamicCast<JSTestInterfacePrototype*>(baseValue);
635     if (!domObject)
636         return throwVMTypeError(exec);
637     return JSValue::encode(JSTestInterface::getConstructor(exec->vm(), domObject->globalObject()));
638 }
639
640 void JSTestInterface::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
641 {
642     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
643     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
644     if (thisObject->putDelegate(exec, propertyName, value, slot))
645         return;
646     Base::put(thisObject, exec, propertyName, value, slot);
647 }
648
649 void JSTestInterface::putByIndex(JSCell* cell, ExecState* exec, unsigned index, JSValue value, bool shouldThrow)
650 {
651     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
652     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
653     PropertyName propertyName = Identifier::from(exec, index);
654     PutPropertySlot slot(thisObject, shouldThrow);
655     if (thisObject->putDelegate(exec, propertyName, value, slot))
656         return;
657     Base::putByIndex(cell, exec, index, value, shouldThrow);
658 }
659
660 #if ENABLE(Condition22) || ENABLE(Condition23)
661 void setJSTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue, EncodedJSValue encodedValue)
662 {
663     JSValue value = JSValue::decode(encodedValue);
664     UNUSED_PARAM(exec);
665     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
666     if (UNLIKELY(exec->hadException()))
667         return;
668     TestInterface::setImplementsStaticAttr(nativeValue);
669 }
670
671 #endif
672
673 #if ENABLE(Condition22) || ENABLE(Condition23)
674 void setJSTestInterfaceImplementsStr2(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
675 {
676     JSValue value = JSValue::decode(encodedValue);
677     UNUSED_PARAM(exec);
678     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
679     if (UNLIKELY(!castedThis)) {
680         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsStr2", " setter can only be used on instances of ", "TestInterface"));
681         return;
682     }
683     TestInterface& impl = castedThis->impl();
684     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
685     if (UNLIKELY(exec->hadException()))
686         return;
687     impl.setImplementsStr2(nativeValue);
688 }
689
690 #endif
691
692 #if ENABLE(Condition22) || ENABLE(Condition23)
693 void setJSTestInterfaceImplementsStr3(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
694 {
695     JSValue value = JSValue::decode(encodedValue);
696     UNUSED_PARAM(exec);
697     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
698     if (UNLIKELY(!castedThis)) {
699         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsStr3", " setter can only be used on instances of ", "TestInterface"));
700         return;
701     }
702     castedThis->setImplementsStr3(exec, value);
703 }
704
705 #endif
706
707 #if ENABLE(Condition22) || ENABLE(Condition23)
708 void setJSTestInterfaceImplementsNode(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
709 {
710     JSValue value = JSValue::decode(encodedValue);
711     UNUSED_PARAM(exec);
712     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
713     if (UNLIKELY(!castedThis)) {
714         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "implementsNode", " setter can only be used on instances of ", "TestInterface"));
715         return;
716     }
717     TestInterface& impl = castedThis->impl();
718     Node* nativeValue(toNode(value));
719     if (UNLIKELY(exec->hadException()))
720         return;
721     impl.setImplementsNode(nativeValue);
722 }
723
724 #endif
725
726 #if ENABLE(Condition11) || ENABLE(Condition12)
727 void setJSTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue, EncodedJSValue encodedValue)
728 {
729     JSValue value = JSValue::decode(encodedValue);
730     UNUSED_PARAM(exec);
731     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
732     if (UNLIKELY(exec->hadException()))
733         return;
734     TestSupplemental::setSupplementalStaticAttr(nativeValue);
735 }
736
737 #endif
738
739 #if ENABLE(Condition11) || ENABLE(Condition12)
740 void setJSTestInterfaceSupplementalStr2(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
741 {
742     JSValue value = JSValue::decode(encodedValue);
743     UNUSED_PARAM(exec);
744     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
745     if (UNLIKELY(!castedThis)) {
746         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalStr2", " setter can only be used on instances of ", "TestInterface"));
747         return;
748     }
749     TestInterface& impl = castedThis->impl();
750     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
751     if (UNLIKELY(exec->hadException()))
752         return;
753     TestSupplemental::setSupplementalStr2(&impl, nativeValue);
754 }
755
756 #endif
757
758 #if ENABLE(Condition11) || ENABLE(Condition12)
759 void setJSTestInterfaceSupplementalStr3(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
760 {
761     JSValue value = JSValue::decode(encodedValue);
762     UNUSED_PARAM(exec);
763     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
764     if (UNLIKELY(!castedThis)) {
765         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalStr3", " setter can only be used on instances of ", "TestInterface"));
766         return;
767     }
768     castedThis->setSupplementalStr3(exec, value);
769 }
770
771 #endif
772
773 #if ENABLE(Condition11) || ENABLE(Condition12)
774 void setJSTestInterfaceSupplementalNode(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
775 {
776     JSValue value = JSValue::decode(encodedValue);
777     UNUSED_PARAM(exec);
778     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
779     if (UNLIKELY(!castedThis)) {
780         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestInterface", ".", "supplementalNode", " setter can only be used on instances of ", "TestInterface"));
781         return;
782     }
783     TestInterface& impl = castedThis->impl();
784     Node* nativeValue(toNode(value));
785     if (UNLIKELY(exec->hadException()))
786         return;
787     TestSupplemental::setSupplementalNode(&impl, nativeValue);
788 }
789
790 #endif
791
792 JSValue JSTestInterface::getConstructor(VM& vm, JSGlobalObject* globalObject)
793 {
794     return getDOMConstructor<JSTestInterfaceConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
795 }
796
797 #if ENABLE(Condition22) || ENABLE(Condition23)
798 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod1(ExecState* exec)
799 {
800     JSValue thisValue = exec->hostThisValue();
801     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
802     if (UNLIKELY(!castedThis))
803         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "implementsMethod1", " on instances of ", "TestInterface"));
804     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
805     TestInterface& impl = castedThis->impl();
806     impl.implementsMethod1();
807     return JSValue::encode(jsUndefined());
808 }
809
810 #endif
811
812 #if ENABLE(Condition22) || ENABLE(Condition23)
813 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod2(ExecState* exec)
814 {
815     JSValue thisValue = exec->hostThisValue();
816     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
817     if (UNLIKELY(!castedThis))
818         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "implementsMethod2", " on instances of ", "TestInterface"));
819     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
820     TestInterface& impl = castedThis->impl();
821     if (exec->argumentCount() < 2)
822         return throwVMError(exec, createNotEnoughArgumentsError(exec));
823     ExceptionCode ec = 0;
824     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
825     if (!scriptContext)
826         return JSValue::encode(jsUndefined());
827     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
828     if (UNLIKELY(exec->hadException()))
829         return JSValue::encode(jsUndefined());
830     TestObj* objArg(toTestObj(exec->argument(1)));
831     if (UNLIKELY(exec->hadException()))
832         return JSValue::encode(jsUndefined());
833     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsMethod2(scriptContext, strArg, objArg, ec)));
834
835     setDOMException(exec, ec);
836     return JSValue::encode(result);
837 }
838
839 #endif
840
841 #if ENABLE(Condition22) || ENABLE(Condition23)
842 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod3(ExecState* exec)
843 {
844     JSValue thisValue = exec->hostThisValue();
845     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
846     if (UNLIKELY(!castedThis))
847         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "implementsMethod3", " on instances of ", "TestInterface"));
848     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
849     return JSValue::encode(castedThis->implementsMethod3(exec));
850 }
851
852 #endif
853
854 #if ENABLE(Condition22) || ENABLE(Condition23)
855 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionImplementsMethod4(ExecState* exec)
856 {
857     TestInterface::implementsMethod4();
858     return JSValue::encode(jsUndefined());
859 }
860
861 #endif
862
863 #if ENABLE(Condition11) || ENABLE(Condition12)
864 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod1(ExecState* exec)
865 {
866     JSValue thisValue = exec->hostThisValue();
867     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
868     if (UNLIKELY(!castedThis))
869         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "supplementalMethod1", " on instances of ", "TestInterface"));
870     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
871     TestInterface& impl = castedThis->impl();
872     TestSupplemental::supplementalMethod1(&impl);
873     return JSValue::encode(jsUndefined());
874 }
875
876 #endif
877
878 #if ENABLE(Condition11) || ENABLE(Condition12)
879 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod2(ExecState* exec)
880 {
881     JSValue thisValue = exec->hostThisValue();
882     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
883     if (UNLIKELY(!castedThis))
884         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "supplementalMethod2", " on instances of ", "TestInterface"));
885     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
886     TestInterface& impl = castedThis->impl();
887     if (exec->argumentCount() < 2)
888         return throwVMError(exec, createNotEnoughArgumentsError(exec));
889     ExceptionCode ec = 0;
890     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
891     if (!scriptContext)
892         return JSValue::encode(jsUndefined());
893     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
894     if (UNLIKELY(exec->hadException()))
895         return JSValue::encode(jsUndefined());
896     TestObj* objArg(toTestObj(exec->argument(1)));
897     if (UNLIKELY(exec->hadException()))
898         return JSValue::encode(jsUndefined());
899     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalMethod2(&impl, scriptContext, strArg, objArg, ec)));
900
901     setDOMException(exec, ec);
902     return JSValue::encode(result);
903 }
904
905 #endif
906
907 #if ENABLE(Condition11) || ENABLE(Condition12)
908 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod3(ExecState* exec)
909 {
910     JSValue thisValue = exec->hostThisValue();
911     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
912     if (UNLIKELY(!castedThis))
913         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Can only call ", "TestInterface", ".", "supplementalMethod3", " on instances of ", "TestInterface"));
914     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
915     return JSValue::encode(castedThis->supplementalMethod3(exec));
916 }
917
918 #endif
919
920 #if ENABLE(Condition11) || ENABLE(Condition12)
921 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionSupplementalMethod4(ExecState* exec)
922 {
923     TestSupplemental::supplementalMethod4();
924     return JSValue::encode(jsUndefined());
925 }
926
927 #endif
928
929 // Constant getters
930
931 #if ENABLE(Condition22) || ENABLE(Condition23)
932 EncodedJSValue jsTestInterfaceIMPLEMENTSCONSTANT1(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
933 {
934     UNUSED_PARAM(exec);
935     return JSValue::encode(jsNumber(static_cast<int>(1)));
936 }
937
938 #endif
939 #if ENABLE(Condition22) || ENABLE(Condition23)
940 EncodedJSValue jsTestInterfaceIMPLEMENTSCONSTANT2(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
941 {
942     UNUSED_PARAM(exec);
943     return JSValue::encode(jsNumber(static_cast<int>(2)));
944 }
945
946 #endif
947 #if ENABLE(Condition11) || ENABLE(Condition12)
948 EncodedJSValue jsTestInterfaceSUPPLEMENTALCONSTANT1(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
949 {
950     UNUSED_PARAM(exec);
951     return JSValue::encode(jsNumber(static_cast<int>(1)));
952 }
953
954 #endif
955 #if ENABLE(Condition11) || ENABLE(Condition12)
956 EncodedJSValue jsTestInterfaceSUPPLEMENTALCONSTANT2(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
957 {
958     UNUSED_PARAM(exec);
959     return JSValue::encode(jsNumber(static_cast<int>(2)));
960 }
961
962 #endif
963 bool JSTestInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
964 {
965     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.slot()->asCell());
966     if (jsTestInterface->impl().hasPendingActivity())
967         return true;
968     UNUSED_PARAM(visitor);
969     return false;
970 }
971
972 void JSTestInterfaceOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
973 {
974     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.slot()->asCell());
975     DOMWrapperWorld& world = *static_cast<DOMWrapperWorld*>(context);
976     uncacheWrapper(world, &jsTestInterface->impl(), jsTestInterface);
977     jsTestInterface->releaseImpl();
978 }
979
980 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestInterface* impl)
981 {
982     if (!impl)
983         return jsNull();
984     if (JSValue result = getExistingWrapper<JSTestInterface>(exec, impl))
985         return result;
986 #if COMPILER(CLANG)
987     // If you hit this failure the interface definition has the ImplementationLacksVTable
988     // attribute. You should remove that attribute. If the class has subclasses
989     // that may be passed through this toJS() function you should use the SkipVTableValidation
990     // attribute to TestInterface.
991     COMPILE_ASSERT(!__is_polymorphic(TestInterface), TestInterface_is_polymorphic_but_idl_claims_not_to_be);
992 #endif
993     return createNewWrapper<JSTestInterface>(exec, globalObject, impl);
994 }
995
996 TestInterface* toTestInterface(JSC::JSValue value)
997 {
998     return value.inherits(JSTestInterface::info()) ? &jsCast<JSTestInterface*>(value)->impl() : 0;
999 }
1000
1001 }
1002
1003 #endif // ENABLE(Condition1) || ENABLE(Condition2)