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 }