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