Foo::s_info should be Foo::info(), so that you can change how the s_info is actually...
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestException.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 "JSTestException.h"
23
24 #include "KURL.h"
25 #include "TestException.h"
26 #include <runtime/JSString.h>
27 #include <wtf/GetPtr.h>
28
29 using namespace JSC;
30
31 namespace WebCore {
32
33 /* Hash table */
34
35 static const HashTableValue JSTestExceptionTableValues[] =
36 {
37     { "name", DontDelete | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestExceptionName), (intptr_t)0, NoIntrinsic },
38     { "constructor", DontEnum | ReadOnly, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestExceptionConstructor), (intptr_t)0, NoIntrinsic },
39     { 0, 0, 0, 0, NoIntrinsic }
40 };
41
42 static const HashTable JSTestExceptionTable = { 5, 3, JSTestExceptionTableValues, 0 };
43 /* Hash table for constructor */
44
45 static const HashTableValue JSTestExceptionConstructorTableValues[] =
46 {
47     { 0, 0, 0, 0, NoIntrinsic }
48 };
49
50 static const HashTable JSTestExceptionConstructorTable = { 1, 0, JSTestExceptionConstructorTableValues, 0 };
51 const ClassInfo JSTestExceptionConstructor::s_info = { "TestExceptionConstructor", &Base::s_info, &JSTestExceptionConstructorTable, 0, CREATE_METHOD_TABLE(JSTestExceptionConstructor) };
52
53 JSTestExceptionConstructor::JSTestExceptionConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
54     : DOMConstructorObject(structure, globalObject)
55 {
56 }
57
58 void JSTestExceptionConstructor::finishCreation(ExecState* exec, JSDOMGlobalObject* globalObject)
59 {
60     Base::finishCreation(exec->vm());
61     ASSERT(inherits(info()));
62     putDirect(exec->vm(), exec->propertyNames().prototype, JSTestExceptionPrototype::self(exec, globalObject), DontDelete | ReadOnly);
63     putDirect(exec->vm(), exec->propertyNames().length, jsNumber(0), ReadOnly | DontDelete | DontEnum);
64 }
65
66 bool JSTestExceptionConstructor::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
67 {
68     return getStaticValueSlot<JSTestExceptionConstructor, JSDOMWrapper>(exec, &JSTestExceptionConstructorTable, jsCast<JSTestExceptionConstructor*>(object), propertyName, slot);
69 }
70
71 bool JSTestExceptionConstructor::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
72 {
73     return getStaticValueDescriptor<JSTestExceptionConstructor, JSDOMWrapper>(exec, &JSTestExceptionConstructorTable, jsCast<JSTestExceptionConstructor*>(object), propertyName, descriptor);
74 }
75
76 /* Hash table for prototype */
77
78 static const HashTableValue JSTestExceptionPrototypeTableValues[] =
79 {
80     { 0, 0, 0, 0, NoIntrinsic }
81 };
82
83 static const HashTable JSTestExceptionPrototypeTable = { 1, 0, JSTestExceptionPrototypeTableValues, 0 };
84 const ClassInfo JSTestExceptionPrototype::s_info = { "TestExceptionPrototype", &Base::s_info, &JSTestExceptionPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestExceptionPrototype) };
85
86 JSObject* JSTestExceptionPrototype::self(ExecState* exec, JSGlobalObject* globalObject)
87 {
88     return getDOMPrototype<JSTestException>(exec, globalObject);
89 }
90
91 const ClassInfo JSTestException::s_info = { "TestException", &Base::s_info, &JSTestExceptionTable, 0 , CREATE_METHOD_TABLE(JSTestException) };
92
93 JSTestException::JSTestException(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestException> impl)
94     : JSDOMWrapper(structure, globalObject)
95     , m_impl(impl.leakRef())
96 {
97 }
98
99 void JSTestException::finishCreation(VM& vm)
100 {
101     Base::finishCreation(vm);
102     ASSERT(inherits(info()));
103 }
104
105 JSObject* JSTestException::createPrototype(ExecState* exec, JSGlobalObject* globalObject)
106 {
107     return JSTestExceptionPrototype::create(exec->vm(), globalObject, JSTestExceptionPrototype::createStructure(globalObject->vm(), globalObject, globalObject->errorPrototype()));
108 }
109
110 void JSTestException::destroy(JSC::JSCell* cell)
111 {
112     JSTestException* thisObject = static_cast<JSTestException*>(cell);
113     thisObject->JSTestException::~JSTestException();
114 }
115
116 JSTestException::~JSTestException()
117 {
118     releaseImplIfNotNull();
119 }
120
121 bool JSTestException::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
122 {
123     JSTestException* thisObject = jsCast<JSTestException*>(object);
124     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
125     return getStaticValueSlot<JSTestException, Base>(exec, &JSTestExceptionTable, thisObject, propertyName, slot);
126 }
127
128 bool JSTestException::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
129 {
130     JSTestException* thisObject = jsCast<JSTestException*>(object);
131     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
132     return getStaticValueDescriptor<JSTestException, Base>(exec, &JSTestExceptionTable, thisObject, propertyName, descriptor);
133 }
134
135 JSValue jsTestExceptionName(ExecState* exec, JSValue slotBase, PropertyName)
136 {
137     JSTestException* castedThis = jsCast<JSTestException*>(asObject(slotBase));
138     UNUSED_PARAM(exec);
139     TestException* impl = static_cast<TestException*>(castedThis->impl());
140     JSValue result = jsStringWithCache(exec, impl->name());
141     return result;
142 }
143
144
145 JSValue jsTestExceptionConstructor(ExecState* exec, JSValue slotBase, PropertyName)
146 {
147     JSTestException* domObject = jsCast<JSTestException*>(asObject(slotBase));
148     return JSTestException::getConstructor(exec, domObject->globalObject());
149 }
150
151 JSValue JSTestException::getConstructor(ExecState* exec, JSGlobalObject* globalObject)
152 {
153     return getDOMConstructor<JSTestExceptionConstructor>(exec, jsCast<JSDOMGlobalObject*>(globalObject));
154 }
155
156 static inline bool isObservable(JSTestException* jsTestException)
157 {
158     if (jsTestException->hasCustomProperties())
159         return true;
160     return false;
161 }
162
163 bool JSTestExceptionOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
164 {
165     JSTestException* jsTestException = jsCast<JSTestException*>(handle.get().asCell());
166     if (!isObservable(jsTestException))
167         return false;
168     UNUSED_PARAM(visitor);
169     return false;
170 }
171
172 void JSTestExceptionOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
173 {
174     JSTestException* jsTestException = jsCast<JSTestException*>(handle.get().asCell());
175     DOMWrapperWorld* world = static_cast<DOMWrapperWorld*>(context);
176     uncacheWrapper(world, jsTestException->impl(), jsTestException);
177     jsTestException->releaseImpl();
178 }
179
180 #if ENABLE(BINDING_INTEGRITY)
181 #if PLATFORM(WIN)
182 #pragma warning(disable: 4483)
183 extern "C" { extern void (*const __identifier("??_7TestException@WebCore@@6B@")[])(); }
184 #else
185 extern "C" { extern void* _ZTVN7WebCore13TestExceptionE[]; }
186 #endif
187 #endif
188 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestException* impl)
189 {
190     if (!impl)
191         return jsNull();
192     if (JSValue result = getExistingWrapper<JSTestException>(exec, impl))
193         return result;
194
195 #if ENABLE(BINDING_INTEGRITY)
196     void* actualVTablePointer = *(reinterpret_cast<void**>(impl));
197 #if PLATFORM(WIN)
198     void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7TestException@WebCore@@6B@"));
199 #else
200     void* expectedVTablePointer = &_ZTVN7WebCore13TestExceptionE[2];
201 #if COMPILER(CLANG)
202     // If this fails TestException does not have a vtable, so you need to add the
203     // ImplementationLacksVTable attribute to the interface definition
204     COMPILE_ASSERT(__is_polymorphic(TestException), TestException_is_not_polymorphic);
205 #endif
206 #endif
207     // If you hit this assertion you either have a use after free bug, or
208     // TestException has subclasses. If TestException has subclasses that get passed
209     // to toJS() we currently require TestException you to opt out of binding hardening
210     // by adding the SkipVTableValidation attribute to the interface IDL definition
211     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
212 #endif
213     ReportMemoryCost<TestException>::reportMemoryCost(exec, impl);
214     return createNewWrapper<JSTestException>(exec, globalObject, impl);
215 }
216
217 TestException* toTestException(JSC::JSValue value)
218 {
219     return value.inherits(JSTestException::info()) ? jsCast<JSTestException*>(asObject(value))->impl() : 0;
220 }
221
222 }