8f43d954422da7c0e56b5a7106d92d16c3352b4b
[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 "TestInterface.h"
31 #include "TestObj.h"
32 #include "TestSupplemental.h"
33 #include <runtime/Error.h>
34 #include <wtf/GetPtr.h>
35
36 #if ENABLE(Condition11) || ENABLE(Condition12) || ENABLE(Condition22) || ENABLE(Condition23)
37 #include "JSNode.h"
38 #include "URL.h"
39 #include <runtime/JSString.h>
40 #endif
41
42 #if ENABLE(Condition11) || ENABLE(Condition12) || ENABLE(Condition22) || ENABLE(Condition23)
43 #include "Node.h"
44 #endif
45
46 using namespace JSC;
47
48 namespace WebCore {
49
50 /* Hash table */
51
52 static const HashTableValue JSTestInterfaceTableValues[] =
53 {
54 #if ENABLE(Condition22) || ENABLE(Condition23)
55     { "implementsStr1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr1), (intptr_t)0 },
56 #endif
57 #if ENABLE(Condition22) || ENABLE(Condition23)
58     { "implementsStr2", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr2), (intptr_t)setJSTestInterfaceImplementsStr2 },
59 #endif
60 #if ENABLE(Condition22) || ENABLE(Condition23)
61     { "implementsStr3", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr3), (intptr_t)setJSTestInterfaceImplementsStr3 },
62 #endif
63 #if ENABLE(Condition22) || ENABLE(Condition23)
64     { "implementsNode", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsNode), (intptr_t)setJSTestInterfaceImplementsNode },
65 #endif
66 #if ENABLE(Condition11) || ENABLE(Condition12)
67     { "supplementalStr1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr1), (intptr_t)0 },
68 #endif
69 #if ENABLE(Condition11) || ENABLE(Condition12)
70     { "supplementalStr2", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr2), (intptr_t)setJSTestInterfaceSupplementalStr2 },
71 #endif
72 #if ENABLE(Condition11) || ENABLE(Condition12)
73     { "supplementalStr3", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr3), (intptr_t)setJSTestInterfaceSupplementalStr3 },
74 #endif
75 #if ENABLE(Condition11) || ENABLE(Condition12)
76     { "supplementalNode", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalNode), (intptr_t)setJSTestInterfaceSupplementalNode },
77 #endif
78     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructor), (intptr_t)0 },
79     { 0, 0, NoIntrinsic, 0, 0 }
80 };
81
82 static const HashTable JSTestInterfaceTable = { 33, 31, JSTestInterfaceTableValues, 0 };
83 /* Hash table for constructor */
84
85 static const HashTableValue JSTestInterfaceConstructorTableValues[] =
86 {
87 #if ENABLE(Condition22) || ENABLE(Condition23)
88     { "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT1), (intptr_t)0 },
89 #endif
90 #if ENABLE(Condition22) || ENABLE(Condition23)
91     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t)0 },
92 #endif
93 #if ENABLE(Condition11) || ENABLE(Condition12)
94     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t)0 },
95 #endif
96 #if ENABLE(Condition11) || ENABLE(Condition12)
97     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t)0 },
98 #endif
99 #if ENABLE(Condition22) || ENABLE(Condition23)
100     { "implementsStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticReadOnlyAttr), (intptr_t)0 },
101 #endif
102 #if ENABLE(Condition22) || ENABLE(Condition23)
103     { "implementsStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticAttr), (intptr_t)setJSTestInterfaceConstructorImplementsStaticAttr },
104 #endif
105 #if ENABLE(Condition11) || ENABLE(Condition12)
106     { "supplementalStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr), (intptr_t)0 },
107 #endif
108 #if ENABLE(Condition11) || ENABLE(Condition12)
109     { "supplementalStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticAttr), (intptr_t)setJSTestInterfaceConstructorSupplementalStaticAttr },
110 #endif
111 #if ENABLE(Condition22) || ENABLE(Condition23)
112     { "implementsMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionImplementsMethod4), (intptr_t)0 },
113 #endif
114 #if ENABLE(Condition11) || ENABLE(Condition12)
115     { "supplementalMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionSupplementalMethod4), (intptr_t)0 },
116 #endif
117     { 0, 0, NoIntrinsic, 0, 0 }
118 };
119
120 static const HashTable JSTestInterfaceConstructorTable = { 11, 7, JSTestInterfaceConstructorTableValues, 0 };
121
122 #if ENABLE(Condition22) || ENABLE(Condition23)
123 COMPILE_ASSERT(1 == TestInterface::IMPLEMENTSCONSTANT1, TestInterfaceEnumIMPLEMENTSCONSTANT1IsWrongUseDoNotCheckConstants);
124 #endif
125 #if ENABLE(Condition22) || ENABLE(Condition23)
126 COMPILE_ASSERT(2 == TestInterface::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
127 #endif
128 #if ENABLE(Condition11) || ENABLE(Condition12)
129 COMPILE_ASSERT(1 == TestSupplemental::SUPPLEMENTALCONSTANT1, TestInterfaceEnumSUPPLEMENTALCONSTANT1IsWrongUseDoNotCheckConstants);
130 #endif
131 #if ENABLE(Condition11) || ENABLE(Condition12)
132 COMPILE_ASSERT(2 == TestSupplemental::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
133 #endif
134
135 EncodedJSValue JSC_HOST_CALL JSTestInterfaceConstructor::constructJSTestInterface(ExecState* exec)
136 {
137     JSTestInterfaceConstructor* castedThis = jsCast<JSTestInterfaceConstructor*>(exec->callee());
138     if (exec->argumentCount() < 1)
139         return throwVMError(exec, createNotEnoughArgumentsError(exec));
140     ExceptionCode ec = 0;
141     const String& str1(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
142     if (exec->hadException())
143         return JSValue::encode(jsUndefined());
144     const String& str2(exec->argument(1).isEmpty() ? String() : exec->argument(1).toString(exec)->value(exec));
145     if (exec->hadException())
146         return JSValue::encode(jsUndefined());
147     ScriptExecutionContext* context = castedThis->scriptExecutionContext();
148     if (!context)
149         return throwVMError(exec, createReferenceError(exec, "TestInterface constructor associated document is unavailable"));
150     RefPtr<TestInterface> object = TestInterface::create(*context, str1, str2, ec);
151     if (ec) {
152         setDOMException(exec, ec);
153         return JSValue::encode(JSValue());
154     }
155     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
156 }
157
158 const ClassInfo JSTestInterfaceConstructor::s_info = { "TestInterfaceConstructor", &Base::s_info, &JSTestInterfaceConstructorTable, 0, CREATE_METHOD_TABLE(JSTestInterfaceConstructor) };
159
160 JSTestInterfaceConstructor::JSTestInterfaceConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
161     : DOMConstructorObject(structure, globalObject)
162 {
163 }
164
165 void JSTestInterfaceConstructor::finishCreation(VM& vm, JSDOMGlobalObject* globalObject)
166 {
167     Base::finishCreation(vm);
168     ASSERT(inherits(info()));
169     putDirect(vm, vm.propertyNames->prototype, JSTestInterfacePrototype::self(vm, globalObject), DontDelete | ReadOnly);
170     putDirect(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontDelete | DontEnum);
171 }
172
173 bool JSTestInterfaceConstructor::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
174 {
175     return getStaticPropertySlot<JSTestInterfaceConstructor, JSDOMWrapper>(exec, JSTestInterfaceConstructorTable, jsCast<JSTestInterfaceConstructor*>(object), propertyName, slot);
176 }
177
178 #if ENABLE(TEST_INTERFACE)
179 ConstructType JSTestInterfaceConstructor::getConstructData(JSCell*, ConstructData& constructData)
180 {
181     constructData.native.function = constructJSTestInterface;
182     return ConstructTypeHost;
183 }
184 #endif // ENABLE(TEST_INTERFACE)
185
186 /* Hash table for prototype */
187
188 static const HashTableValue JSTestInterfacePrototypeTableValues[] =
189 {
190 #if ENABLE(Condition22) || ENABLE(Condition23)
191     { "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT1), (intptr_t)0 },
192 #endif
193 #if ENABLE(Condition22) || ENABLE(Condition23)
194     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t)0 },
195 #endif
196 #if ENABLE(Condition11) || ENABLE(Condition12)
197     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t)0 },
198 #endif
199 #if ENABLE(Condition11) || ENABLE(Condition12)
200     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t)0 },
201 #endif
202 #if ENABLE(Condition22) || ENABLE(Condition23)
203     { "implementsMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod1), (intptr_t)0 },
204 #endif
205 #if ENABLE(Condition22) || ENABLE(Condition23)
206     { "implementsMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod2), (intptr_t)2 },
207 #endif
208 #if ENABLE(Condition22) || ENABLE(Condition23)
209     { "implementsMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod3), (intptr_t)0 },
210 #endif
211 #if ENABLE(Condition11) || ENABLE(Condition12)
212     { "supplementalMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod1), (intptr_t)0 },
213 #endif
214 #if ENABLE(Condition11) || ENABLE(Condition12)
215     { "supplementalMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod2), (intptr_t)2 },
216 #endif
217 #if ENABLE(Condition11) || ENABLE(Condition12)
218     { "supplementalMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod3), (intptr_t)0 },
219 #endif
220     { 0, 0, NoIntrinsic, 0, 0 }
221 };
222
223 static const HashTable JSTestInterfacePrototypeTable = { 34, 31, JSTestInterfacePrototypeTableValues, 0 };
224 const ClassInfo JSTestInterfacePrototype::s_info = { "TestInterfacePrototype", &Base::s_info, &JSTestInterfacePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestInterfacePrototype) };
225
226 JSObject* JSTestInterfacePrototype::self(VM& vm, JSGlobalObject* globalObject)
227 {
228     return getDOMPrototype<JSTestInterface>(vm, globalObject);
229 }
230
231 bool JSTestInterfacePrototype::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
232 {
233     JSTestInterfacePrototype* thisObject = jsCast<JSTestInterfacePrototype*>(object);
234     return getStaticPropertySlot<JSTestInterfacePrototype, JSObject>(exec, JSTestInterfacePrototypeTable, thisObject, propertyName, slot);
235 }
236
237 const ClassInfo JSTestInterface::s_info = { "TestInterface", &Base::s_info, &JSTestInterfaceTable, 0 , CREATE_METHOD_TABLE(JSTestInterface) };
238
239 JSTestInterface::JSTestInterface(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestInterface> impl)
240     : JSDOMWrapper(structure, globalObject)
241     , m_impl(impl.leakRef())
242 {
243 }
244
245 void JSTestInterface::finishCreation(VM& vm)
246 {
247     Base::finishCreation(vm);
248     ASSERT(inherits(info()));
249 }
250
251 JSObject* JSTestInterface::createPrototype(VM& vm, JSGlobalObject* globalObject)
252 {
253     return JSTestInterfacePrototype::create(vm, globalObject, JSTestInterfacePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
254 }
255
256 void JSTestInterface::destroy(JSC::JSCell* cell)
257 {
258     JSTestInterface* thisObject = static_cast<JSTestInterface*>(cell);
259     thisObject->JSTestInterface::~JSTestInterface();
260 }
261
262 JSTestInterface::~JSTestInterface()
263 {
264     releaseImplIfNotNull();
265 }
266
267 bool JSTestInterface::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
268 {
269     JSTestInterface* thisObject = jsCast<JSTestInterface*>(object);
270     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
271     return getStaticValueSlot<JSTestInterface, Base>(exec, JSTestInterfaceTable, thisObject, propertyName, slot);
272 }
273
274 #if ENABLE(Condition22) || ENABLE(Condition23)
275 JSValue jsTestInterfaceConstructorImplementsStaticReadOnlyAttr(ExecState* exec, JSValue slotBase, PropertyName)
276 {
277     UNUSED_PARAM(slotBase);
278     UNUSED_PARAM(exec);
279     JSValue result = jsNumber(TestInterface::implementsStaticReadOnlyAttr());
280     return result;
281 }
282
283 #endif
284
285 #if ENABLE(Condition22) || ENABLE(Condition23)
286 JSValue jsTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSValue slotBase, PropertyName)
287 {
288     UNUSED_PARAM(slotBase);
289     UNUSED_PARAM(exec);
290     JSValue result = jsStringWithCache(exec, TestInterface::implementsStaticAttr());
291     return result;
292 }
293
294 #endif
295
296 #if ENABLE(Condition22) || ENABLE(Condition23)
297 JSValue jsTestInterfaceImplementsStr1(ExecState* exec, JSValue slotBase, PropertyName)
298 {
299     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
300     UNUSED_PARAM(exec);
301     TestInterface& impl = castedThis->impl();
302     JSValue result = jsStringWithCache(exec, impl.implementsStr1());
303     return result;
304 }
305
306 #endif
307
308 #if ENABLE(Condition22) || ENABLE(Condition23)
309 JSValue jsTestInterfaceImplementsStr2(ExecState* exec, JSValue slotBase, PropertyName)
310 {
311     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
312     UNUSED_PARAM(exec);
313     TestInterface& impl = castedThis->impl();
314     JSValue result = jsStringWithCache(exec, impl.implementsStr2());
315     return result;
316 }
317
318 #endif
319
320 #if ENABLE(Condition22) || ENABLE(Condition23)
321 JSValue jsTestInterfaceImplementsStr3(ExecState* exec, JSValue slotBase, PropertyName)
322 {
323     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
324     return castedThis->implementsStr3(exec);
325 }
326
327 #endif
328
329 #if ENABLE(Condition22) || ENABLE(Condition23)
330 JSValue jsTestInterfaceImplementsNode(ExecState* exec, JSValue slotBase, PropertyName)
331 {
332     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
333     UNUSED_PARAM(exec);
334     TestInterface& impl = castedThis->impl();
335     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsNode()));
336     return result;
337 }
338
339 #endif
340
341 #if ENABLE(Condition11) || ENABLE(Condition12)
342 JSValue jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr(ExecState* exec, JSValue slotBase, PropertyName)
343 {
344     UNUSED_PARAM(slotBase);
345     UNUSED_PARAM(exec);
346     JSValue result = jsNumber(TestSupplemental::supplementalStaticReadOnlyAttr());
347     return result;
348 }
349
350 #endif
351
352 #if ENABLE(Condition11) || ENABLE(Condition12)
353 JSValue jsTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSValue slotBase, PropertyName)
354 {
355     UNUSED_PARAM(slotBase);
356     UNUSED_PARAM(exec);
357     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStaticAttr());
358     return result;
359 }
360
361 #endif
362
363 #if ENABLE(Condition11) || ENABLE(Condition12)
364 JSValue jsTestInterfaceSupplementalStr1(ExecState* exec, JSValue slotBase, PropertyName)
365 {
366     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
367     UNUSED_PARAM(exec);
368     TestInterface& impl = castedThis->impl();
369     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr1(&impl));
370     return result;
371 }
372
373 #endif
374
375 #if ENABLE(Condition11) || ENABLE(Condition12)
376 JSValue jsTestInterfaceSupplementalStr2(ExecState* exec, JSValue slotBase, PropertyName)
377 {
378     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
379     UNUSED_PARAM(exec);
380     TestInterface& impl = castedThis->impl();
381     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr2(&impl));
382     return result;
383 }
384
385 #endif
386
387 #if ENABLE(Condition11) || ENABLE(Condition12)
388 JSValue jsTestInterfaceSupplementalStr3(ExecState* exec, JSValue slotBase, PropertyName)
389 {
390     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
391     return castedThis->supplementalStr3(exec);
392 }
393
394 #endif
395
396 #if ENABLE(Condition11) || ENABLE(Condition12)
397 JSValue jsTestInterfaceSupplementalNode(ExecState* exec, JSValue slotBase, PropertyName)
398 {
399     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(slotBase));
400     UNUSED_PARAM(exec);
401     TestInterface& impl = castedThis->impl();
402     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalNode(&impl)));
403     return result;
404 }
405
406 #endif
407
408 JSValue jsTestInterfaceConstructor(ExecState* exec, JSValue slotBase, PropertyName)
409 {
410     JSTestInterface* domObject = jsCast<JSTestInterface*>(asObject(slotBase));
411     return JSTestInterface::getConstructor(exec->vm(), domObject->globalObject());
412 }
413
414 void JSTestInterface::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
415 {
416     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
417     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
418     if (thisObject->putDelegate(exec, propertyName, value, slot))
419         return;
420     lookupPut<JSTestInterface, Base>(exec, propertyName, value, JSTestInterfaceTable, thisObject, slot);
421 }
422
423 void JSTestInterface::putByIndex(JSCell* cell, ExecState* exec, unsigned index, JSValue value, bool shouldThrow)
424 {
425     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
426     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
427     PropertyName propertyName = Identifier::from(exec, index);
428     PutPropertySlot slot(shouldThrow);
429     if (thisObject->putDelegate(exec, propertyName, value, slot))
430         return;
431     Base::putByIndex(cell, exec, index, value, shouldThrow);
432 }
433
434 #if ENABLE(Condition22) || ENABLE(Condition23)
435 void setJSTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSObject*, JSValue value)
436 {
437     UNUSED_PARAM(exec);
438     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
439     if (exec->hadException())
440         return;
441     TestInterface::setImplementsStaticAttr(nativeValue);
442 }
443
444 #endif
445
446 #if ENABLE(Condition22) || ENABLE(Condition23)
447 void setJSTestInterfaceImplementsStr2(ExecState* exec, JSObject* thisObject, JSValue value)
448 {
449     UNUSED_PARAM(exec);
450     JSTestInterface* castedThis = jsCast<JSTestInterface*>(thisObject);
451     TestInterface& impl = castedThis->impl();
452     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
453     if (exec->hadException())
454         return;
455     impl.setImplementsStr2(nativeValue);
456 }
457
458 #endif
459
460 #if ENABLE(Condition22) || ENABLE(Condition23)
461 void setJSTestInterfaceImplementsStr3(ExecState* exec, JSObject* thisObject, JSValue value)
462 {
463     UNUSED_PARAM(exec);
464     jsCast<JSTestInterface*>(thisObject)->setImplementsStr3(exec, value);
465 }
466
467 #endif
468
469 #if ENABLE(Condition22) || ENABLE(Condition23)
470 void setJSTestInterfaceImplementsNode(ExecState* exec, JSObject* thisObject, JSValue value)
471 {
472     UNUSED_PARAM(exec);
473     JSTestInterface* castedThis = jsCast<JSTestInterface*>(thisObject);
474     TestInterface& impl = castedThis->impl();
475     Node* nativeValue(toNode(value));
476     if (exec->hadException())
477         return;
478     impl.setImplementsNode(nativeValue);
479 }
480
481 #endif
482
483 #if ENABLE(Condition11) || ENABLE(Condition12)
484 void setJSTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject*, JSValue value)
485 {
486     UNUSED_PARAM(exec);
487     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
488     if (exec->hadException())
489         return;
490     TestSupplemental::setSupplementalStaticAttr(nativeValue);
491 }
492
493 #endif
494
495 #if ENABLE(Condition11) || ENABLE(Condition12)
496 void setJSTestInterfaceSupplementalStr2(ExecState* exec, JSObject* thisObject, JSValue value)
497 {
498     UNUSED_PARAM(exec);
499     JSTestInterface* castedThis = jsCast<JSTestInterface*>(thisObject);
500     TestInterface& impl = castedThis->impl();
501     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
502     if (exec->hadException())
503         return;
504     TestSupplemental::setSupplementalStr2(&impl, nativeValue);
505 }
506
507 #endif
508
509 #if ENABLE(Condition11) || ENABLE(Condition12)
510 void setJSTestInterfaceSupplementalStr3(ExecState* exec, JSObject* thisObject, JSValue value)
511 {
512     UNUSED_PARAM(exec);
513     jsCast<JSTestInterface*>(thisObject)->setSupplementalStr3(exec, value);
514 }
515
516 #endif
517
518 #if ENABLE(Condition11) || ENABLE(Condition12)
519 void setJSTestInterfaceSupplementalNode(ExecState* exec, JSObject* thisObject, JSValue value)
520 {
521     UNUSED_PARAM(exec);
522     JSTestInterface* castedThis = jsCast<JSTestInterface*>(thisObject);
523     TestInterface& impl = castedThis->impl();
524     Node* nativeValue(toNode(value));
525     if (exec->hadException())
526         return;
527     TestSupplemental::setSupplementalNode(&impl, nativeValue);
528 }
529
530 #endif
531
532 JSValue JSTestInterface::getConstructor(VM& vm, JSGlobalObject* globalObject)
533 {
534     return getDOMConstructor<JSTestInterfaceConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
535 }
536
537 #if ENABLE(Condition22) || ENABLE(Condition23)
538 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod1(ExecState* exec)
539 {
540     JSValue thisValue = exec->hostThisValue();
541     if (!thisValue.inherits(JSTestInterface::info()))
542         return throwVMTypeError(exec);
543     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(thisValue));
544     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
545     TestInterface& impl = castedThis->impl();
546     impl.implementsMethod1();
547     return JSValue::encode(jsUndefined());
548 }
549
550 #endif
551
552 #if ENABLE(Condition22) || ENABLE(Condition23)
553 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod2(ExecState* exec)
554 {
555     JSValue thisValue = exec->hostThisValue();
556     if (!thisValue.inherits(JSTestInterface::info()))
557         return throwVMTypeError(exec);
558     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(thisValue));
559     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
560     TestInterface& impl = castedThis->impl();
561     if (exec->argumentCount() < 2)
562         return throwVMError(exec, createNotEnoughArgumentsError(exec));
563     ExceptionCode ec = 0;
564     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
565     if (!scriptContext)
566         return JSValue::encode(jsUndefined());
567     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
568     if (exec->hadException())
569         return JSValue::encode(jsUndefined());
570     TestObj* objArg(toTestObj(exec->argument(1)));
571     if (exec->hadException())
572         return JSValue::encode(jsUndefined());
573
574     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsMethod2(scriptContext, strArg, objArg, ec)));
575     setDOMException(exec, ec);
576     return JSValue::encode(result);
577 }
578
579 #endif
580
581 #if ENABLE(Condition22) || ENABLE(Condition23)
582 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod3(ExecState* exec)
583 {
584     JSValue thisValue = exec->hostThisValue();
585     if (!thisValue.inherits(JSTestInterface::info()))
586         return throwVMTypeError(exec);
587     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(thisValue));
588     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
589     return JSValue::encode(castedThis->implementsMethod3(exec));
590 }
591
592 #endif
593
594 #if ENABLE(Condition22) || ENABLE(Condition23)
595 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionImplementsMethod4(ExecState* exec)
596 {
597     TestInterface::implementsMethod4();
598     return JSValue::encode(jsUndefined());
599 }
600
601 #endif
602
603 #if ENABLE(Condition11) || ENABLE(Condition12)
604 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod1(ExecState* exec)
605 {
606     JSValue thisValue = exec->hostThisValue();
607     if (!thisValue.inherits(JSTestInterface::info()))
608         return throwVMTypeError(exec);
609     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(thisValue));
610     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
611     TestInterface& impl = castedThis->impl();
612     TestSupplemental::supplementalMethod1(&impl);
613     return JSValue::encode(jsUndefined());
614 }
615
616 #endif
617
618 #if ENABLE(Condition11) || ENABLE(Condition12)
619 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod2(ExecState* exec)
620 {
621     JSValue thisValue = exec->hostThisValue();
622     if (!thisValue.inherits(JSTestInterface::info()))
623         return throwVMTypeError(exec);
624     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(thisValue));
625     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
626     TestInterface& impl = castedThis->impl();
627     if (exec->argumentCount() < 2)
628         return throwVMError(exec, createNotEnoughArgumentsError(exec));
629     ExceptionCode ec = 0;
630     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
631     if (!scriptContext)
632         return JSValue::encode(jsUndefined());
633     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
634     if (exec->hadException())
635         return JSValue::encode(jsUndefined());
636     TestObj* objArg(toTestObj(exec->argument(1)));
637     if (exec->hadException())
638         return JSValue::encode(jsUndefined());
639
640     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalMethod2(&impl, scriptContext, strArg, objArg, ec)));
641     setDOMException(exec, ec);
642     return JSValue::encode(result);
643 }
644
645 #endif
646
647 #if ENABLE(Condition11) || ENABLE(Condition12)
648 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod3(ExecState* exec)
649 {
650     JSValue thisValue = exec->hostThisValue();
651     if (!thisValue.inherits(JSTestInterface::info()))
652         return throwVMTypeError(exec);
653     JSTestInterface* castedThis = jsCast<JSTestInterface*>(asObject(thisValue));
654     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
655     return JSValue::encode(castedThis->supplementalMethod3(exec));
656 }
657
658 #endif
659
660 #if ENABLE(Condition11) || ENABLE(Condition12)
661 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionSupplementalMethod4(ExecState* exec)
662 {
663     TestSupplemental::supplementalMethod4();
664     return JSValue::encode(jsUndefined());
665 }
666
667 #endif
668
669 // Constant getters
670
671 #if ENABLE(Condition22) || ENABLE(Condition23)
672 JSValue jsTestInterfaceIMPLEMENTSCONSTANT1(ExecState* exec, JSValue, PropertyName)
673 {
674     UNUSED_PARAM(exec);
675     return jsNumber(static_cast<int>(1));
676 }
677
678 #endif
679 #if ENABLE(Condition22) || ENABLE(Condition23)
680 JSValue jsTestInterfaceIMPLEMENTSCONSTANT2(ExecState* exec, JSValue, PropertyName)
681 {
682     UNUSED_PARAM(exec);
683     return jsNumber(static_cast<int>(2));
684 }
685
686 #endif
687 #if ENABLE(Condition11) || ENABLE(Condition12)
688 JSValue jsTestInterfaceSUPPLEMENTALCONSTANT1(ExecState* exec, JSValue, PropertyName)
689 {
690     UNUSED_PARAM(exec);
691     return jsNumber(static_cast<int>(1));
692 }
693
694 #endif
695 #if ENABLE(Condition11) || ENABLE(Condition12)
696 JSValue jsTestInterfaceSUPPLEMENTALCONSTANT2(ExecState* exec, JSValue, PropertyName)
697 {
698     UNUSED_PARAM(exec);
699     return jsNumber(static_cast<int>(2));
700 }
701
702 #endif
703 bool JSTestInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
704 {
705     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.get().asCell());
706     if (jsTestInterface->impl().hasPendingActivity())
707         return true;
708     UNUSED_PARAM(visitor);
709     return false;
710 }
711
712 void JSTestInterfaceOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
713 {
714     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.get().asCell());
715     DOMWrapperWorld& world = *static_cast<DOMWrapperWorld*>(context);
716     uncacheWrapper(world, &jsTestInterface->impl(), jsTestInterface);
717     jsTestInterface->releaseImpl();
718 }
719
720 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestInterface* impl)
721 {
722     if (!impl)
723         return jsNull();
724     if (JSValue result = getExistingWrapper<JSTestInterface>(exec, impl))
725         return result;
726 #if COMPILER(CLANG)
727     // If you hit this failure the interface definition has the ImplementationLacksVTable
728     // attribute. You should remove that attribute. If the class has subclasses
729     // that may be passed through this toJS() function you should use the SkipVTableValidation
730     // attribute to TestInterface.
731     COMPILE_ASSERT(!__is_polymorphic(TestInterface), TestInterface_is_polymorphic_but_idl_claims_not_to_be);
732 #endif
733     ReportMemoryCost<TestInterface>::reportMemoryCost(exec, impl);
734     return createNewWrapper<JSTestInterface>(exec, globalObject, impl);
735 }
736
737 TestInterface* toTestInterface(JSC::JSValue value)
738 {
739     return value.inherits(JSTestInterface::info()) ? &jsCast<JSTestInterface*>(asObject(value))->impl() : 0;
740 }
741
742 }
743
744 #endif // ENABLE(Condition1) || ENABLE(Condition2)