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 | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
  56 #endif
  57 #if ENABLE(Condition22) || ENABLE(Condition23)
  58     { "implementsStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr2) },
  59 #endif
  60 #if ENABLE(Condition22) || ENABLE(Condition23)
  61     { "implementsStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr3) },
  62 #endif
  63 #if ENABLE(Condition22) || ENABLE(Condition23)
  64     { "implementsNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsNode) },
  65 #endif
  66 #if ENABLE(Condition11) || ENABLE(Condition12)
  67     { "supplementalStr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
  68 #endif
  69 #if ENABLE(Condition11) || ENABLE(Condition12)
  70     { "supplementalStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr2) },
  71 #endif
  72 #if ENABLE(Condition11) || ENABLE(Condition12)
  73     { "supplementalStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr3) },
  74 #endif
  75 #if ENABLE(Condition11) || ENABLE(Condition12)
  76     { "supplementalNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalNode) },
  77 #endif
  78     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
  79     { 0, 0, NoIntrinsic, 0, 0 }
  80 };
  81
  82 static const HashTable JSTestInterfaceTable = { 33, 31, true, 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) static_cast<PutPropertySlot::PutValueFunc>(0) },
  89 #endif
  90 #if ENABLE(Condition22) || ENABLE(Condition23)
  91     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
  92 #endif
  93 #if ENABLE(Condition11) || ENABLE(Condition12)
  94     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
  95 #endif
  96 #if ENABLE(Condition11) || ENABLE(Condition12)
  97     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
  98 #endif
  99 #if ENABLE(Condition22) || ENABLE(Condition23)
 100     { "implementsStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
 101 #endif
 102 #if ENABLE(Condition22) || ENABLE(Condition23)
 103     { "implementsStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceConstructorImplementsStaticAttr) },
 104 #endif
 105 #if ENABLE(Condition11) || ENABLE(Condition12)
 106     { "supplementalStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
 107 #endif
 108 #if ENABLE(Condition11) || ENABLE(Condition12)
 109     { "supplementalStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(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, true, 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) static_cast<PutPropertySlot::PutValueFunc>(0) },
 192 #endif
 193 #if ENABLE(Condition22) || ENABLE(Condition23)
 194     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
 195 #endif
 196 #if ENABLE(Condition11) || ENABLE(Condition12)
 197     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
 198 #endif
 199 #if ENABLE(Condition11) || ENABLE(Condition12)
 200     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(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, true, 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 EncodedJSValue jsTestInterfaceConstructorImplementsStaticReadOnlyAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 276 {
 277     UNUSED_PARAM(thisValue);
 278     UNUSED_PARAM(slotBase);
 279     UNUSED_PARAM(exec);
 280     JSValue result = jsNumber(TestInterface::implementsStaticReadOnlyAttr());
 281     return JSValue::encode(result);
 282 }
 283
 284 #endif
 285
 286 #if ENABLE(Condition22) || ENABLE(Condition23)
 287 EncodedJSValue jsTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 288 {
 289     UNUSED_PARAM(thisValue);
 290     UNUSED_PARAM(slotBase);
 291     UNUSED_PARAM(exec);
 292     JSValue result = jsStringWithCache(exec, TestInterface::implementsStaticAttr());
 293     return JSValue::encode(result);
 294 }
 295
 296 #endif
 297
 298 #if ENABLE(Condition22) || ENABLE(Condition23)
 299 EncodedJSValue jsTestInterfaceImplementsStr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 300 {
 301     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 302     UNUSED_PARAM(slotBase);
 303     if (!castedThis)
 304         return throwVMTypeError(exec);
 305     UNUSED_PARAM(exec);
 306     TestInterface& impl = castedThis->impl();
 307     JSValue result = jsStringWithCache(exec, impl.implementsStr1());
 308     return JSValue::encode(result);
 309 }
 310
 311 #endif
 312
 313 #if ENABLE(Condition22) || ENABLE(Condition23)
 314 EncodedJSValue jsTestInterfaceImplementsStr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 315 {
 316     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 317     UNUSED_PARAM(slotBase);
 318     if (!castedThis)
 319         return throwVMTypeError(exec);
 320     UNUSED_PARAM(exec);
 321     TestInterface& impl = castedThis->impl();
 322     JSValue result = jsStringWithCache(exec, impl.implementsStr2());
 323     return JSValue::encode(result);
 324 }
 325
 326 #endif
 327
 328 #if ENABLE(Condition22) || ENABLE(Condition23)
 329 EncodedJSValue jsTestInterfaceImplementsStr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 330 {
 331     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 332     UNUSED_PARAM(slotBase);
 333     if (!castedThis)
 334         return throwVMTypeError(exec);
 335     return JSValue::encode(castedThis->implementsStr3(exec));
 336 }
 337
 338 #endif
 339
 340 #if ENABLE(Condition22) || ENABLE(Condition23)
 341 EncodedJSValue jsTestInterfaceImplementsNode(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 342 {
 343     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 344     UNUSED_PARAM(slotBase);
 345     if (!castedThis)
 346         return throwVMTypeError(exec);
 347     UNUSED_PARAM(exec);
 348     TestInterface& impl = castedThis->impl();
 349     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsNode()));
 350     return JSValue::encode(result);
 351 }
 352
 353 #endif
 354
 355 #if ENABLE(Condition11) || ENABLE(Condition12)
 356 EncodedJSValue jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 357 {
 358     UNUSED_PARAM(thisValue);
 359     UNUSED_PARAM(slotBase);
 360     UNUSED_PARAM(exec);
 361     JSValue result = jsNumber(TestSupplemental::supplementalStaticReadOnlyAttr());
 362     return JSValue::encode(result);
 363 }
 364
 365 #endif
 366
 367 #if ENABLE(Condition11) || ENABLE(Condition12)
 368 EncodedJSValue jsTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 369 {
 370     UNUSED_PARAM(thisValue);
 371     UNUSED_PARAM(slotBase);
 372     UNUSED_PARAM(exec);
 373     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStaticAttr());
 374     return JSValue::encode(result);
 375 }
 376
 377 #endif
 378
 379 #if ENABLE(Condition11) || ENABLE(Condition12)
 380 EncodedJSValue jsTestInterfaceSupplementalStr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 381 {
 382     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 383     UNUSED_PARAM(slotBase);
 384     if (!castedThis)
 385         return throwVMTypeError(exec);
 386     UNUSED_PARAM(exec);
 387     TestInterface& impl = castedThis->impl();
 388     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr1(&impl));
 389     return JSValue::encode(result);
 390 }
 391
 392 #endif
 393
 394 #if ENABLE(Condition11) || ENABLE(Condition12)
 395 EncodedJSValue jsTestInterfaceSupplementalStr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 396 {
 397     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 398     UNUSED_PARAM(slotBase);
 399     if (!castedThis)
 400         return throwVMTypeError(exec);
 401     UNUSED_PARAM(exec);
 402     TestInterface& impl = castedThis->impl();
 403     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr2(&impl));
 404     return JSValue::encode(result);
 405 }
 406
 407 #endif
 408
 409 #if ENABLE(Condition11) || ENABLE(Condition12)
 410 EncodedJSValue jsTestInterfaceSupplementalStr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 411 {
 412     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 413     UNUSED_PARAM(slotBase);
 414     if (!castedThis)
 415         return throwVMTypeError(exec);
 416     return JSValue::encode(castedThis->supplementalStr3(exec));
 417 }
 418
 419 #endif
 420
 421 #if ENABLE(Condition11) || ENABLE(Condition12)
 422 EncodedJSValue jsTestInterfaceSupplementalNode(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
 423 {
 424     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 425     UNUSED_PARAM(slotBase);
 426     if (!castedThis)
 427         return throwVMTypeError(exec);
 428     UNUSED_PARAM(exec);
 429     TestInterface& impl = castedThis->impl();
 430     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalNode(&impl)));
 431     return JSValue::encode(result);
 432 }
 433
 434 #endif
 435
 436 EncodedJSValue jsTestInterfaceConstructor(ExecState* exec, JSObject*, EncodedJSValue thisValue, PropertyName)
 437 {
 438     JSTestInterface* domObject = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 439     if (!domObject)
 440         return throwVMTypeError(exec);
 441     return JSValue::encode(JSTestInterface::getConstructor(exec->vm(), domObject->globalObject()));
 442 }
 443
 444 void JSTestInterface::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
 445 {
 446     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
 447     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
 448     if (thisObject->putDelegate(exec, propertyName, value, slot))
 449         return;
 450     Base::put(thisObject, exec, propertyName, value, slot);
 451 }
 452
 453 void JSTestInterface::putByIndex(JSCell* cell, ExecState* exec, unsigned index, JSValue value, bool shouldThrow)
 454 {
 455     JSTestInterface* thisObject = jsCast<JSTestInterface*>(cell);
 456     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
 457     PropertyName propertyName = Identifier::from(exec, index);
 458     PutPropertySlot slot(thisObject, shouldThrow);
 459     if (thisObject->putDelegate(exec, propertyName, value, slot))
 460         return;
 461     Base::putByIndex(cell, exec, index, value, shouldThrow);
 462 }
 463
 464 #if ENABLE(Condition22) || ENABLE(Condition23)
 465 void setJSTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue, EncodedJSValue encodedValue)
 466 {
 467     JSValue value = JSValue::decode(encodedValue);
 468     UNUSED_PARAM(exec);
 469     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
 470     if (exec->hadException())
 471         return;
 472     TestInterface::setImplementsStaticAttr(nativeValue);
 473 }
 474
 475 #endif
 476
 477 #if ENABLE(Condition22) || ENABLE(Condition23)
 478 void setJSTestInterfaceImplementsStr2(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
 479 {
 480     JSValue value = JSValue::decode(encodedValue);
 481     UNUSED_PARAM(exec);
 482     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 483     if (!castedThis) {
 484         throwVMTypeError(exec);
 485         return;
 486     }
 487     TestInterface& impl = castedThis->impl();
 488     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
 489     if (exec->hadException())
 490         return;
 491     impl.setImplementsStr2(nativeValue);
 492 }
 493
 494 #endif
 495
 496 #if ENABLE(Condition22) || ENABLE(Condition23)
 497 void setJSTestInterfaceImplementsStr3(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
 498 {
 499     JSValue value = JSValue::decode(encodedValue);
 500     UNUSED_PARAM(exec);
 501     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 502     if (!castedThis) {
 503         throwVMTypeError(exec);
 504         return;
 505     }
 506     castedThis->setImplementsStr3(exec, value);
 507 }
 508
 509 #endif
 510
 511 #if ENABLE(Condition22) || ENABLE(Condition23)
 512 void setJSTestInterfaceImplementsNode(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
 513 {
 514     JSValue value = JSValue::decode(encodedValue);
 515     UNUSED_PARAM(exec);
 516     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 517     if (!castedThis) {
 518         throwVMTypeError(exec);
 519         return;
 520     }
 521     TestInterface& impl = castedThis->impl();
 522     Node* nativeValue(toNode(value));
 523     if (exec->hadException())
 524         return;
 525     impl.setImplementsNode(nativeValue);
 526 }
 527
 528 #endif
 529
 530 #if ENABLE(Condition11) || ENABLE(Condition12)
 531 void setJSTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue, EncodedJSValue encodedValue)
 532 {
 533     JSValue value = JSValue::decode(encodedValue);
 534     UNUSED_PARAM(exec);
 535     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
 536     if (exec->hadException())
 537         return;
 538     TestSupplemental::setSupplementalStaticAttr(nativeValue);
 539 }
 540
 541 #endif
 542
 543 #if ENABLE(Condition11) || ENABLE(Condition12)
 544 void setJSTestInterfaceSupplementalStr2(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
 545 {
 546     JSValue value = JSValue::decode(encodedValue);
 547     UNUSED_PARAM(exec);
 548     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 549     if (!castedThis) {
 550         throwVMTypeError(exec);
 551         return;
 552     }
 553     TestInterface& impl = castedThis->impl();
 554     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
 555     if (exec->hadException())
 556         return;
 557     TestSupplemental::setSupplementalStr2(&impl, nativeValue);
 558 }
 559
 560 #endif
 561
 562 #if ENABLE(Condition11) || ENABLE(Condition12)
 563 void setJSTestInterfaceSupplementalStr3(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
 564 {
 565     JSValue value = JSValue::decode(encodedValue);
 566     UNUSED_PARAM(exec);
 567     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 568     if (!castedThis) {
 569         throwVMTypeError(exec);
 570         return;
 571     }
 572     castedThis->setSupplementalStr3(exec, value);
 573 }
 574
 575 #endif
 576
 577 #if ENABLE(Condition11) || ENABLE(Condition12)
 578 void setJSTestInterfaceSupplementalNode(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
 579 {
 580     JSValue value = JSValue::decode(encodedValue);
 581     UNUSED_PARAM(exec);
 582     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
 583     if (!castedThis) {
 584         throwVMTypeError(exec);
 585         return;
 586     }
 587     TestInterface& impl = castedThis->impl();
 588     Node* nativeValue(toNode(value));
 589     if (exec->hadException())
 590         return;
 591     TestSupplemental::setSupplementalNode(&impl, nativeValue);
 592 }
 593
 594 #endif
 595
 596 JSValue JSTestInterface::getConstructor(VM& vm, JSGlobalObject* globalObject)
 597 {
 598     return getDOMConstructor<JSTestInterfaceConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
 599 }
 600
 601 #if ENABLE(Condition22) || ENABLE(Condition23)
 602 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod1(ExecState* exec)
 603 {
 604     JSValue thisValue = exec->hostThisValue();
 605     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
 606     if (!castedThis)
 607         return throwVMTypeError(exec);
 608     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
 609     TestInterface& impl = castedThis->impl();
 610     impl.implementsMethod1();
 611     return JSValue::encode(jsUndefined());
 612 }
 613
 614 #endif
 615
 616 #if ENABLE(Condition22) || ENABLE(Condition23)
 617 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod2(ExecState* exec)
 618 {
 619     JSValue thisValue = exec->hostThisValue();
 620     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
 621     if (!castedThis)
 622         return throwVMTypeError(exec);
 623     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
 624     TestInterface& impl = castedThis->impl();
 625     if (exec->argumentCount() < 2)
 626         return throwVMError(exec, createNotEnoughArgumentsError(exec));
 627     ExceptionCode ec = 0;
 628     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
 629     if (!scriptContext)
 630         return JSValue::encode(jsUndefined());
 631     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
 632     if (exec->hadException())
 633         return JSValue::encode(jsUndefined());
 634     TestObj* objArg(toTestObj(exec->argument(1)));
 635     if (exec->hadException())
 636         return JSValue::encode(jsUndefined());
 637
 638     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsMethod2(scriptContext, strArg, objArg, ec)));
 639     setDOMException(exec, ec);
 640     return JSValue::encode(result);
 641 }
 642
 643 #endif
 644
 645 #if ENABLE(Condition22) || ENABLE(Condition23)
 646 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod3(ExecState* exec)
 647 {
 648     JSValue thisValue = exec->hostThisValue();
 649     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
 650     if (!castedThis)
 651         return throwVMTypeError(exec);
 652     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
 653     return JSValue::encode(castedThis->implementsMethod3(exec));
 654 }
 655
 656 #endif
 657
 658 #if ENABLE(Condition22) || ENABLE(Condition23)
 659 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionImplementsMethod4(ExecState* exec)
 660 {
 661     TestInterface::implementsMethod4();
 662     return JSValue::encode(jsUndefined());
 663 }
 664
 665 #endif
 666
 667 #if ENABLE(Condition11) || ENABLE(Condition12)
 668 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod1(ExecState* exec)
 669 {
 670     JSValue thisValue = exec->hostThisValue();
 671     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
 672     if (!castedThis)
 673         return throwVMTypeError(exec);
 674     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
 675     TestInterface& impl = castedThis->impl();
 676     TestSupplemental::supplementalMethod1(&impl);
 677     return JSValue::encode(jsUndefined());
 678 }
 679
 680 #endif
 681
 682 #if ENABLE(Condition11) || ENABLE(Condition12)
 683 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod2(ExecState* exec)
 684 {
 685     JSValue thisValue = exec->hostThisValue();
 686     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
 687     if (!castedThis)
 688         return throwVMTypeError(exec);
 689     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
 690     TestInterface& impl = castedThis->impl();
 691     if (exec->argumentCount() < 2)
 692         return throwVMError(exec, createNotEnoughArgumentsError(exec));
 693     ExceptionCode ec = 0;
 694     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
 695     if (!scriptContext)
 696         return JSValue::encode(jsUndefined());
 697     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
 698     if (exec->hadException())
 699         return JSValue::encode(jsUndefined());
 700     TestObj* objArg(toTestObj(exec->argument(1)));
 701     if (exec->hadException())
 702         return JSValue::encode(jsUndefined());
 703
 704     JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalMethod2(&impl, scriptContext, strArg, objArg, ec)));
 705     setDOMException(exec, ec);
 706     return JSValue::encode(result);
 707 }
 708
 709 #endif
 710
 711 #if ENABLE(Condition11) || ENABLE(Condition12)
 712 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod3(ExecState* exec)
 713 {
 714     JSValue thisValue = exec->hostThisValue();
 715     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
 716     if (!castedThis)
 717         return throwVMTypeError(exec);
 718     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
 719     return JSValue::encode(castedThis->supplementalMethod3(exec));
 720 }
 721
 722 #endif
 723
 724 #if ENABLE(Condition11) || ENABLE(Condition12)
 725 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionSupplementalMethod4(ExecState* exec)
 726 {
 727     TestSupplemental::supplementalMethod4();
 728     return JSValue::encode(jsUndefined());
 729 }
 730
 731 #endif
 732
 733 // Constant getters
 734
 735 #if ENABLE(Condition22) || ENABLE(Condition23)
 736 EncodedJSValue jsTestInterfaceIMPLEMENTSCONSTANT1(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
 737 {
 738     UNUSED_PARAM(exec);
 739     return JSValue::encode(jsNumber(static_cast<int>(1)));
 740 }
 741
 742 #endif
 743 #if ENABLE(Condition22) || ENABLE(Condition23)
 744 EncodedJSValue jsTestInterfaceIMPLEMENTSCONSTANT2(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
 745 {
 746     UNUSED_PARAM(exec);
 747     return JSValue::encode(jsNumber(static_cast<int>(2)));
 748 }
 749
 750 #endif
 751 #if ENABLE(Condition11) || ENABLE(Condition12)
 752 EncodedJSValue jsTestInterfaceSUPPLEMENTALCONSTANT1(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
 753 {
 754     UNUSED_PARAM(exec);
 755     return JSValue::encode(jsNumber(static_cast<int>(1)));
 756 }
 757
 758 #endif
 759 #if ENABLE(Condition11) || ENABLE(Condition12)
 760 EncodedJSValue jsTestInterfaceSUPPLEMENTALCONSTANT2(ExecState* exec, JSObject*, EncodedJSValue, PropertyName)
 761 {
 762     UNUSED_PARAM(exec);
 763     return JSValue::encode(jsNumber(static_cast<int>(2)));
 764 }
 765
 766 #endif
 767 bool JSTestInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 768 {
 769     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.get().asCell());
 770     if (jsTestInterface->impl().hasPendingActivity())
 771         return true;
 772     UNUSED_PARAM(visitor);
 773     return false;
 774 }
 775
 776 void JSTestInterfaceOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
 777 {
 778     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.get().asCell());
 779     DOMWrapperWorld& world = *static_cast<DOMWrapperWorld*>(context);
 780     uncacheWrapper(world, &jsTestInterface->impl(), jsTestInterface);
 781     jsTestInterface->releaseImpl();
 782 }
 783
 784 JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestInterface* impl)
 785 {
 786     if (!impl)
 787         return jsNull();
 788     if (JSValue result = getExistingWrapper<JSTestInterface>(exec, impl))
 789         return result;
 790 #if COMPILER(CLANG)
 791     // If you hit this failure the interface definition has the ImplementationLacksVTable
 792     // attribute. You should remove that attribute. If the class has subclasses
 793     // that may be passed through this toJS() function you should use the SkipVTableValidation
 794     // attribute to TestInterface.
 795     COMPILE_ASSERT(!__is_polymorphic(TestInterface), TestInterface_is_polymorphic_but_idl_claims_not_to_be);
 796 #endif
 797     ReportMemoryCost<TestInterface>::reportMemoryCost(exec, impl);
 798     return createNewWrapper<JSTestInterface>(exec, globalObject, impl);
 799 }
 800
 801 TestInterface* toTestInterface(JSC::JSValue value)
 802 {
 803     return value.inherits(JSTestInterface::info()) ? &jsCast<JSTestInterface*>(value)->impl() : 0;
 804 }
 805
 806 }
 807
 808 #endif // ENABLE(Condition1) || ENABLE(Condition2)