b311665af0d0a8a9f31877c7ef679f505fb0dd7a
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestOverloadedConstructors.cpp
1 /*
2     This file is part of the WebKit open source project.
3     This file has been generated by generate-bindings.pl. DO NOT MODIFY!
4
5     This library is free software; you can redistribute it and/or
6     modify it under the terms of the GNU Library General Public
7     License as published by the Free Software Foundation; either
8     version 2 of the License, or (at your option) any later version.
9
10     This library is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13     Library General Public License for more details.
14
15     You should have received a copy of the GNU Library General Public License
16     along with this library; see the file COPYING.LIB.  If not, write to
17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18     Boston, MA 02110-1301, USA.
19 */
20
21 #include "config.h"
22 #include "JSTestOverloadedConstructors.h"
23
24 #include "ExceptionCode.h"
25 #include "JSBlob.h"
26 #include "JSDOMBinding.h"
27 #include "TestOverloadedConstructors.h"
28 #include <runtime/Error.h>
29 #include <wtf/GetPtr.h>
30
31 using namespace JSC;
32
33 namespace WebCore {
34
35 /* Hash table for constructor */
36
37 static const struct CompactHashIndex JSTestOverloadedConstructorsConstructorTableIndex[1] = {
38     { -1, -1 },
39 };
40
41
42 static const HashTableValue JSTestOverloadedConstructorsConstructorTableValues[] =
43 {
44     { 0, 0, NoIntrinsic, 0, 0 }
45 };
46
47 static const HashTable JSTestOverloadedConstructorsConstructorTable = { 0, 0, false, JSTestOverloadedConstructorsConstructorTableValues, 0, JSTestOverloadedConstructorsConstructorTableIndex };
48 EncodedJSValue JSC_HOST_CALL JSTestOverloadedConstructorsConstructor::constructJSTestOverloadedConstructors1(ExecState* exec)
49 {
50     JSTestOverloadedConstructorsConstructor* castedThis = jsCast<JSTestOverloadedConstructorsConstructor*>(exec->callee());
51     if (exec->argumentCount() < 1)
52         return throwVMError(exec, createNotEnoughArgumentsError(exec));
53     ArrayBuffer* arrayBuffer(toArrayBuffer(exec->argument(0)));
54     if (UNLIKELY(exec->hadException()))
55         return JSValue::encode(jsUndefined());
56     RefPtr<TestOverloadedConstructors> object = TestOverloadedConstructors::create(arrayBuffer);
57     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
58 }
59
60 EncodedJSValue JSC_HOST_CALL JSTestOverloadedConstructorsConstructor::constructJSTestOverloadedConstructors2(ExecState* exec)
61 {
62     JSTestOverloadedConstructorsConstructor* castedThis = jsCast<JSTestOverloadedConstructorsConstructor*>(exec->callee());
63     if (exec->argumentCount() < 1)
64         return throwVMError(exec, createNotEnoughArgumentsError(exec));
65     RefPtr<ArrayBufferView> arrayBufferView(toArrayBufferView(exec->argument(0)));
66     if (UNLIKELY(exec->hadException()))
67         return JSValue::encode(jsUndefined());
68     RefPtr<TestOverloadedConstructors> object = TestOverloadedConstructors::create(arrayBufferView);
69     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
70 }
71
72 EncodedJSValue JSC_HOST_CALL JSTestOverloadedConstructorsConstructor::constructJSTestOverloadedConstructors3(ExecState* exec)
73 {
74     JSTestOverloadedConstructorsConstructor* castedThis = jsCast<JSTestOverloadedConstructorsConstructor*>(exec->callee());
75     if (exec->argumentCount() < 1)
76         return throwVMError(exec, createNotEnoughArgumentsError(exec));
77     Blob* blob(toBlob(exec->argument(0)));
78     if (UNLIKELY(exec->hadException()))
79         return JSValue::encode(jsUndefined());
80     RefPtr<TestOverloadedConstructors> object = TestOverloadedConstructors::create(blob);
81     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
82 }
83
84 EncodedJSValue JSC_HOST_CALL JSTestOverloadedConstructorsConstructor::constructJSTestOverloadedConstructors4(ExecState* exec)
85 {
86     JSTestOverloadedConstructorsConstructor* castedThis = jsCast<JSTestOverloadedConstructorsConstructor*>(exec->callee());
87     if (exec->argumentCount() < 1)
88         return throwVMError(exec, createNotEnoughArgumentsError(exec));
89     const String& string(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
90     if (UNLIKELY(exec->hadException()))
91         return JSValue::encode(jsUndefined());
92     RefPtr<TestOverloadedConstructors> object = TestOverloadedConstructors::create(string);
93     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
94 }
95
96 EncodedJSValue JSC_HOST_CALL JSTestOverloadedConstructorsConstructor::constructJSTestOverloadedConstructors(ExecState* exec)
97 {
98     size_t argsCount = exec->argumentCount();
99     JSValue arg0(exec->argument(0));
100     if ((argsCount == 1 && (arg0.isObject() && asObject(arg0)->inherits(JSArrayBuffer::info()))))
101         return JSTestOverloadedConstructorsConstructor::constructJSTestOverloadedConstructors1(exec);
102     if ((argsCount == 1 && (arg0.isObject() && asObject(arg0)->inherits(JSArrayBufferView::info()))))
103         return JSTestOverloadedConstructorsConstructor::constructJSTestOverloadedConstructors2(exec);
104     if ((argsCount == 1 && (arg0.isObject() && asObject(arg0)->inherits(JSBlob::info()))))
105         return JSTestOverloadedConstructorsConstructor::constructJSTestOverloadedConstructors3(exec);
106     if (argsCount == 1)
107         return JSTestOverloadedConstructorsConstructor::constructJSTestOverloadedConstructors4(exec);
108     if (argsCount < 1)
109         return throwVMError(exec, createNotEnoughArgumentsError(exec));
110     return throwVMTypeError(exec);
111 }
112
113 const ClassInfo JSTestOverloadedConstructorsConstructor::s_info = { "TestOverloadedConstructorsConstructor", &Base::s_info, &JSTestOverloadedConstructorsConstructorTable, 0, CREATE_METHOD_TABLE(JSTestOverloadedConstructorsConstructor) };
114
115 JSTestOverloadedConstructorsConstructor::JSTestOverloadedConstructorsConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
116     : DOMConstructorObject(structure, globalObject)
117 {
118 }
119
120 void JSTestOverloadedConstructorsConstructor::finishCreation(VM& vm, JSDOMGlobalObject* globalObject)
121 {
122     Base::finishCreation(vm);
123     ASSERT(inherits(info()));
124     putDirect(vm, vm.propertyNames->prototype, JSTestOverloadedConstructorsPrototype::self(vm, globalObject), DontDelete | ReadOnly);
125     putDirect(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontDelete | DontEnum);
126 }
127
128 bool JSTestOverloadedConstructorsConstructor::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
129 {
130     return getStaticValueSlot<JSTestOverloadedConstructorsConstructor, JSDOMWrapper>(exec, JSTestOverloadedConstructorsConstructorTable, jsCast<JSTestOverloadedConstructorsConstructor*>(object), propertyName, slot);
131 }
132
133 ConstructType JSTestOverloadedConstructorsConstructor::getConstructData(JSCell*, ConstructData& constructData)
134 {
135     constructData.native.function = constructJSTestOverloadedConstructors;
136     return ConstructTypeHost;
137 }
138
139 /* Hash table for prototype */
140
141 static const struct CompactHashIndex JSTestOverloadedConstructorsPrototypeTableIndex[2] = {
142     { -1, -1 },
143     { 0, -1 },
144 };
145
146
147 static const HashTableValue JSTestOverloadedConstructorsPrototypeTableValues[] =
148 {
149     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestOverloadedConstructorsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
150 };
151
152 static const HashTable JSTestOverloadedConstructorsPrototypeTable = { 1, 1, true, JSTestOverloadedConstructorsPrototypeTableValues, 0, JSTestOverloadedConstructorsPrototypeTableIndex };
153 const ClassInfo JSTestOverloadedConstructorsPrototype::s_info = { "TestOverloadedConstructorsPrototype", &Base::s_info, &JSTestOverloadedConstructorsPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestOverloadedConstructorsPrototype) };
154
155 JSObject* JSTestOverloadedConstructorsPrototype::self(VM& vm, JSGlobalObject* globalObject)
156 {
157     return getDOMPrototype<JSTestOverloadedConstructors>(vm, globalObject);
158 }
159
160 bool JSTestOverloadedConstructorsPrototype::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
161 {
162     JSTestOverloadedConstructorsPrototype* thisObject = jsCast<JSTestOverloadedConstructorsPrototype*>(object);
163     return getStaticPropertySlot<JSTestOverloadedConstructorsPrototype, JSObject>(exec, JSTestOverloadedConstructorsPrototypeTable, thisObject, propertyName, slot);
164 }
165
166 const ClassInfo JSTestOverloadedConstructors::s_info = { "TestOverloadedConstructors", &Base::s_info, 0, 0 , CREATE_METHOD_TABLE(JSTestOverloadedConstructors) };
167
168 JSTestOverloadedConstructors::JSTestOverloadedConstructors(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestOverloadedConstructors> impl)
169     : JSDOMWrapper(structure, globalObject)
170     , m_impl(impl.leakRef())
171 {
172 }
173
174 void JSTestOverloadedConstructors::finishCreation(VM& vm)
175 {
176     Base::finishCreation(vm);
177     ASSERT(inherits(info()));
178 }
179
180 JSObject* JSTestOverloadedConstructors::createPrototype(VM& vm, JSGlobalObject* globalObject)
181 {
182     return JSTestOverloadedConstructorsPrototype::create(vm, globalObject, JSTestOverloadedConstructorsPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
183 }
184
185 void JSTestOverloadedConstructors::destroy(JSC::JSCell* cell)
186 {
187     JSTestOverloadedConstructors* thisObject = static_cast<JSTestOverloadedConstructors*>(cell);
188     thisObject->JSTestOverloadedConstructors::~JSTestOverloadedConstructors();
189 }
190
191 JSTestOverloadedConstructors::~JSTestOverloadedConstructors()
192 {
193     releaseImplIfNotNull();
194 }
195
196 bool JSTestOverloadedConstructors::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
197 {
198     JSTestOverloadedConstructors* thisObject = jsCast<JSTestOverloadedConstructors*>(object);
199     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
200     return Base::getOwnPropertySlot(thisObject, exec, propertyName, slot);
201 }
202
203 EncodedJSValue jsTestOverloadedConstructorsConstructor(ExecState* exec, JSObject* baseValue, EncodedJSValue thisValue, PropertyName)
204 {
205     UNUSED_PARAM(baseValue);
206     UNUSED_PARAM(thisValue);
207     JSTestOverloadedConstructorsPrototype* domObject = jsDynamicCast<JSTestOverloadedConstructorsPrototype*>(baseValue);
208     if (!domObject)
209         return throwVMTypeError(exec);
210     return JSValue::encode(JSTestOverloadedConstructors::getConstructor(exec->vm(), domObject->globalObject()));
211 }
212
213 JSValue JSTestOverloadedConstructors::getConstructor(VM& vm, JSGlobalObject* globalObject)
214 {
215     return getDOMConstructor<JSTestOverloadedConstructorsConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
216 }
217
218 bool JSTestOverloadedConstructorsOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
219 {
220     UNUSED_PARAM(handle);
221     UNUSED_PARAM(visitor);
222     return false;
223 }
224
225 void JSTestOverloadedConstructorsOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
226 {
227     JSTestOverloadedConstructors* jsTestOverloadedConstructors = jsCast<JSTestOverloadedConstructors*>(handle.slot()->asCell());
228     DOMWrapperWorld& world = *static_cast<DOMWrapperWorld*>(context);
229     uncacheWrapper(world, &jsTestOverloadedConstructors->impl(), jsTestOverloadedConstructors);
230     jsTestOverloadedConstructors->releaseImpl();
231 }
232
233 #if ENABLE(BINDING_INTEGRITY)
234 #if PLATFORM(WIN)
235 #pragma warning(disable: 4483)
236 extern "C" { extern void (*const __identifier("??_7TestOverloadedConstructors@WebCore@@6B@")[])(); }
237 #else
238 extern "C" { extern void* _ZTVN7WebCore26TestOverloadedConstructorsE[]; }
239 #endif
240 #endif
241 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestOverloadedConstructors* impl)
242 {
243     if (!impl)
244         return jsNull();
245     if (JSValue result = getExistingWrapper<JSTestOverloadedConstructors>(exec, impl))
246         return result;
247
248 #if ENABLE(BINDING_INTEGRITY)
249     void* actualVTablePointer = *(reinterpret_cast<void**>(impl));
250 #if PLATFORM(WIN)
251     void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7TestOverloadedConstructors@WebCore@@6B@"));
252 #else
253     void* expectedVTablePointer = &_ZTVN7WebCore26TestOverloadedConstructorsE[2];
254 #if COMPILER(CLANG)
255     // If this fails TestOverloadedConstructors does not have a vtable, so you need to add the
256     // ImplementationLacksVTable attribute to the interface definition
257     COMPILE_ASSERT(__is_polymorphic(TestOverloadedConstructors), TestOverloadedConstructors_is_not_polymorphic);
258 #endif
259 #endif
260     // If you hit this assertion you either have a use after free bug, or
261     // TestOverloadedConstructors has subclasses. If TestOverloadedConstructors has subclasses that get passed
262     // to toJS() we currently require TestOverloadedConstructors you to opt out of binding hardening
263     // by adding the SkipVTableValidation attribute to the interface IDL definition
264     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
265 #endif
266     return createNewWrapper<JSTestOverloadedConstructors>(exec, globalObject, impl);
267 }
268
269 TestOverloadedConstructors* toTestOverloadedConstructors(JSC::JSValue value)
270 {
271     return value.inherits(JSTestOverloadedConstructors::info()) ? &jsCast<JSTestOverloadedConstructors*>(value)->impl() : 0;
272 }
273
274 }