Constructors should eagerly reify their properties too
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestObj.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 "JSTestObj.h"
23
24 #include "CallbackFunction.h"
25 #include "DOMStringList.h"
26 #include "Dictionary.h"
27 #include "Document.h"
28 #include "ExceptionCode.h"
29 #include "Frame.h"
30 #include "HTMLNames.h"
31 #include "JSDOMBinding.h"
32 #include "JSDOMStringList.h"
33 #include "JSDocument.h"
34 #include "JSEventListener.h"
35 #include "JSNode.h"
36 #include "JSSVGDocument.h"
37 #include "JSSVGPoint.h"
38 #include "JSScriptProfile.h"
39 #include "JSTestCallback.h"
40 #include "JSTestNode.h"
41 #include "JSTestObj.h"
42 #include "JSTestSubObj.h"
43 #include "JSbool.h"
44 #include "SVGDocument.h"
45 #include "SVGPoint.h"
46 #include "SVGStaticPropertyTearOff.h"
47 #include "ScriptExecutionContext.h"
48 #include "ScriptProfile.h"
49 #include "SerializedScriptValue.h"
50 #include "Settings.h"
51 #include "TestObj.h"
52 #include "URL.h"
53 #include "bool.h"
54 #include <inspector/ScriptArguments.h>
55 #include <inspector/ScriptCallStackFactory.h>
56 #include <runtime/Error.h>
57 #include <runtime/JSArray.h>
58 #include <runtime/JSString.h>
59 #include <wtf/GetPtr.h>
60
61 #if ENABLE(Condition1)
62 #include "JSTestObjectA.h"
63 #endif
64
65 #if ENABLE(Condition1) && ENABLE(Condition2)
66 #include "JSTestObjectB.h"
67 #endif
68
69 #if ENABLE(Condition1) || ENABLE(Condition2)
70 #include "JSTestObjectC.h"
71 #endif
72
73 using namespace JSC;
74
75 namespace WebCore {
76
77 /* Hash table */
78
79 static const struct CompactHashIndex JSTestObjTableIndex[17] = {
80     { 5, -1 },
81     { -1, -1 },
82     { -1, -1 },
83     { -1, -1 },
84     { -1, -1 },
85     { -1, -1 },
86     { 4, -1 },
87     { -1, -1 },
88     { -1, -1 },
89     { 2, -1 },
90     { 0, 16 },
91     { -1, -1 },
92     { 1, -1 },
93     { -1, -1 },
94     { -1, -1 },
95     { -1, -1 },
96     { 3, -1 },
97 };
98
99
100 static const HashTableValue JSTestObjTableValues[] =
101 {
102     { "TestSubObjEnabledBySetting", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestSubObjEnabledBySettingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestSubObjEnabledBySettingConstructor) },
103     { "customAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCustomAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjCustomAttr) },
104 #if ENABLE(Condition1)
105     { "conditionalAttr4", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr4Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr4Constructor) },
106 #else
107     { 0, 0, NoIntrinsic, 0, 0 },
108 #endif
109 #if ENABLE(Condition1) && ENABLE(Condition2)
110     { "conditionalAttr5", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr5Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr5Constructor) },
111 #else
112     { 0, 0, NoIntrinsic, 0, 0 },
113 #endif
114 #if ENABLE(Condition1) || ENABLE(Condition2)
115     { "conditionalAttr6", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr6Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr6Constructor) },
116 #else
117     { 0, 0, NoIntrinsic, 0, 0 },
118 #endif
119     { "contentDocument", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjContentDocument), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
120 };
121
122 static const HashTable JSTestObjTable = { 6, 15, true, JSTestObjTableValues, 0, JSTestObjTableIndex };
123 /* Hash table for constructor */
124
125 static const struct CompactHashIndex JSTestObjConstructorTableIndex[39] = {
126     { -1, -1 },
127     { 9, 34 },
128     { 21, -1 },
129     { 2, -1 },
130     { 1, -1 },
131     { -1, -1 },
132     { -1, -1 },
133     { -1, -1 },
134     { -1, -1 },
135     { 0, -1 },
136     { 12, -1 },
137     { 16, -1 },
138     { 5, 32 },
139     { -1, -1 },
140     { -1, -1 },
141     { -1, -1 },
142     { -1, -1 },
143     { -1, -1 },
144     { -1, -1 },
145     { 10, -1 },
146     { 7, 36 },
147     { 15, -1 },
148     { 3, -1 },
149     { -1, -1 },
150     { 11, 33 },
151     { -1, -1 },
152     { -1, -1 },
153     { 8, 37 },
154     { 18, -1 },
155     { -1, -1 },
156     { -1, -1 },
157     { 4, -1 },
158     { 6, -1 },
159     { 13, -1 },
160     { 14, 35 },
161     { 17, -1 },
162     { 19, 38 },
163     { 20, -1 },
164     { 22, -1 },
165 };
166
167
168 static const HashTableValue JSTestObjConstructorTableValues[] =
169 {
170 #if ENABLE(Condition1)
171     { "CONDITIONAL_CONST", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONDITIONAL_CONST), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
172 #else
173     { 0, 0, NoIntrinsic, 0, 0 },
174 #endif
175     { "CONST_VALUE_0", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_0), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
176     { "CONST_VALUE_1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
177     { "CONST_VALUE_2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
178     { "CONST_VALUE_4", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_4), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
179     { "CONST_VALUE_8", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_8), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
180     { "CONST_VALUE_9", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_9), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
181     { "CONST_VALUE_10", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_10), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
182     { "CONST_VALUE_11", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_11), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
183     { "CONST_VALUE_12", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_12), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
184     { "CONST_VALUE_13", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_13), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
185     { "CONST_VALUE_14", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_14), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
186     { "CONST_JAVASCRIPT", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_JAVASCRIPT), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
187     { "readonly", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadonly), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
188     { "staticReadOnlyLongAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorStaticReadOnlyLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
189     { "staticStringAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorStaticStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConstructorStaticStringAttr) },
190     { "TestSubObj", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorTestSubObj), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
191     { "staticMethodWithCallbackAndOptionalArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionStaticMethodWithCallbackAndOptionalArg), (intptr_t) (0) },
192     { "staticMethodWithCallbackArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionStaticMethodWithCallbackArg), (intptr_t) (1) },
193     { "classMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethod), (intptr_t) (0) },
194     { "classMethodWithOptional", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethodWithOptional), (intptr_t) (0) },
195     { "classMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethod2), (intptr_t) (1) },
196 #if ENABLE(Condition1)
197     { "overloadedMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionOverloadedMethod1), (intptr_t) (1) },
198 #else
199     { 0, 0, NoIntrinsic, 0, 0 },
200 #endif
201 };
202
203 static const HashTable JSTestObjConstructorTable = { 23, 31, true, JSTestObjConstructorTableValues, 0, JSTestObjConstructorTableIndex };
204
205 #if ENABLE(Condition1)
206 COMPILE_ASSERT(0 == TestObj::CONDITIONAL_CONST, TestObjEnumCONDITIONAL_CONSTIsWrongUseDoNotCheckConstants);
207 #endif
208 COMPILE_ASSERT(0 == TestObj::CONST_VALUE_0, TestObjEnumCONST_VALUE_0IsWrongUseDoNotCheckConstants);
209 COMPILE_ASSERT(1 == TestObj::CONST_VALUE_1, TestObjEnumCONST_VALUE_1IsWrongUseDoNotCheckConstants);
210 COMPILE_ASSERT(2 == TestObj::CONST_VALUE_2, TestObjEnumCONST_VALUE_2IsWrongUseDoNotCheckConstants);
211 COMPILE_ASSERT(4 == TestObj::CONST_VALUE_4, TestObjEnumCONST_VALUE_4IsWrongUseDoNotCheckConstants);
212 COMPILE_ASSERT(8 == TestObj::CONST_VALUE_8, TestObjEnumCONST_VALUE_8IsWrongUseDoNotCheckConstants);
213 COMPILE_ASSERT(-1 == TestObj::CONST_VALUE_9, TestObjEnumCONST_VALUE_9IsWrongUseDoNotCheckConstants);
214 COMPILE_ASSERT("my constant string" == TestObj::CONST_VALUE_10, TestObjEnumCONST_VALUE_10IsWrongUseDoNotCheckConstants);
215 COMPILE_ASSERT(0xffffffff == TestObj::CONST_VALUE_11, TestObjEnumCONST_VALUE_11IsWrongUseDoNotCheckConstants);
216 COMPILE_ASSERT(0x01 == TestObj::CONST_VALUE_12, TestObjEnumCONST_VALUE_12IsWrongUseDoNotCheckConstants);
217 COMPILE_ASSERT(0X20 == TestObj::CONST_VALUE_13, TestObjEnumCONST_VALUE_13IsWrongUseDoNotCheckConstants);
218 COMPILE_ASSERT(0x1abc == TestObj::CONST_VALUE_14, TestObjEnumCONST_VALUE_14IsWrongUseDoNotCheckConstants);
219 COMPILE_ASSERT(15 == TestObj::CONST_IMPL, TestObjEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
220 COMPILE_ASSERT(0 == TestObj::readonly, TestObjEnumreadonlyIsWrongUseDoNotCheckConstants);
221
222 EncodedJSValue JSC_HOST_CALL JSTestObjConstructor::constructJSTestObj(ExecState* exec)
223 {
224     JSTestObjConstructor* castedThis = jsCast<JSTestObjConstructor*>(exec->callee());
225     if (exec->argumentCount() < 1)
226         return throwVMError(exec, createNotEnoughArgumentsError(exec));
227     if (!exec->argument(0).isFunction())
228         return throwArgumentMustBeFunctionError(*exec, 0, "testCallback", "TestObj", nullptr);
229     RefPtr<TestCallback> testCallback = JSTestCallback::create(asObject(exec->uncheckedArgument(0)), castedThis->globalObject());
230     RefPtr<TestObj> object = TestObj::create(testCallback);
231     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
232 }
233
234 const ClassInfo JSTestObjConstructor::s_info = { "TestObjectConstructor", &Base::s_info, &JSTestObjConstructorTable, 0, CREATE_METHOD_TABLE(JSTestObjConstructor) };
235
236 JSTestObjConstructor::JSTestObjConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
237     : DOMConstructorObject(structure, globalObject)
238 {
239 }
240
241 void JSTestObjConstructor::finishCreation(VM& vm, JSDOMGlobalObject* globalObject)
242 {
243     Base::finishCreation(vm);
244     ASSERT(inherits(info()));
245     putDirect(vm, vm.propertyNames->prototype, JSTestObjPrototype::self(vm, globalObject), DontDelete | ReadOnly);
246     putDirect(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontDelete | DontEnum);
247     reifyStaticProperties(vm, JSTestObjConstructorTableValues, *this);
248 }
249
250 ConstructType JSTestObjConstructor::getConstructData(JSCell*, ConstructData& constructData)
251 {
252     constructData.native.function = constructJSTestObj;
253     return ConstructTypeHost;
254 }
255
256 /* Hash table for prototype */
257
258 static const struct CompactHashIndex JSTestObjPrototypeTableIndex[530] = {
259     { -1, -1 },
260     { -1, -1 },
261     { -1, -1 },
262     { -1, -1 },
263     { -1, -1 },
264     { 23, -1 },
265     { -1, -1 },
266     { -1, -1 },
267     { -1, -1 },
268     { -1, -1 },
269     { -1, -1 },
270     { -1, -1 },
271     { -1, -1 },
272     { 49, -1 },
273     { -1, -1 },
274     { -1, -1 },
275     { -1, -1 },
276     { 16, 513 },
277     { -1, -1 },
278     { -1, -1 },
279     { -1, -1 },
280     { -1, -1 },
281     { -1, -1 },
282     { 47, -1 },
283     { 73, -1 },
284     { -1, -1 },
285     { 41, -1 },
286     { -1, -1 },
287     { -1, -1 },
288     { -1, -1 },
289     { -1, -1 },
290     { -1, -1 },
291     { -1, -1 },
292     { -1, -1 },
293     { -1, -1 },
294     { -1, -1 },
295     { 102, -1 },
296     { -1, -1 },
297     { -1, -1 },
298     { -1, -1 },
299     { -1, -1 },
300     { 15, -1 },
301     { -1, -1 },
302     { -1, -1 },
303     { -1, -1 },
304     { 110, -1 },
305     { -1, -1 },
306     { -1, -1 },
307     { -1, -1 },
308     { -1, -1 },
309     { -1, -1 },
310     { -1, -1 },
311     { -1, -1 },
312     { -1, -1 },
313     { -1, -1 },
314     { 27, 522 },
315     { -1, -1 },
316     { -1, -1 },
317     { -1, -1 },
318     { -1, -1 },
319     { -1, -1 },
320     { -1, -1 },
321     { 126, -1 },
322     { -1, -1 },
323     { -1, -1 },
324     { -1, -1 },
325     { 101, -1 },
326     { 100, -1 },
327     { -1, -1 },
328     { -1, -1 },
329     { -1, -1 },
330     { -1, -1 },
331     { -1, -1 },
332     { 4, -1 },
333     { -1, -1 },
334     { 17, -1 },
335     { -1, -1 },
336     { -1, -1 },
337     { -1, -1 },
338     { 5, -1 },
339     { 134, -1 },
340     { -1, -1 },
341     { -1, -1 },
342     { -1, -1 },
343     { -1, -1 },
344     { 53, -1 },
345     { 32, 517 },
346     { -1, -1 },
347     { -1, -1 },
348     { -1, -1 },
349     { -1, -1 },
350     { -1, -1 },
351     { -1, -1 },
352     { -1, -1 },
353     { 93, -1 },
354     { 87, -1 },
355     { -1, -1 },
356     { -1, -1 },
357     { -1, -1 },
358     { 31, -1 },
359     { -1, -1 },
360     { 55, -1 },
361     { -1, -1 },
362     { -1, -1 },
363     { -1, -1 },
364     { -1, -1 },
365     { -1, -1 },
366     { -1, -1 },
367     { -1, -1 },
368     { -1, -1 },
369     { -1, -1 },
370     { 117, -1 },
371     { -1, -1 },
372     { -1, -1 },
373     { 78, -1 },
374     { 70, -1 },
375     { -1, -1 },
376     { 25, -1 },
377     { -1, -1 },
378     { -1, -1 },
379     { 22, -1 },
380     { -1, -1 },
381     { -1, -1 },
382     { -1, -1 },
383     { -1, -1 },
384     { -1, -1 },
385     { -1, -1 },
386     { -1, -1 },
387     { -1, -1 },
388     { 96, -1 },
389     { -1, -1 },
390     { -1, -1 },
391     { -1, -1 },
392     { 114, -1 },
393     { -1, -1 },
394     { 6, -1 },
395     { -1, -1 },
396     { -1, -1 },
397     { -1, -1 },
398     { -1, -1 },
399     { -1, -1 },
400     { -1, -1 },
401     { -1, -1 },
402     { 86, -1 },
403     { -1, -1 },
404     { -1, -1 },
405     { 1, -1 },
406     { -1, -1 },
407     { -1, -1 },
408     { 33, -1 },
409     { 51, -1 },
410     { -1, -1 },
411     { 71, -1 },
412     { -1, -1 },
413     { -1, -1 },
414     { -1, -1 },
415     { -1, -1 },
416     { -1, -1 },
417     { -1, -1 },
418     { 92, -1 },
419     { -1, -1 },
420     { -1, -1 },
421     { -1, -1 },
422     { -1, -1 },
423     { -1, -1 },
424     { 127, -1 },
425     { -1, -1 },
426     { -1, -1 },
427     { -1, -1 },
428     { -1, -1 },
429     { 72, -1 },
430     { -1, -1 },
431     { -1, -1 },
432     { -1, -1 },
433     { -1, -1 },
434     { -1, -1 },
435     { -1, -1 },
436     { -1, -1 },
437     { -1, -1 },
438     { -1, -1 },
439     { 67, -1 },
440     { -1, -1 },
441     { -1, -1 },
442     { -1, -1 },
443     { -1, -1 },
444     { -1, -1 },
445     { -1, -1 },
446     { -1, -1 },
447     { -1, -1 },
448     { 24, -1 },
449     { -1, -1 },
450     { -1, -1 },
451     { -1, -1 },
452     { -1, -1 },
453     { -1, -1 },
454     { -1, -1 },
455     { -1, -1 },
456     { -1, -1 },
457     { -1, -1 },
458     { -1, -1 },
459     { -1, -1 },
460     { -1, -1 },
461     { -1, -1 },
462     { -1, -1 },
463     { 89, -1 },
464     { -1, -1 },
465     { -1, -1 },
466     { -1, -1 },
467     { -1, -1 },
468     { -1, -1 },
469     { -1, -1 },
470     { -1, -1 },
471     { -1, -1 },
472     { -1, -1 },
473     { -1, -1 },
474     { -1, -1 },
475     { -1, -1 },
476     { -1, -1 },
477     { -1, -1 },
478     { -1, -1 },
479     { -1, -1 },
480     { -1, -1 },
481     { -1, -1 },
482     { -1, -1 },
483     { -1, -1 },
484     { 82, -1 },
485     { -1, -1 },
486     { -1, -1 },
487     { -1, -1 },
488     { 3, -1 },
489     { -1, -1 },
490     { -1, -1 },
491     { -1, -1 },
492     { 45, -1 },
493     { -1, -1 },
494     { 77, -1 },
495     { -1, -1 },
496     { -1, -1 },
497     { -1, -1 },
498     { -1, -1 },
499     { -1, -1 },
500     { 36, 526 },
501     { -1, -1 },
502     { -1, -1 },
503     { -1, -1 },
504     { 8, 512 },
505     { -1, -1 },
506     { 130, -1 },
507     { -1, -1 },
508     { 58, 528 },
509     { 135, -1 },
510     { -1, -1 },
511     { -1, -1 },
512     { -1, -1 },
513     { -1, -1 },
514     { 64, 524 },
515     { -1, -1 },
516     { -1, -1 },
517     { -1, -1 },
518     { 131, -1 },
519     { -1, -1 },
520     { 103, -1 },
521     { -1, -1 },
522     { -1, -1 },
523     { -1, -1 },
524     { -1, -1 },
525     { -1, -1 },
526     { -1, -1 },
527     { -1, -1 },
528     { -1, -1 },
529     { -1, -1 },
530     { 39, 515 },
531     { -1, -1 },
532     { -1, -1 },
533     { 113, -1 },
534     { 90, -1 },
535     { 120, -1 },
536     { -1, -1 },
537     { -1, -1 },
538     { -1, -1 },
539     { -1, -1 },
540     { -1, -1 },
541     { -1, -1 },
542     { -1, -1 },
543     { -1, -1 },
544     { 34, -1 },
545     { -1, -1 },
546     { 18, -1 },
547     { -1, -1 },
548     { -1, -1 },
549     { -1, -1 },
550     { -1, -1 },
551     { 61, -1 },
552     { -1, -1 },
553     { -1, -1 },
554     { -1, -1 },
555     { -1, -1 },
556     { -1, -1 },
557     { -1, -1 },
558     { -1, -1 },
559     { -1, -1 },
560     { -1, -1 },
561     { -1, -1 },
562     { -1, -1 },
563     { -1, -1 },
564     { 128, -1 },
565     { 123, -1 },
566     { -1, -1 },
567     { -1, -1 },
568     { -1, -1 },
569     { 26, -1 },
570     { -1, -1 },
571     { -1, -1 },
572     { -1, -1 },
573     { -1, -1 },
574     { 76, -1 },
575     { -1, -1 },
576     { -1, -1 },
577     { -1, -1 },
578     { -1, -1 },
579     { -1, -1 },
580     { -1, -1 },
581     { -1, -1 },
582     { -1, -1 },
583     { 84, -1 },
584     { -1, -1 },
585     { -1, -1 },
586     { -1, -1 },
587     { -1, -1 },
588     { -1, -1 },
589     { 43, -1 },
590     { -1, -1 },
591     { -1, -1 },
592     { -1, -1 },
593     { -1, -1 },
594     { -1, -1 },
595     { -1, -1 },
596     { -1, -1 },
597     { -1, -1 },
598     { -1, -1 },
599     { 12, -1 },
600     { -1, -1 },
601     { 59, -1 },
602     { -1, -1 },
603     { -1, -1 },
604     { 0, -1 },
605     { -1, -1 },
606     { 99, -1 },
607     { -1, -1 },
608     { -1, -1 },
609     { -1, -1 },
610     { -1, -1 },
611     { 30, -1 },
612     { 28, -1 },
613     { -1, -1 },
614     { -1, -1 },
615     { 124, -1 },
616     { -1, -1 },
617     { 35, -1 },
618     { -1, -1 },
619     { -1, -1 },
620     { -1, -1 },
621     { -1, -1 },
622     { -1, -1 },
623     { 65, 518 },
624     { -1, -1 },
625     { -1, -1 },
626     { -1, -1 },
627     { -1, -1 },
628     { -1, -1 },
629     { 88, -1 },
630     { -1, -1 },
631     { -1, -1 },
632     { -1, -1 },
633     { -1, -1 },
634     { -1, -1 },
635     { 46, 521 },
636     { 80, -1 },
637     { -1, -1 },
638     { -1, -1 },
639     { -1, -1 },
640     { 44, -1 },
641     { -1, -1 },
642     { -1, -1 },
643     { -1, -1 },
644     { 69, -1 },
645     { -1, -1 },
646     { 62, -1 },
647     { -1, -1 },
648     { 2, -1 },
649     { -1, -1 },
650     { 50, -1 },
651     { -1, -1 },
652     { -1, -1 },
653     { -1, -1 },
654     { 95, -1 },
655     { -1, -1 },
656     { -1, -1 },
657     { -1, -1 },
658     { -1, -1 },
659     { -1, -1 },
660     { -1, -1 },
661     { -1, -1 },
662     { -1, -1 },
663     { -1, -1 },
664     { -1, -1 },
665     { 38, 523 },
666     { -1, -1 },
667     { -1, -1 },
668     { -1, -1 },
669     { 57, -1 },
670     { 68, -1 },
671     { -1, -1 },
672     { -1, -1 },
673     { 107, 527 },
674     { -1, -1 },
675     { 108, -1 },
676     { -1, -1 },
677     { -1, -1 },
678     { -1, -1 },
679     { -1, -1 },
680     { 14, -1 },
681     { 20, 529 },
682     { -1, -1 },
683     { -1, -1 },
684     { -1, -1 },
685     { -1, -1 },
686     { -1, -1 },
687     { -1, -1 },
688     { -1, -1 },
689     { -1, -1 },
690     { -1, -1 },
691     { -1, -1 },
692     { -1, -1 },
693     { -1, -1 },
694     { -1, -1 },
695     { 112, -1 },
696     { -1, -1 },
697     { -1, -1 },
698     { -1, -1 },
699     { -1, -1 },
700     { -1, -1 },
701     { -1, -1 },
702     { -1, -1 },
703     { -1, -1 },
704     { 118, -1 },
705     { -1, -1 },
706     { -1, -1 },
707     { -1, -1 },
708     { -1, -1 },
709     { -1, -1 },
710     { -1, -1 },
711     { -1, -1 },
712     { 79, -1 },
713     { -1, -1 },
714     { -1, -1 },
715     { -1, -1 },
716     { 60, -1 },
717     { 52, -1 },
718     { -1, -1 },
719     { 74, -1 },
720     { 132, -1 },
721     { -1, -1 },
722     { -1, -1 },
723     { -1, -1 },
724     { 54, 516 },
725     { -1, -1 },
726     { 85, -1 },
727     { 9, -1 },
728     { -1, -1 },
729     { -1, -1 },
730     { -1, -1 },
731     { 105, -1 },
732     { 29, -1 },
733     { -1, -1 },
734     { -1, -1 },
735     { 37, -1 },
736     { -1, -1 },
737     { -1, -1 },
738     { -1, -1 },
739     { -1, -1 },
740     { -1, -1 },
741     { -1, -1 },
742     { -1, -1 },
743     { -1, -1 },
744     { -1, -1 },
745     { -1, -1 },
746     { -1, -1 },
747     { -1, -1 },
748     { 19, -1 },
749     { -1, -1 },
750     { -1, -1 },
751     { -1, -1 },
752     { 109, -1 },
753     { 13, 514 },
754     { 40, -1 },
755     { 111, -1 },
756     { -1, -1 },
757     { 7, 525 },
758     { -1, -1 },
759     { 125, -1 },
760     { 106, -1 },
761     { 75, 520 },
762     { -1, -1 },
763     { 122, -1 },
764     { 83, -1 },
765     { -1, -1 },
766     { -1, -1 },
767     { -1, -1 },
768     { 119, -1 },
769     { -1, -1 },
770     { 10, 519 },
771     { 11, -1 },
772     { 21, -1 },
773     { 42, -1 },
774     { 48, -1 },
775     { 56, -1 },
776     { 63, -1 },
777     { 66, -1 },
778     { 81, -1 },
779     { 91, -1 },
780     { 94, -1 },
781     { 97, -1 },
782     { 98, -1 },
783     { 104, -1 },
784     { 115, -1 },
785     { 116, -1 },
786     { 121, -1 },
787     { 129, -1 },
788     { 133, -1 },
789 };
790
791
792 static const HashTableValue JSTestObjPrototypeTableValues[] =
793 {
794     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
795     { "readOnlyLongAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
796     { "readOnlyStringAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
797     { "readOnlyTestObjAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
798     { "enumAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjEnumAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjEnumAttr) },
799     { "byteAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjByteAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjByteAttr) },
800     { "octetAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjOctetAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjOctetAttr) },
801     { "shortAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjShortAttr) },
802     { "unsignedShortAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjUnsignedShortAttr) },
803     { "longAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLongAttr) },
804     { "longLongAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLongLongAttr) },
805     { "unsignedLongLongAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjUnsignedLongLongAttr) },
806     { "stringAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttr) },
807     { "testObjAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestObjAttr) },
808     { "XMLObjAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjXMLObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjXMLObjAttr) },
809     { "create", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCreate), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjCreate) },
810     { "reflectedStringAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedStringAttr) },
811     { "reflectedIntegralAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedIntegralAttr) },
812     { "reflectedUnsignedIntegralAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedUnsignedIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedUnsignedIntegralAttr) },
813     { "reflectedBooleanAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedBooleanAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedBooleanAttr) },
814     { "reflectedURLAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedURLAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedURLAttr) },
815     { "reflectedStringAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedStringAttr) },
816     { "reflectedCustomIntegralAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomIntegralAttr) },
817     { "reflectedCustomBooleanAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomBooleanAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomBooleanAttr) },
818     { "reflectedCustomURLAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomURLAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomURLAttr) },
819     { "typedArrayAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTypedArrayAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTypedArrayAttr) },
820     { "attrWithGetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithGetterException) },
821     { "attrWithSetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithSetterException) },
822     { "stringAttrWithGetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrWithGetterException) },
823     { "stringAttrWithSetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrWithSetterException) },
824     { "withScriptStateAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptStateAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptStateAttribute) },
825     { "withScriptExecutionContextAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAttribute) },
826     { "withScriptStateAttributeRaises", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptStateAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptStateAttributeRaises) },
827     { "withScriptExecutionContextAttributeRaises", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAttributeRaises) },
828     { "withScriptExecutionContextAndScriptStateAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateAttribute) },
829     { "withScriptExecutionContextAndScriptStateAttributeRaises", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises) },
830     { "withScriptExecutionContextAndScriptStateWithSpacesAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute) },
831     { "withScriptArgumentsAndCallStackAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptArgumentsAndCallStackAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptArgumentsAndCallStackAttribute) },
832 #if ENABLE(Condition1)
833     { "conditionalAttr1", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr1) },
834 #else
835     { 0, 0, NoIntrinsic, 0, 0 },
836 #endif
837 #if ENABLE(Condition1) && ENABLE(Condition2)
838     { "conditionalAttr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr2) },
839 #else
840     { 0, 0, NoIntrinsic, 0, 0 },
841 #endif
842 #if ENABLE(Condition1) || ENABLE(Condition2)
843     { "conditionalAttr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr3) },
844 #else
845     { 0, 0, NoIntrinsic, 0, 0 },
846 #endif
847     { "cachedAttribute1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
848     { "cachedAttribute2", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
849     { "anyAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAnyAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAnyAttribute) },
850     { "mutablePoint", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjMutablePoint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjMutablePoint) },
851     { "immutablePoint", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjImmutablePoint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjImmutablePoint) },
852     { "strawberry", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrawberry), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrawberry) },
853     { "strictFloat", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrictFloat), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrictFloat) },
854     { "description", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjDescription), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
855     { "id", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjId), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjId) },
856     { "hash", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjHash), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
857     { "replaceableAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReplaceableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReplaceableAttribute) },
858     { "nullableDoubleAttribute", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableDoubleAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
859     { "nullableLongAttribute", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableLongAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
860     { "nullableBooleanAttribute", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableBooleanAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
861     { "nullableStringAttribute", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
862     { "nullableLongSettableAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableLongSettableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableLongSettableAttribute) },
863     { "nullableStringValue", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableStringValue) },
864     { "attribute", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
865     { "attributeWithReservedEnumType", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttributeWithReservedEnumType), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttributeWithReservedEnumType) },
866 #if ENABLE(Condition1)
867     { "CONDITIONAL_CONST", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONDITIONAL_CONST), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
868 #else
869     { 0, 0, NoIntrinsic, 0, 0 },
870 #endif
871     { "CONST_VALUE_0", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_0), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
872     { "CONST_VALUE_1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
873     { "CONST_VALUE_2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
874     { "CONST_VALUE_4", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_4), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
875     { "CONST_VALUE_8", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_8), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
876     { "CONST_VALUE_9", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_9), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
877     { "CONST_VALUE_10", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_10), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
878     { "CONST_VALUE_11", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_11), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
879     { "CONST_VALUE_12", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_12), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
880     { "CONST_VALUE_13", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_13), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
881     { "CONST_VALUE_14", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_14), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
882     { "CONST_JAVASCRIPT", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_JAVASCRIPT), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
883     { "readonly", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadonly), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
884     { "voidMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethod), (intptr_t) (0) },
885     { "voidMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethodWithArgs), (intptr_t) (3) },
886     { "byteMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionByteMethod), (intptr_t) (0) },
887     { "byteMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionByteMethodWithArgs), (intptr_t) (3) },
888     { "octetMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOctetMethod), (intptr_t) (0) },
889     { "octetMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOctetMethodWithArgs), (intptr_t) (3) },
890     { "longMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethod), (intptr_t) (0) },
891     { "longMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethodWithArgs), (intptr_t) (3) },
892     { "objMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethod), (intptr_t) (0) },
893     { "objMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethodWithArgs), (intptr_t) (3) },
894     { "methodWithSequenceArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithSequenceArg), (intptr_t) (1) },
895     { "methodReturningSequence", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodReturningSequence), (intptr_t) (1) },
896     { "methodWithEnumArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithEnumArg), (intptr_t) (1) },
897     { "methodThatRequiresAllArgsAndThrows", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows), (intptr_t) (2) },
898     { "serializedValue", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionSerializedValue), (intptr_t) (1) },
899     { "optionsObject", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOptionsObject), (intptr_t) (1) },
900     { "methodWithException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithException), (intptr_t) (0) },
901     { "customMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionCustomMethod), (intptr_t) (0) },
902     { "customMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionCustomMethodWithArgs), (intptr_t) (3) },
903     { "addEventListener", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAddEventListener), (intptr_t) (2) },
904     { "removeEventListener", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionRemoveEventListener), (intptr_t) (2) },
905     { "withScriptStateVoid", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateVoid), (intptr_t) (0) },
906     { "withScriptStateObj", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObj), (intptr_t) (0) },
907     { "withScriptStateVoidException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateVoidException), (intptr_t) (0) },
908     { "withScriptStateObjException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObjException), (intptr_t) (0) },
909     { "withScriptExecutionContext", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContext), (intptr_t) (0) },
910     { "withScriptExecutionContextAndScriptState", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptState), (intptr_t) (0) },
911     { "withScriptExecutionContextAndScriptStateObjException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateObjException), (intptr_t) (0) },
912     { "withScriptExecutionContextAndScriptStateWithSpaces", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateWithSpaces), (intptr_t) (0) },
913     { "withScriptArgumentsAndCallStack", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptArgumentsAndCallStack), (intptr_t) (0) },
914     { "methodWithOptionalArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArg), (intptr_t) (0) },
915     { "methodWithNonOptionalArgAndOptionalArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg), (intptr_t) (1) },
916     { "methodWithNonOptionalArgAndTwoOptionalArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs), (intptr_t) (1) },
917     { "methodWithOptionalString", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalString), (intptr_t) (0) },
918     { "methodWithOptionalStringIsUndefined", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsUndefined), (intptr_t) (0) },
919     { "methodWithOptionalStringIsNullString", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsNullString), (intptr_t) (0) },
920     { "methodWithCallbackArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackArg), (intptr_t) (1) },
921     { "methodWithNonCallbackArgAndCallbackArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackArg), (intptr_t) (2) },
922     { "methodWithCallbackAndOptionalArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackAndOptionalArg), (intptr_t) (0) },
923 #if ENABLE(Condition1)
924     { "conditionalMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod1), (intptr_t) (0) },
925 #else
926     { 0, 0, NoIntrinsic, 0, 0 },
927 #endif
928 #if ENABLE(Condition1) && ENABLE(Condition2)
929     { "conditionalMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod2), (intptr_t) (0) },
930 #else
931     { 0, 0, NoIntrinsic, 0, 0 },
932 #endif
933 #if ENABLE(Condition1) || ENABLE(Condition2)
934     { "conditionalMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod3), (intptr_t) (0) },
935 #else
936     { 0, 0, NoIntrinsic, 0, 0 },
937 #endif
938     { "overloadedMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOverloadedMethod), (intptr_t) (2) },
939     { "classMethodWithClamp", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionClassMethodWithClamp), (intptr_t) (2) },
940     { "methodWithUnsignedLongSequence", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithUnsignedLongSequence), (intptr_t) (1) },
941     { "stringArrayFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStringArrayFunction), (intptr_t) (1) },
942     { "domStringListFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionDomStringListFunction), (intptr_t) (1) },
943     { "getSVGDocument", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionGetSVGDocument), (intptr_t) (0) },
944     { "convert1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert1), (intptr_t) (1) },
945     { "convert2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert2), (intptr_t) (1) },
946     { "convert4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert4), (intptr_t) (1) },
947     { "convert5", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert5), (intptr_t) (1) },
948     { "mutablePointFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMutablePointFunction), (intptr_t) (0) },
949     { "immutablePointFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionImmutablePointFunction), (intptr_t) (0) },
950     { "orange", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOrange), (intptr_t) (0) },
951     { "strictFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunction), (intptr_t) (3) },
952     { "strictFunctionWithSequence", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunctionWithSequence), (intptr_t) (2) },
953     { "strictFunctionWithArray", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunctionWithArray), (intptr_t) (2) },
954     { "variadicStringMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicStringMethod), (intptr_t) (2) },
955     { "variadicDoubleMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicDoubleMethod), (intptr_t) (2) },
956     { "variadicNodeMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicNodeMethod), (intptr_t) (2) },
957     { "any", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAny), (intptr_t) (2) },
958 };
959
960 static const HashTable JSTestObjPrototypeTable = { 136, 511, true, JSTestObjPrototypeTableValues, 0, JSTestObjPrototypeTableIndex };
961 const ClassInfo JSTestObjPrototype::s_info = { "TestObjectPrototype", &Base::s_info, &JSTestObjPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestObjPrototype) };
962
963 JSObject* JSTestObjPrototype::self(VM& vm, JSGlobalObject* globalObject)
964 {
965     return getDOMPrototype<JSTestObj>(vm, globalObject);
966 }
967
968 void JSTestObjPrototype::finishCreation(VM& vm)
969 {
970     Base::finishCreation(vm);
971     reifyStaticProperties(vm, JSTestObjPrototypeTableValues, *this);
972 }
973
974 const ClassInfo JSTestObj::s_info = { "TestObject", &Base::s_info, &JSTestObjTable, 0 , CREATE_METHOD_TABLE(JSTestObj) };
975
976 JSTestObj::JSTestObj(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestObj> impl)
977     : JSDOMWrapper(structure, globalObject)
978     , m_impl(impl.leakRef())
979 {
980 }
981
982 JSObject* JSTestObj::createPrototype(VM& vm, JSGlobalObject* globalObject)
983 {
984     return JSTestObjPrototype::create(vm, globalObject, JSTestObjPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
985 }
986
987 void JSTestObj::destroy(JSC::JSCell* cell)
988 {
989     JSTestObj* thisObject = static_cast<JSTestObj*>(cell);
990     thisObject->JSTestObj::~JSTestObj();
991 }
992
993 JSTestObj::~JSTestObj()
994 {
995     releaseImplIfNotNull();
996 }
997
998 bool JSTestObj::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
999 {
1000     JSTestObj* thisObject = jsCast<JSTestObj*>(object);
1001     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
1002     return getStaticValueSlot<JSTestObj, Base>(exec, JSTestObjTable, thisObject, propertyName, slot);
1003 }
1004
1005 EncodedJSValue jsTestObjReadOnlyLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1006 {
1007     UNUSED_PARAM(exec);
1008     UNUSED_PARAM(slotBase);
1009     UNUSED_PARAM(thisValue);
1010     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1011     if (UNLIKELY(!castedThis)) {
1012         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1013             return reportDeprecatedGetterError(*exec, "TestObj", "readOnlyLongAttr");
1014         return throwGetterTypeError(*exec, "TestObj", "readOnlyLongAttr");
1015     }
1016     TestObj& impl = castedThis->impl();
1017     JSValue result = jsNumber(impl.readOnlyLongAttr());
1018     return JSValue::encode(result);
1019 }
1020
1021
1022 EncodedJSValue jsTestObjReadOnlyStringAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1023 {
1024     UNUSED_PARAM(exec);
1025     UNUSED_PARAM(slotBase);
1026     UNUSED_PARAM(thisValue);
1027     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1028     if (UNLIKELY(!castedThis)) {
1029         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1030             return reportDeprecatedGetterError(*exec, "TestObj", "readOnlyStringAttr");
1031         return throwGetterTypeError(*exec, "TestObj", "readOnlyStringAttr");
1032     }
1033     TestObj& impl = castedThis->impl();
1034     JSValue result = jsStringWithCache(exec, impl.readOnlyStringAttr());
1035     return JSValue::encode(result);
1036 }
1037
1038
1039 EncodedJSValue jsTestObjReadOnlyTestObjAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1040 {
1041     UNUSED_PARAM(exec);
1042     UNUSED_PARAM(slotBase);
1043     UNUSED_PARAM(thisValue);
1044     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1045     if (UNLIKELY(!castedThis)) {
1046         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1047             return reportDeprecatedGetterError(*exec, "TestObj", "readOnlyTestObjAttr");
1048         return throwGetterTypeError(*exec, "TestObj", "readOnlyTestObjAttr");
1049     }
1050     TestObj& impl = castedThis->impl();
1051     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.readOnlyTestObjAttr()));
1052     return JSValue::encode(result);
1053 }
1054
1055
1056 EncodedJSValue jsTestObjConstructorStaticReadOnlyLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1057 {
1058     UNUSED_PARAM(exec);
1059     UNUSED_PARAM(slotBase);
1060     UNUSED_PARAM(thisValue);
1061     JSValue result = jsNumber(TestObj::staticReadOnlyLongAttr());
1062     return JSValue::encode(result);
1063 }
1064
1065
1066 EncodedJSValue jsTestObjConstructorStaticStringAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1067 {
1068     UNUSED_PARAM(exec);
1069     UNUSED_PARAM(slotBase);
1070     UNUSED_PARAM(thisValue);
1071     JSValue result = jsStringWithCache(exec, TestObj::staticStringAttr());
1072     return JSValue::encode(result);
1073 }
1074
1075
1076 EncodedJSValue jsTestObjConstructorTestSubObj(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1077 {
1078     UNUSED_PARAM(exec);
1079     UNUSED_PARAM(slotBase);
1080     UNUSED_PARAM(thisValue);
1081     JSTestObj* castedThis = jsCast<JSTestObj*>(slotBase);
1082     return JSValue::encode(JSTestSubObj::getConstructor(exec->vm(), castedThis->globalObject()));
1083 }
1084
1085
1086 EncodedJSValue jsTestObjTestSubObjEnabledBySettingConstructor(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1087 {
1088     UNUSED_PARAM(exec);
1089     UNUSED_PARAM(slotBase);
1090     UNUSED_PARAM(thisValue);
1091     JSTestObj* castedThis = jsCast<JSTestObj*>(slotBase);
1092     if (!castedThis->impl().frame())
1093         return JSValue::encode(jsUndefined());
1094     Settings& settings = castedThis->impl().frame()->settings();
1095     if (!settings.testSettingEnabled())
1096         return JSValue::encode(jsUndefined());
1097     return JSValue::encode(JSTestSubObj::getConstructor(exec->vm(), castedThis->globalObject()));
1098 }
1099
1100
1101 EncodedJSValue jsTestObjEnumAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1102 {
1103     UNUSED_PARAM(exec);
1104     UNUSED_PARAM(slotBase);
1105     UNUSED_PARAM(thisValue);
1106     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1107     if (UNLIKELY(!castedThis)) {
1108         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1109             return reportDeprecatedGetterError(*exec, "TestObj", "enumAttr");
1110         return throwGetterTypeError(*exec, "TestObj", "enumAttr");
1111     }
1112     TestObj& impl = castedThis->impl();
1113     JSValue result = jsStringWithCache(exec, impl.enumAttr());
1114     return JSValue::encode(result);
1115 }
1116
1117
1118 EncodedJSValue jsTestObjByteAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1119 {
1120     UNUSED_PARAM(exec);
1121     UNUSED_PARAM(slotBase);
1122     UNUSED_PARAM(thisValue);
1123     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1124     if (UNLIKELY(!castedThis)) {
1125         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1126             return reportDeprecatedGetterError(*exec, "TestObj", "byteAttr");
1127         return throwGetterTypeError(*exec, "TestObj", "byteAttr");
1128     }
1129     TestObj& impl = castedThis->impl();
1130     JSValue result = jsNumber(impl.byteAttr());
1131     return JSValue::encode(result);
1132 }
1133
1134
1135 EncodedJSValue jsTestObjOctetAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1136 {
1137     UNUSED_PARAM(exec);
1138     UNUSED_PARAM(slotBase);
1139     UNUSED_PARAM(thisValue);
1140     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1141     if (UNLIKELY(!castedThis)) {
1142         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1143             return reportDeprecatedGetterError(*exec, "TestObj", "octetAttr");
1144         return throwGetterTypeError(*exec, "TestObj", "octetAttr");
1145     }
1146     TestObj& impl = castedThis->impl();
1147     JSValue result = jsNumber(impl.octetAttr());
1148     return JSValue::encode(result);
1149 }
1150
1151
1152 EncodedJSValue jsTestObjShortAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1153 {
1154     UNUSED_PARAM(exec);
1155     UNUSED_PARAM(slotBase);
1156     UNUSED_PARAM(thisValue);
1157     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1158     if (UNLIKELY(!castedThis)) {
1159         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1160             return reportDeprecatedGetterError(*exec, "TestObj", "shortAttr");
1161         return throwGetterTypeError(*exec, "TestObj", "shortAttr");
1162     }
1163     TestObj& impl = castedThis->impl();
1164     JSValue result = jsNumber(impl.shortAttr());
1165     return JSValue::encode(result);
1166 }
1167
1168
1169 EncodedJSValue jsTestObjUnsignedShortAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1170 {
1171     UNUSED_PARAM(exec);
1172     UNUSED_PARAM(slotBase);
1173     UNUSED_PARAM(thisValue);
1174     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1175     if (UNLIKELY(!castedThis)) {
1176         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1177             return reportDeprecatedGetterError(*exec, "TestObj", "unsignedShortAttr");
1178         return throwGetterTypeError(*exec, "TestObj", "unsignedShortAttr");
1179     }
1180     TestObj& impl = castedThis->impl();
1181     JSValue result = jsNumber(impl.unsignedShortAttr());
1182     return JSValue::encode(result);
1183 }
1184
1185
1186 EncodedJSValue jsTestObjLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1187 {
1188     UNUSED_PARAM(exec);
1189     UNUSED_PARAM(slotBase);
1190     UNUSED_PARAM(thisValue);
1191     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1192     if (UNLIKELY(!castedThis)) {
1193         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1194             return reportDeprecatedGetterError(*exec, "TestObj", "longAttr");
1195         return throwGetterTypeError(*exec, "TestObj", "longAttr");
1196     }
1197     TestObj& impl = castedThis->impl();
1198     JSValue result = jsNumber(impl.longAttr());
1199     return JSValue::encode(result);
1200 }
1201
1202
1203 EncodedJSValue jsTestObjLongLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1204 {
1205     UNUSED_PARAM(exec);
1206     UNUSED_PARAM(slotBase);
1207     UNUSED_PARAM(thisValue);
1208     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1209     if (UNLIKELY(!castedThis)) {
1210         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1211             return reportDeprecatedGetterError(*exec, "TestObj", "longLongAttr");
1212         return throwGetterTypeError(*exec, "TestObj", "longLongAttr");
1213     }
1214     TestObj& impl = castedThis->impl();
1215     JSValue result = jsNumber(impl.longLongAttr());
1216     return JSValue::encode(result);
1217 }
1218
1219
1220 EncodedJSValue jsTestObjUnsignedLongLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1221 {
1222     UNUSED_PARAM(exec);
1223     UNUSED_PARAM(slotBase);
1224     UNUSED_PARAM(thisValue);
1225     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1226     if (UNLIKELY(!castedThis)) {
1227         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1228             return reportDeprecatedGetterError(*exec, "TestObj", "unsignedLongLongAttr");
1229         return throwGetterTypeError(*exec, "TestObj", "unsignedLongLongAttr");
1230     }
1231     TestObj& impl = castedThis->impl();
1232     JSValue result = jsNumber(impl.unsignedLongLongAttr());
1233     return JSValue::encode(result);
1234 }
1235
1236
1237 EncodedJSValue jsTestObjStringAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1238 {
1239     UNUSED_PARAM(exec);
1240     UNUSED_PARAM(slotBase);
1241     UNUSED_PARAM(thisValue);
1242     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1243     if (UNLIKELY(!castedThis)) {
1244         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1245             return reportDeprecatedGetterError(*exec, "TestObj", "stringAttr");
1246         return throwGetterTypeError(*exec, "TestObj", "stringAttr");
1247     }
1248     TestObj& impl = castedThis->impl();
1249     JSValue result = jsStringWithCache(exec, impl.stringAttr());
1250     return JSValue::encode(result);
1251 }
1252
1253
1254 EncodedJSValue jsTestObjTestObjAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1255 {
1256     UNUSED_PARAM(exec);
1257     UNUSED_PARAM(slotBase);
1258     UNUSED_PARAM(thisValue);
1259     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1260     if (UNLIKELY(!castedThis)) {
1261         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1262             return reportDeprecatedGetterError(*exec, "TestObj", "testObjAttr");
1263         return throwGetterTypeError(*exec, "TestObj", "testObjAttr");
1264     }
1265     TestObj& impl = castedThis->impl();
1266     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.testObjAttr()));
1267     return JSValue::encode(result);
1268 }
1269
1270
1271 EncodedJSValue jsTestObjXMLObjAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1272 {
1273     UNUSED_PARAM(exec);
1274     UNUSED_PARAM(slotBase);
1275     UNUSED_PARAM(thisValue);
1276     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1277     if (UNLIKELY(!castedThis)) {
1278         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1279             return reportDeprecatedGetterError(*exec, "TestObj", "XMLObjAttr");
1280         return throwGetterTypeError(*exec, "TestObj", "XMLObjAttr");
1281     }
1282     TestObj& impl = castedThis->impl();
1283     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.xmlObjAttr()));
1284     return JSValue::encode(result);
1285 }
1286
1287
1288 EncodedJSValue jsTestObjCreate(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1289 {
1290     UNUSED_PARAM(exec);
1291     UNUSED_PARAM(slotBase);
1292     UNUSED_PARAM(thisValue);
1293     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1294     if (UNLIKELY(!castedThis)) {
1295         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1296             return reportDeprecatedGetterError(*exec, "TestObj", "create");
1297         return throwGetterTypeError(*exec, "TestObj", "create");
1298     }
1299     TestObj& impl = castedThis->impl();
1300     JSValue result = jsBoolean(impl.isCreate());
1301     return JSValue::encode(result);
1302 }
1303
1304
1305 EncodedJSValue jsTestObjReflectedStringAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1306 {
1307     UNUSED_PARAM(exec);
1308     UNUSED_PARAM(slotBase);
1309     UNUSED_PARAM(thisValue);
1310     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1311     if (UNLIKELY(!castedThis)) {
1312         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1313             return reportDeprecatedGetterError(*exec, "TestObj", "reflectedStringAttr");
1314         return throwGetterTypeError(*exec, "TestObj", "reflectedStringAttr");
1315     }
1316     TestObj& impl = castedThis->impl();
1317     JSValue result = jsStringWithCache(exec, impl.fastGetAttribute(WebCore::HTMLNames::reflectedstringattrAttr));
1318     return JSValue::encode(result);
1319 }
1320
1321
1322 EncodedJSValue jsTestObjReflectedIntegralAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1323 {
1324     UNUSED_PARAM(exec);
1325     UNUSED_PARAM(slotBase);
1326     UNUSED_PARAM(thisValue);
1327     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1328     if (UNLIKELY(!castedThis)) {
1329         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1330             return reportDeprecatedGetterError(*exec, "TestObj", "reflectedIntegralAttr");
1331         return throwGetterTypeError(*exec, "TestObj", "reflectedIntegralAttr");
1332     }
1333     TestObj& impl = castedThis->impl();
1334     JSValue result = jsNumber(impl.getIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr));
1335     return JSValue::encode(result);
1336 }
1337
1338
1339 EncodedJSValue jsTestObjReflectedUnsignedIntegralAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1340 {
1341     UNUSED_PARAM(exec);
1342     UNUSED_PARAM(slotBase);
1343     UNUSED_PARAM(thisValue);
1344     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1345     if (UNLIKELY(!castedThis)) {
1346         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1347             return reportDeprecatedGetterError(*exec, "TestObj", "reflectedUnsignedIntegralAttr");
1348         return throwGetterTypeError(*exec, "TestObj", "reflectedUnsignedIntegralAttr");
1349     }
1350     TestObj& impl = castedThis->impl();
1351     JSValue result = jsNumber(std::max(0, impl.getIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr)));
1352     return JSValue::encode(result);
1353 }
1354
1355
1356 EncodedJSValue jsTestObjReflectedBooleanAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1357 {
1358     UNUSED_PARAM(exec);
1359     UNUSED_PARAM(slotBase);
1360     UNUSED_PARAM(thisValue);
1361     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1362     if (UNLIKELY(!castedThis)) {
1363         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1364             return reportDeprecatedGetterError(*exec, "TestObj", "reflectedBooleanAttr");
1365         return throwGetterTypeError(*exec, "TestObj", "reflectedBooleanAttr");
1366     }
1367     TestObj& impl = castedThis->impl();
1368     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr));
1369     return JSValue::encode(result);
1370 }
1371
1372
1373 EncodedJSValue jsTestObjReflectedURLAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1374 {
1375     UNUSED_PARAM(exec);
1376     UNUSED_PARAM(slotBase);
1377     UNUSED_PARAM(thisValue);
1378     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1379     if (UNLIKELY(!castedThis)) {
1380         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1381             return reportDeprecatedGetterError(*exec, "TestObj", "reflectedURLAttr");
1382         return throwGetterTypeError(*exec, "TestObj", "reflectedURLAttr");
1383     }
1384     TestObj& impl = castedThis->impl();
1385     JSValue result = jsStringWithCache(exec, impl.getURLAttribute(WebCore::HTMLNames::reflectedurlattrAttr));
1386     return JSValue::encode(result);
1387 }
1388
1389
1390 EncodedJSValue jsTestObjReflectedStringAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1391 {
1392     UNUSED_PARAM(exec);
1393     UNUSED_PARAM(slotBase);
1394     UNUSED_PARAM(thisValue);
1395     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1396     if (UNLIKELY(!castedThis)) {
1397         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1398             return reportDeprecatedGetterError(*exec, "TestObj", "reflectedStringAttr");
1399         return throwGetterTypeError(*exec, "TestObj", "reflectedStringAttr");
1400     }
1401     TestObj& impl = castedThis->impl();
1402     JSValue result = jsStringWithCache(exec, impl.fastGetAttribute(WebCore::HTMLNames::customContentStringAttrAttr));
1403     return JSValue::encode(result);
1404 }
1405
1406
1407 EncodedJSValue jsTestObjReflectedCustomIntegralAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1408 {
1409     UNUSED_PARAM(exec);
1410     UNUSED_PARAM(slotBase);
1411     UNUSED_PARAM(thisValue);
1412     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1413     if (UNLIKELY(!castedThis)) {
1414         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1415             return reportDeprecatedGetterError(*exec, "TestObj", "reflectedCustomIntegralAttr");
1416         return throwGetterTypeError(*exec, "TestObj", "reflectedCustomIntegralAttr");
1417     }
1418     TestObj& impl = castedThis->impl();
1419     JSValue result = jsNumber(impl.getIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr));
1420     return JSValue::encode(result);
1421 }
1422
1423
1424 EncodedJSValue jsTestObjReflectedCustomBooleanAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1425 {
1426     UNUSED_PARAM(exec);
1427     UNUSED_PARAM(slotBase);
1428     UNUSED_PARAM(thisValue);
1429     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1430     if (UNLIKELY(!castedThis)) {
1431         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1432             return reportDeprecatedGetterError(*exec, "TestObj", "reflectedCustomBooleanAttr");
1433         return throwGetterTypeError(*exec, "TestObj", "reflectedCustomBooleanAttr");
1434     }
1435     TestObj& impl = castedThis->impl();
1436     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr));
1437     return JSValue::encode(result);
1438 }
1439
1440
1441 EncodedJSValue jsTestObjReflectedCustomURLAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1442 {
1443     UNUSED_PARAM(exec);
1444     UNUSED_PARAM(slotBase);
1445     UNUSED_PARAM(thisValue);
1446     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1447     if (UNLIKELY(!castedThis)) {
1448         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1449             return reportDeprecatedGetterError(*exec, "TestObj", "reflectedCustomURLAttr");
1450         return throwGetterTypeError(*exec, "TestObj", "reflectedCustomURLAttr");
1451     }
1452     TestObj& impl = castedThis->impl();
1453     JSValue result = jsStringWithCache(exec, impl.getURLAttribute(WebCore::HTMLNames::customContentURLAttrAttr));
1454     return JSValue::encode(result);
1455 }
1456
1457
1458 EncodedJSValue jsTestObjTypedArrayAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1459 {
1460     UNUSED_PARAM(exec);
1461     UNUSED_PARAM(slotBase);
1462     UNUSED_PARAM(thisValue);
1463     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1464     if (UNLIKELY(!castedThis)) {
1465         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1466             return reportDeprecatedGetterError(*exec, "TestObj", "typedArrayAttr");
1467         return throwGetterTypeError(*exec, "TestObj", "typedArrayAttr");
1468     }
1469     TestObj& impl = castedThis->impl();
1470     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.typedArrayAttr()));
1471     return JSValue::encode(result);
1472 }
1473
1474
1475 EncodedJSValue jsTestObjAttrWithGetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1476 {
1477     UNUSED_PARAM(exec);
1478     UNUSED_PARAM(slotBase);
1479     UNUSED_PARAM(thisValue);
1480     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1481     if (UNLIKELY(!castedThis)) {
1482         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1483             return reportDeprecatedGetterError(*exec, "TestObj", "attrWithGetterException");
1484         return throwGetterTypeError(*exec, "TestObj", "attrWithGetterException");
1485     }
1486     ExceptionCode ec = 0;
1487     TestObj& impl = castedThis->impl();
1488     JSValue result = jsNumber(impl.attrWithGetterException(ec));
1489     setDOMException(exec, ec);
1490     return JSValue::encode(result);
1491 }
1492
1493
1494 EncodedJSValue jsTestObjAttrWithSetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1495 {
1496     UNUSED_PARAM(exec);
1497     UNUSED_PARAM(slotBase);
1498     UNUSED_PARAM(thisValue);
1499     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1500     if (UNLIKELY(!castedThis)) {
1501         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1502             return reportDeprecatedGetterError(*exec, "TestObj", "attrWithSetterException");
1503         return throwGetterTypeError(*exec, "TestObj", "attrWithSetterException");
1504     }
1505     TestObj& impl = castedThis->impl();
1506     JSValue result = jsNumber(impl.attrWithSetterException());
1507     return JSValue::encode(result);
1508 }
1509
1510
1511 EncodedJSValue jsTestObjStringAttrWithGetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1512 {
1513     UNUSED_PARAM(exec);
1514     UNUSED_PARAM(slotBase);
1515     UNUSED_PARAM(thisValue);
1516     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1517     if (UNLIKELY(!castedThis)) {
1518         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1519             return reportDeprecatedGetterError(*exec, "TestObj", "stringAttrWithGetterException");
1520         return throwGetterTypeError(*exec, "TestObj", "stringAttrWithGetterException");
1521     }
1522     ExceptionCode ec = 0;
1523     TestObj& impl = castedThis->impl();
1524     JSValue result = jsStringWithCache(exec, impl.stringAttrWithGetterException(ec));
1525     setDOMException(exec, ec);
1526     return JSValue::encode(result);
1527 }
1528
1529
1530 EncodedJSValue jsTestObjStringAttrWithSetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1531 {
1532     UNUSED_PARAM(exec);
1533     UNUSED_PARAM(slotBase);
1534     UNUSED_PARAM(thisValue);
1535     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1536     if (UNLIKELY(!castedThis)) {
1537         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1538             return reportDeprecatedGetterError(*exec, "TestObj", "stringAttrWithSetterException");
1539         return throwGetterTypeError(*exec, "TestObj", "stringAttrWithSetterException");
1540     }
1541     TestObj& impl = castedThis->impl();
1542     JSValue result = jsStringWithCache(exec, impl.stringAttrWithSetterException());
1543     return JSValue::encode(result);
1544 }
1545
1546
1547 EncodedJSValue jsTestObjCustomAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1548 {
1549     UNUSED_PARAM(exec);
1550     UNUSED_PARAM(slotBase);
1551     UNUSED_PARAM(thisValue);
1552     JSTestObj* castedThis = jsCast<JSTestObj*>(slotBase);
1553     return JSValue::encode(castedThis->customAttr(exec));
1554 }
1555
1556
1557 EncodedJSValue jsTestObjWithScriptStateAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1558 {
1559     UNUSED_PARAM(exec);
1560     UNUSED_PARAM(slotBase);
1561     UNUSED_PARAM(thisValue);
1562     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1563     if (UNLIKELY(!castedThis)) {
1564         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1565             return reportDeprecatedGetterError(*exec, "TestObj", "withScriptStateAttribute");
1566         return throwGetterTypeError(*exec, "TestObj", "withScriptStateAttribute");
1567     }
1568     TestObj& impl = castedThis->impl();
1569     JSValue result = jsNumber(impl.withScriptStateAttribute(exec));
1570     return JSValue::encode(result);
1571 }
1572
1573
1574 EncodedJSValue jsTestObjWithScriptExecutionContextAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1575 {
1576     UNUSED_PARAM(exec);
1577     UNUSED_PARAM(slotBase);
1578     UNUSED_PARAM(thisValue);
1579     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1580     if (UNLIKELY(!castedThis)) {
1581         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1582             return reportDeprecatedGetterError(*exec, "TestObj", "withScriptExecutionContextAttribute");
1583         return throwGetterTypeError(*exec, "TestObj", "withScriptExecutionContextAttribute");
1584     }
1585     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1586     if (!scriptContext)
1587         return JSValue::encode(jsUndefined());
1588     TestObj& impl = castedThis->impl();
1589     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttribute(scriptContext)));
1590     return JSValue::encode(result);
1591 }
1592
1593
1594 EncodedJSValue jsTestObjWithScriptStateAttributeRaises(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1595 {
1596     UNUSED_PARAM(exec);
1597     UNUSED_PARAM(slotBase);
1598     UNUSED_PARAM(thisValue);
1599     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1600     if (UNLIKELY(!castedThis)) {
1601         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1602             return reportDeprecatedGetterError(*exec, "TestObj", "withScriptStateAttributeRaises");
1603         return throwGetterTypeError(*exec, "TestObj", "withScriptStateAttributeRaises");
1604     }
1605     ExceptionCode ec = 0;
1606     TestObj& impl = castedThis->impl();
1607     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateAttributeRaises(exec, ec)));
1608     setDOMException(exec, ec);
1609     return JSValue::encode(result);
1610 }
1611
1612
1613 EncodedJSValue jsTestObjWithScriptExecutionContextAttributeRaises(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1614 {
1615     UNUSED_PARAM(exec);
1616     UNUSED_PARAM(slotBase);
1617     UNUSED_PARAM(thisValue);
1618     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1619     if (UNLIKELY(!castedThis)) {
1620         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1621             return reportDeprecatedGetterError(*exec, "TestObj", "withScriptExecutionContextAttributeRaises");
1622         return throwGetterTypeError(*exec, "TestObj", "withScriptExecutionContextAttributeRaises");
1623     }
1624     ExceptionCode ec = 0;
1625     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1626     if (!scriptContext)
1627         return JSValue::encode(jsUndefined());
1628     TestObj& impl = castedThis->impl();
1629     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttributeRaises(scriptContext, ec)));
1630     setDOMException(exec, ec);
1631     return JSValue::encode(result);
1632 }
1633
1634
1635 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1636 {
1637     UNUSED_PARAM(exec);
1638     UNUSED_PARAM(slotBase);
1639     UNUSED_PARAM(thisValue);
1640     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1641     if (UNLIKELY(!castedThis)) {
1642         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1643             return reportDeprecatedGetterError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateAttribute");
1644         return throwGetterTypeError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateAttribute");
1645     }
1646     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1647     if (!scriptContext)
1648         return JSValue::encode(jsUndefined());
1649     TestObj& impl = castedThis->impl();
1650     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttribute(exec, scriptContext)));
1651     return JSValue::encode(result);
1652 }
1653
1654
1655 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1656 {
1657     UNUSED_PARAM(exec);
1658     UNUSED_PARAM(slotBase);
1659     UNUSED_PARAM(thisValue);
1660     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1661     if (UNLIKELY(!castedThis)) {
1662         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1663             return reportDeprecatedGetterError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateAttributeRaises");
1664         return throwGetterTypeError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateAttributeRaises");
1665     }
1666     ExceptionCode ec = 0;
1667     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1668     if (!scriptContext)
1669         return JSValue::encode(jsUndefined());
1670     TestObj& impl = castedThis->impl();
1671     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttributeRaises(exec, scriptContext, ec)));
1672     setDOMException(exec, ec);
1673     return JSValue::encode(result);
1674 }
1675
1676
1677 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1678 {
1679     UNUSED_PARAM(exec);
1680     UNUSED_PARAM(slotBase);
1681     UNUSED_PARAM(thisValue);
1682     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1683     if (UNLIKELY(!castedThis)) {
1684         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1685             return reportDeprecatedGetterError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateWithSpacesAttribute");
1686         return throwGetterTypeError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateWithSpacesAttribute");
1687     }
1688     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1689     if (!scriptContext)
1690         return JSValue::encode(jsUndefined());
1691     TestObj& impl = castedThis->impl();
1692     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateWithSpacesAttribute(exec, scriptContext)));
1693     return JSValue::encode(result);
1694 }
1695
1696
1697 EncodedJSValue jsTestObjWithScriptArgumentsAndCallStackAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1698 {
1699     UNUSED_PARAM(exec);
1700     UNUSED_PARAM(slotBase);
1701     UNUSED_PARAM(thisValue);
1702     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1703     if (UNLIKELY(!castedThis)) {
1704         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1705             return reportDeprecatedGetterError(*exec, "TestObj", "withScriptArgumentsAndCallStackAttribute");
1706         return throwGetterTypeError(*exec, "TestObj", "withScriptArgumentsAndCallStackAttribute");
1707     }
1708     TestObj& impl = castedThis->impl();
1709     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptArgumentsAndCallStackAttribute()));
1710     return JSValue::encode(result);
1711 }
1712
1713
1714 #if ENABLE(Condition1)
1715 EncodedJSValue jsTestObjConditionalAttr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1716 {
1717     UNUSED_PARAM(exec);
1718     UNUSED_PARAM(slotBase);
1719     UNUSED_PARAM(thisValue);
1720     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1721     if (UNLIKELY(!castedThis)) {
1722         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1723             return reportDeprecatedGetterError(*exec, "TestObj", "conditionalAttr1");
1724         return throwGetterTypeError(*exec, "TestObj", "conditionalAttr1");
1725     }
1726     TestObj& impl = castedThis->impl();
1727     JSValue result = jsNumber(impl.conditionalAttr1());
1728     return JSValue::encode(result);
1729 }
1730
1731 #endif
1732
1733 #if ENABLE(Condition1) && ENABLE(Condition2)
1734 EncodedJSValue jsTestObjConditionalAttr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1735 {
1736     UNUSED_PARAM(exec);
1737     UNUSED_PARAM(slotBase);
1738     UNUSED_PARAM(thisValue);
1739     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1740     if (UNLIKELY(!castedThis)) {
1741         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1742             return reportDeprecatedGetterError(*exec, "TestObj", "conditionalAttr2");
1743         return throwGetterTypeError(*exec, "TestObj", "conditionalAttr2");
1744     }
1745     TestObj& impl = castedThis->impl();
1746     JSValue result = jsNumber(impl.conditionalAttr2());
1747     return JSValue::encode(result);
1748 }
1749
1750 #endif
1751
1752 #if ENABLE(Condition1) || ENABLE(Condition2)
1753 EncodedJSValue jsTestObjConditionalAttr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1754 {
1755     UNUSED_PARAM(exec);
1756     UNUSED_PARAM(slotBase);
1757     UNUSED_PARAM(thisValue);
1758     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1759     if (UNLIKELY(!castedThis)) {
1760         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1761             return reportDeprecatedGetterError(*exec, "TestObj", "conditionalAttr3");
1762         return throwGetterTypeError(*exec, "TestObj", "conditionalAttr3");
1763     }
1764     TestObj& impl = castedThis->impl();
1765     JSValue result = jsNumber(impl.conditionalAttr3());
1766     return JSValue::encode(result);
1767 }
1768
1769 #endif
1770
1771 #if ENABLE(Condition1)
1772 EncodedJSValue jsTestObjConditionalAttr4Constructor(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1773 {
1774     UNUSED_PARAM(exec);
1775     UNUSED_PARAM(slotBase);
1776     UNUSED_PARAM(thisValue);
1777     JSTestObj* castedThis = jsCast<JSTestObj*>(slotBase);
1778     return JSValue::encode(JSTestObjectA::getConstructor(exec->vm(), castedThis->globalObject()));
1779 }
1780
1781 #endif
1782
1783 #if ENABLE(Condition1) && ENABLE(Condition2)
1784 EncodedJSValue jsTestObjConditionalAttr5Constructor(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1785 {
1786     UNUSED_PARAM(exec);
1787     UNUSED_PARAM(slotBase);
1788     UNUSED_PARAM(thisValue);
1789     JSTestObj* castedThis = jsCast<JSTestObj*>(slotBase);
1790     return JSValue::encode(JSTestObjectB::getConstructor(exec->vm(), castedThis->globalObject()));
1791 }
1792
1793 #endif
1794
1795 #if ENABLE(Condition1) || ENABLE(Condition2)
1796 EncodedJSValue jsTestObjConditionalAttr6Constructor(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1797 {
1798     UNUSED_PARAM(exec);
1799     UNUSED_PARAM(slotBase);
1800     UNUSED_PARAM(thisValue);
1801     JSTestObj* castedThis = jsCast<JSTestObj*>(slotBase);
1802     return JSValue::encode(JSTestObjectC::getConstructor(exec->vm(), castedThis->globalObject()));
1803 }
1804
1805 #endif
1806
1807 EncodedJSValue jsTestObjCachedAttribute1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1808 {
1809     UNUSED_PARAM(exec);
1810     UNUSED_PARAM(slotBase);
1811     UNUSED_PARAM(thisValue);
1812     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1813     if (UNLIKELY(!castedThis)) {
1814         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1815             return reportDeprecatedGetterError(*exec, "TestObj", "cachedAttribute1");
1816         return throwGetterTypeError(*exec, "TestObj", "cachedAttribute1");
1817     }
1818     if (JSValue cachedValue = castedThis->m_cachedAttribute1.get())
1819         return JSValue::encode(cachedValue);
1820     TestObj& impl = castedThis->impl();
1821     JSValue result = (impl.cachedAttribute1().hasNoValue() ? jsNull() : impl.cachedAttribute1().jsValue());
1822     castedThis->m_cachedAttribute1.set(exec->vm(), castedThis, result);
1823     return JSValue::encode(result);
1824 }
1825
1826
1827 EncodedJSValue jsTestObjCachedAttribute2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1828 {
1829     UNUSED_PARAM(exec);
1830     UNUSED_PARAM(slotBase);
1831     UNUSED_PARAM(thisValue);
1832     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1833     if (UNLIKELY(!castedThis)) {
1834         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1835             return reportDeprecatedGetterError(*exec, "TestObj", "cachedAttribute2");
1836         return throwGetterTypeError(*exec, "TestObj", "cachedAttribute2");
1837     }
1838     if (JSValue cachedValue = castedThis->m_cachedAttribute2.get())
1839         return JSValue::encode(cachedValue);
1840     TestObj& impl = castedThis->impl();
1841     JSValue result = (impl.cachedAttribute2().hasNoValue() ? jsNull() : impl.cachedAttribute2().jsValue());
1842     castedThis->m_cachedAttribute2.set(exec->vm(), castedThis, result);
1843     return JSValue::encode(result);
1844 }
1845
1846
1847 EncodedJSValue jsTestObjAnyAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1848 {
1849     UNUSED_PARAM(exec);
1850     UNUSED_PARAM(slotBase);
1851     UNUSED_PARAM(thisValue);
1852     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1853     if (UNLIKELY(!castedThis)) {
1854         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1855             return reportDeprecatedGetterError(*exec, "TestObj", "anyAttribute");
1856         return throwGetterTypeError(*exec, "TestObj", "anyAttribute");
1857     }
1858     TestObj& impl = castedThis->impl();
1859     JSValue result = (impl.anyAttribute().hasNoValue() ? jsNull() : impl.anyAttribute().jsValue());
1860     return JSValue::encode(result);
1861 }
1862
1863
1864 EncodedJSValue jsTestObjContentDocument(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1865 {
1866     UNUSED_PARAM(exec);
1867     UNUSED_PARAM(slotBase);
1868     UNUSED_PARAM(thisValue);
1869     JSTestObj* castedThis = jsCast<JSTestObj*>(slotBase);
1870     TestObj& impl = castedThis->impl();
1871     return JSValue::encode(shouldAllowAccessToNode(exec, impl.contentDocument()) ? toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.contentDocument())) : jsNull());
1872 }
1873
1874
1875 EncodedJSValue jsTestObjMutablePoint(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1876 {
1877     UNUSED_PARAM(exec);
1878     UNUSED_PARAM(slotBase);
1879     UNUSED_PARAM(thisValue);
1880     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1881     if (UNLIKELY(!castedThis)) {
1882         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1883             return reportDeprecatedGetterError(*exec, "TestObj", "mutablePoint");
1884         return throwGetterTypeError(*exec, "TestObj", "mutablePoint");
1885     }
1886     TestObj& impl = castedThis->impl();
1887     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGStaticPropertyTearOff<TestObj, SVGPoint>::create(impl, impl.mutablePoint(), &TestObj::updateMutablePoint)));
1888     return JSValue::encode(result);
1889 }
1890
1891
1892 EncodedJSValue jsTestObjImmutablePoint(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1893 {
1894     UNUSED_PARAM(exec);
1895     UNUSED_PARAM(slotBase);
1896     UNUSED_PARAM(thisValue);
1897     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1898     if (UNLIKELY(!castedThis)) {
1899         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1900             return reportDeprecatedGetterError(*exec, "TestObj", "immutablePoint");
1901         return throwGetterTypeError(*exec, "TestObj", "immutablePoint");
1902     }
1903     TestObj& impl = castedThis->impl();
1904     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePoint())));
1905     return JSValue::encode(result);
1906 }
1907
1908
1909 EncodedJSValue jsTestObjStrawberry(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1910 {
1911     UNUSED_PARAM(exec);
1912     UNUSED_PARAM(slotBase);
1913     UNUSED_PARAM(thisValue);
1914     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1915     if (UNLIKELY(!castedThis)) {
1916         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1917             return reportDeprecatedGetterError(*exec, "TestObj", "strawberry");
1918         return throwGetterTypeError(*exec, "TestObj", "strawberry");
1919     }
1920     TestObj& impl = castedThis->impl();
1921     JSValue result = jsNumber(impl.blueberry());
1922     return JSValue::encode(result);
1923 }
1924
1925
1926 EncodedJSValue jsTestObjStrictFloat(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1927 {
1928     UNUSED_PARAM(exec);
1929     UNUSED_PARAM(slotBase);
1930     UNUSED_PARAM(thisValue);
1931     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1932     if (UNLIKELY(!castedThis)) {
1933         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1934             return reportDeprecatedGetterError(*exec, "TestObj", "strictFloat");
1935         return throwGetterTypeError(*exec, "TestObj", "strictFloat");
1936     }
1937     TestObj& impl = castedThis->impl();
1938     JSValue result = jsNumber(impl.strictFloat());
1939     return JSValue::encode(result);
1940 }
1941
1942
1943 EncodedJSValue jsTestObjDescription(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1944 {
1945     UNUSED_PARAM(exec);
1946     UNUSED_PARAM(slotBase);
1947     UNUSED_PARAM(thisValue);
1948     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1949     if (UNLIKELY(!castedThis)) {
1950         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1951             return reportDeprecatedGetterError(*exec, "TestObj", "description");
1952         return throwGetterTypeError(*exec, "TestObj", "description");
1953     }
1954     TestObj& impl = castedThis->impl();
1955     JSValue result = jsNumber(impl.description());
1956     return JSValue::encode(result);
1957 }
1958
1959
1960 EncodedJSValue jsTestObjId(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1961 {
1962     UNUSED_PARAM(exec);
1963     UNUSED_PARAM(slotBase);
1964     UNUSED_PARAM(thisValue);
1965     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1966     if (UNLIKELY(!castedThis)) {
1967         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1968             return reportDeprecatedGetterError(*exec, "TestObj", "id");
1969         return throwGetterTypeError(*exec, "TestObj", "id");
1970     }
1971     TestObj& impl = castedThis->impl();
1972     JSValue result = jsNumber(impl.id());
1973     return JSValue::encode(result);
1974 }
1975
1976
1977 EncodedJSValue jsTestObjHash(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1978 {
1979     UNUSED_PARAM(exec);
1980     UNUSED_PARAM(slotBase);
1981     UNUSED_PARAM(thisValue);
1982     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1983     if (UNLIKELY(!castedThis)) {
1984         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
1985             return reportDeprecatedGetterError(*exec, "TestObj", "hash");
1986         return throwGetterTypeError(*exec, "TestObj", "hash");
1987     }
1988     TestObj& impl = castedThis->impl();
1989     JSValue result = jsStringWithCache(exec, impl.hash());
1990     return JSValue::encode(result);
1991 }
1992
1993
1994 EncodedJSValue jsTestObjReplaceableAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1995 {
1996     UNUSED_PARAM(exec);
1997     UNUSED_PARAM(slotBase);
1998     UNUSED_PARAM(thisValue);
1999     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2000     if (UNLIKELY(!castedThis)) {
2001         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
2002             return reportDeprecatedGetterError(*exec, "TestObj", "replaceableAttribute");
2003         return throwGetterTypeError(*exec, "TestObj", "replaceableAttribute");
2004     }
2005     TestObj& impl = castedThis->impl();
2006     JSValue result = jsNumber(impl.replaceableAttribute());
2007     return JSValue::encode(result);
2008 }
2009
2010
2011 EncodedJSValue jsTestObjNullableDoubleAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2012 {
2013     UNUSED_PARAM(exec);
2014     UNUSED_PARAM(slotBase);
2015     UNUSED_PARAM(thisValue);
2016     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2017     if (UNLIKELY(!castedThis)) {
2018         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
2019             return reportDeprecatedGetterError(*exec, "TestObj", "nullableDoubleAttribute");
2020         return throwGetterTypeError(*exec, "TestObj", "nullableDoubleAttribute");
2021     }
2022     bool isNull = false;
2023     TestObj& impl = castedThis->impl();
2024     JSValue result = jsNumber(impl.nullableDoubleAttribute(isNull));
2025     if (isNull)
2026         return JSValue::encode(jsNull());
2027     return JSValue::encode(result);
2028 }
2029
2030
2031 EncodedJSValue jsTestObjNullableLongAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2032 {
2033     UNUSED_PARAM(exec);
2034     UNUSED_PARAM(slotBase);
2035     UNUSED_PARAM(thisValue);
2036     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2037     if (UNLIKELY(!castedThis)) {
2038         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
2039             return reportDeprecatedGetterError(*exec, "TestObj", "nullableLongAttribute");
2040         return throwGetterTypeError(*exec, "TestObj", "nullableLongAttribute");
2041     }
2042     bool isNull = false;
2043     TestObj& impl = castedThis->impl();
2044     JSValue result = jsNumber(impl.nullableLongAttribute(isNull));
2045     if (isNull)
2046         return JSValue::encode(jsNull());
2047     return JSValue::encode(result);
2048 }
2049
2050
2051 EncodedJSValue jsTestObjNullableBooleanAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2052 {
2053     UNUSED_PARAM(exec);
2054     UNUSED_PARAM(slotBase);
2055     UNUSED_PARAM(thisValue);
2056     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2057     if (UNLIKELY(!castedThis)) {
2058         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
2059             return reportDeprecatedGetterError(*exec, "TestObj", "nullableBooleanAttribute");
2060         return throwGetterTypeError(*exec, "TestObj", "nullableBooleanAttribute");
2061     }
2062     bool isNull = false;
2063     TestObj& impl = castedThis->impl();
2064     JSValue result = jsBoolean(impl.nullableBooleanAttribute(isNull));
2065     if (isNull)
2066         return JSValue::encode(jsNull());
2067     return JSValue::encode(result);
2068 }
2069
2070
2071 EncodedJSValue jsTestObjNullableStringAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2072 {
2073     UNUSED_PARAM(exec);
2074     UNUSED_PARAM(slotBase);
2075     UNUSED_PARAM(thisValue);
2076     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2077     if (UNLIKELY(!castedThis)) {
2078         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
2079             return reportDeprecatedGetterError(*exec, "TestObj", "nullableStringAttribute");
2080         return throwGetterTypeError(*exec, "TestObj", "nullableStringAttribute");
2081     }
2082     bool isNull = false;
2083     TestObj& impl = castedThis->impl();
2084     JSValue result = jsStringWithCache(exec, impl.nullableStringAttribute(isNull));
2085     if (isNull)
2086         return JSValue::encode(jsNull());
2087     return JSValue::encode(result);
2088 }
2089
2090
2091 EncodedJSValue jsTestObjNullableLongSettableAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2092 {
2093     UNUSED_PARAM(exec);
2094     UNUSED_PARAM(slotBase);
2095     UNUSED_PARAM(thisValue);
2096     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2097     if (UNLIKELY(!castedThis)) {
2098         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
2099             return reportDeprecatedGetterError(*exec, "TestObj", "nullableLongSettableAttribute");
2100         return throwGetterTypeError(*exec, "TestObj", "nullableLongSettableAttribute");
2101     }
2102     bool isNull = false;
2103     TestObj& impl = castedThis->impl();
2104     JSValue result = jsNumber(impl.nullableLongSettableAttribute(isNull));
2105     if (isNull)
2106         return JSValue::encode(jsNull());
2107     return JSValue::encode(result);
2108 }
2109
2110
2111 EncodedJSValue jsTestObjNullableStringValue(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2112 {
2113     UNUSED_PARAM(exec);
2114     UNUSED_PARAM(slotBase);
2115     UNUSED_PARAM(thisValue);
2116     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2117     if (UNLIKELY(!castedThis)) {
2118         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
2119             return reportDeprecatedGetterError(*exec, "TestObj", "nullableStringValue");
2120         return throwGetterTypeError(*exec, "TestObj", "nullableStringValue");
2121     }
2122     ExceptionCode ec = 0;
2123     bool isNull = false;
2124     TestObj& impl = castedThis->impl();
2125     JSValue result = jsNumber(impl.nullableStringValue(isNull, ec));
2126     setDOMException(exec, ec);
2127     if (isNull)
2128         return JSValue::encode(jsNull());
2129     return JSValue::encode(result);
2130 }
2131
2132
2133 EncodedJSValue jsTestObjAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2134 {
2135     UNUSED_PARAM(exec);
2136     UNUSED_PARAM(slotBase);
2137     UNUSED_PARAM(thisValue);
2138     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2139     if (UNLIKELY(!castedThis)) {
2140         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
2141             return reportDeprecatedGetterError(*exec, "TestObj", "attribute");
2142         return throwGetterTypeError(*exec, "TestObj", "attribute");
2143     }
2144     TestObj& impl = castedThis->impl();
2145     JSValue result = jsStringWithCache(exec, impl.attribute());
2146     return JSValue::encode(result);
2147 }
2148
2149
2150 EncodedJSValue jsTestObjAttributeWithReservedEnumType(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2151 {
2152     UNUSED_PARAM(exec);
2153     UNUSED_PARAM(slotBase);
2154     UNUSED_PARAM(thisValue);
2155     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2156     if (UNLIKELY(!castedThis)) {
2157         if (jsDynamicCast<JSTestObjPrototype*>(slotBase))
2158             return reportDeprecatedGetterError(*exec, "TestObj", "attributeWithReservedEnumType");
2159         return throwGetterTypeError(*exec, "TestObj", "attributeWithReservedEnumType");
2160     }
2161     TestObj& impl = castedThis->impl();
2162     JSValue result = jsStringWithCache(exec, impl.attributeWithReservedEnumType());
2163     return JSValue::encode(result);
2164 }
2165
2166
2167 EncodedJSValue jsTestObjConstructor(ExecState* exec, JSObject* baseValue, EncodedJSValue, PropertyName)
2168 {
2169     JSTestObjPrototype* domObject = jsDynamicCast<JSTestObjPrototype*>(baseValue);
2170     if (!domObject)
2171         return throwVMTypeError(exec);
2172     return JSValue::encode(JSTestObj::getConstructor(exec->vm(), domObject->globalObject()));
2173 }
2174
2175 void setJSTestObjConstructorStaticStringAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue, EncodedJSValue encodedValue)
2176 {
2177     JSValue value = JSValue::decode(encodedValue);
2178     UNUSED_PARAM(baseObject);
2179     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
2180     if (UNLIKELY(exec->hadException()))
2181         return;
2182     TestObj::setStaticStringAttr(nativeValue);
2183 }
2184
2185
2186 void setJSTestObjTestSubObjEnabledBySettingConstructor(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2187 {
2188     JSValue value = JSValue::decode(encodedValue);
2189     UNUSED_PARAM(baseObject);
2190     UNUSED_PARAM(thisValue);
2191     JSTestObj* castedThis = jsCast<JSTestObj*>(baseObject);
2192     UNUSED_PARAM(thisValue);
2193     UNUSED_PARAM(exec);
2194     // Shadowing a built-in constructor
2195     castedThis->putDirect(exec->vm(), Identifier(exec, "TestSubObjEnabledBySetting"), value);
2196 }
2197
2198
2199 void setJSTestObjEnumAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2200 {
2201     JSValue value = JSValue::decode(encodedValue);
2202     UNUSED_PARAM(baseObject);
2203     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2204     if (UNLIKELY(!castedThis)) {
2205         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2206             reportDeprecatedSetterError(*exec, "TestObj", "enumAttr");
2207         else
2208             throwSetterTypeError(*exec, "TestObj", "enumAttr");
2209         return;
2210     }
2211     TestObj& impl = castedThis->impl();
2212     const String nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
2213     if (UNLIKELY(exec->hadException()))
2214         return;
2215     if (nativeValue != "" && nativeValue != "EnumValue1" && nativeValue != "EnumValue2" && nativeValue != "EnumValue3")
2216         return;
2217     impl.setEnumAttr(nativeValue);
2218 }
2219
2220
2221 void setJSTestObjByteAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2222 {
2223     JSValue value = JSValue::decode(encodedValue);
2224     UNUSED_PARAM(baseObject);
2225     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2226     if (UNLIKELY(!castedThis)) {
2227         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2228             reportDeprecatedSetterError(*exec, "TestObj", "byteAttr");
2229         else
2230             throwSetterTypeError(*exec, "TestObj", "byteAttr");
2231         return;
2232     }
2233     TestObj& impl = castedThis->impl();
2234     int8_t nativeValue(toInt8(exec, value, NormalConversion));
2235     if (UNLIKELY(exec->hadException()))
2236         return;
2237     impl.setByteAttr(nativeValue);
2238 }
2239
2240
2241 void setJSTestObjOctetAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2242 {
2243     JSValue value = JSValue::decode(encodedValue);
2244     UNUSED_PARAM(baseObject);
2245     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2246     if (UNLIKELY(!castedThis)) {
2247         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2248             reportDeprecatedSetterError(*exec, "TestObj", "octetAttr");
2249         else
2250             throwSetterTypeError(*exec, "TestObj", "octetAttr");
2251         return;
2252     }
2253     TestObj& impl = castedThis->impl();
2254     uint8_t nativeValue(toUInt8(exec, value, NormalConversion));
2255     if (UNLIKELY(exec->hadException()))
2256         return;
2257     impl.setOctetAttr(nativeValue);
2258 }
2259
2260
2261 void setJSTestObjShortAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2262 {
2263     JSValue value = JSValue::decode(encodedValue);
2264     UNUSED_PARAM(baseObject);
2265     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2266     if (UNLIKELY(!castedThis)) {
2267         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2268             reportDeprecatedSetterError(*exec, "TestObj", "shortAttr");
2269         else
2270             throwSetterTypeError(*exec, "TestObj", "shortAttr");
2271         return;
2272     }
2273     TestObj& impl = castedThis->impl();
2274     int16_t nativeValue(toInt16(exec, value, NormalConversion));
2275     if (UNLIKELY(exec->hadException()))
2276         return;
2277     impl.setShortAttr(nativeValue);
2278 }
2279
2280
2281 void setJSTestObjUnsignedShortAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2282 {
2283     JSValue value = JSValue::decode(encodedValue);
2284     UNUSED_PARAM(baseObject);
2285     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2286     if (UNLIKELY(!castedThis)) {
2287         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2288             reportDeprecatedSetterError(*exec, "TestObj", "unsignedShortAttr");
2289         else
2290             throwSetterTypeError(*exec, "TestObj", "unsignedShortAttr");
2291         return;
2292     }
2293     TestObj& impl = castedThis->impl();
2294     uint16_t nativeValue(toUInt16(exec, value, NormalConversion));
2295     if (UNLIKELY(exec->hadException()))
2296         return;
2297     impl.setUnsignedShortAttr(nativeValue);
2298 }
2299
2300
2301 void setJSTestObjLongAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2302 {
2303     JSValue value = JSValue::decode(encodedValue);
2304     UNUSED_PARAM(baseObject);
2305     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2306     if (UNLIKELY(!castedThis)) {
2307         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2308             reportDeprecatedSetterError(*exec, "TestObj", "longAttr");
2309         else
2310             throwSetterTypeError(*exec, "TestObj", "longAttr");
2311         return;
2312     }
2313     TestObj& impl = castedThis->impl();
2314     int nativeValue(toInt32(exec, value, NormalConversion));
2315     if (UNLIKELY(exec->hadException()))
2316         return;
2317     impl.setLongAttr(nativeValue);
2318 }
2319
2320
2321 void setJSTestObjLongLongAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2322 {
2323     JSValue value = JSValue::decode(encodedValue);
2324     UNUSED_PARAM(baseObject);
2325     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2326     if (UNLIKELY(!castedThis)) {
2327         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2328             reportDeprecatedSetterError(*exec, "TestObj", "longLongAttr");
2329         else
2330             throwSetterTypeError(*exec, "TestObj", "longLongAttr");
2331         return;
2332     }
2333     TestObj& impl = castedThis->impl();
2334     long long nativeValue(toInt64(exec, value, NormalConversion));
2335     if (UNLIKELY(exec->hadException()))
2336         return;
2337     impl.setLongLongAttr(nativeValue);
2338 }
2339
2340
2341 void setJSTestObjUnsignedLongLongAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2342 {
2343     JSValue value = JSValue::decode(encodedValue);
2344     UNUSED_PARAM(baseObject);
2345     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2346     if (UNLIKELY(!castedThis)) {
2347         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2348             reportDeprecatedSetterError(*exec, "TestObj", "unsignedLongLongAttr");
2349         else
2350             throwSetterTypeError(*exec, "TestObj", "unsignedLongLongAttr");
2351         return;
2352     }
2353     TestObj& impl = castedThis->impl();
2354     unsigned long long nativeValue(toUInt64(exec, value, NormalConversion));
2355     if (UNLIKELY(exec->hadException()))
2356         return;
2357     impl.setUnsignedLongLongAttr(nativeValue);
2358 }
2359
2360
2361 void setJSTestObjStringAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2362 {
2363     JSValue value = JSValue::decode(encodedValue);
2364     UNUSED_PARAM(baseObject);
2365     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2366     if (UNLIKELY(!castedThis)) {
2367         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2368             reportDeprecatedSetterError(*exec, "TestObj", "stringAttr");
2369         else
2370             throwSetterTypeError(*exec, "TestObj", "stringAttr");
2371         return;
2372     }
2373     TestObj& impl = castedThis->impl();
2374     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
2375     if (UNLIKELY(exec->hadException()))
2376         return;
2377     impl.setStringAttr(nativeValue);
2378 }
2379
2380
2381 void setJSTestObjTestObjAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2382 {
2383     JSValue value = JSValue::decode(encodedValue);
2384     UNUSED_PARAM(baseObject);
2385     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2386     if (UNLIKELY(!castedThis)) {
2387         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2388             reportDeprecatedSetterError(*exec, "TestObj", "testObjAttr");
2389         else
2390             throwSetterTypeError(*exec, "TestObj", "testObjAttr");
2391         return;
2392     }
2393     TestObj& impl = castedThis->impl();
2394     TestObj* nativeValue(toTestObj(value));
2395     if (UNLIKELY(exec->hadException()))
2396         return;
2397     impl.setTestObjAttr(nativeValue);
2398 }
2399
2400
2401 void setJSTestObjXMLObjAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2402 {
2403     JSValue value = JSValue::decode(encodedValue);
2404     UNUSED_PARAM(baseObject);
2405     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2406     if (UNLIKELY(!castedThis)) {
2407         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2408             reportDeprecatedSetterError(*exec, "TestObj", "XMLObjAttr");
2409         else
2410             throwSetterTypeError(*exec, "TestObj", "XMLObjAttr");
2411         return;
2412     }
2413     TestObj& impl = castedThis->impl();
2414     TestObj* nativeValue(toTestObj(value));
2415     if (UNLIKELY(exec->hadException()))
2416         return;
2417     impl.setXMLObjAttr(nativeValue);
2418 }
2419
2420
2421 void setJSTestObjCreate(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2422 {
2423     JSValue value = JSValue::decode(encodedValue);
2424     UNUSED_PARAM(baseObject);
2425     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2426     if (UNLIKELY(!castedThis)) {
2427         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2428             reportDeprecatedSetterError(*exec, "TestObj", "create");
2429         else
2430             throwSetterTypeError(*exec, "TestObj", "create");
2431         return;
2432     }
2433     TestObj& impl = castedThis->impl();
2434     bool nativeValue(value.toBoolean(exec));
2435     if (UNLIKELY(exec->hadException()))
2436         return;
2437     impl.setCreate(nativeValue);
2438 }
2439
2440
2441 void setJSTestObjReflectedStringAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2442 {
2443     JSValue value = JSValue::decode(encodedValue);
2444     UNUSED_PARAM(baseObject);
2445     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2446     if (UNLIKELY(!castedThis)) {
2447         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2448             reportDeprecatedSetterError(*exec, "TestObj", "reflectedStringAttr");
2449         else
2450             throwSetterTypeError(*exec, "TestObj", "reflectedStringAttr");
2451         return;
2452     }
2453     TestObj& impl = castedThis->impl();
2454     const String& nativeValue(valueToStringWithNullCheck(exec, value));
2455     if (UNLIKELY(exec->hadException()))
2456         return;
2457     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedstringattrAttr, nativeValue);
2458 }
2459
2460
2461 void setJSTestObjReflectedIntegralAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2462 {
2463     JSValue value = JSValue::decode(encodedValue);
2464     UNUSED_PARAM(baseObject);
2465     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2466     if (UNLIKELY(!castedThis)) {
2467         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2468             reportDeprecatedSetterError(*exec, "TestObj", "reflectedIntegralAttr");
2469         else
2470             throwSetterTypeError(*exec, "TestObj", "reflectedIntegralAttr");
2471         return;
2472     }
2473     TestObj& impl = castedThis->impl();
2474     int nativeValue(toInt32(exec, value, NormalConversion));
2475     if (UNLIKELY(exec->hadException()))
2476         return;
2477     impl.setIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr, nativeValue);
2478 }
2479
2480
2481 void setJSTestObjReflectedUnsignedIntegralAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2482 {
2483     JSValue value = JSValue::decode(encodedValue);
2484     UNUSED_PARAM(baseObject);
2485     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2486     if (UNLIKELY(!castedThis)) {
2487         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2488             reportDeprecatedSetterError(*exec, "TestObj", "reflectedUnsignedIntegralAttr");
2489         else
2490             throwSetterTypeError(*exec, "TestObj", "reflectedUnsignedIntegralAttr");
2491         return;
2492     }
2493     TestObj& impl = castedThis->impl();
2494     unsigned nativeValue(toUInt32(exec, value, NormalConversion));
2495     if (UNLIKELY(exec->hadException()))
2496         return;
2497     impl.setUnsignedIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr, nativeValue);
2498 }
2499
2500
2501 void setJSTestObjReflectedBooleanAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2502 {
2503     JSValue value = JSValue::decode(encodedValue);
2504     UNUSED_PARAM(baseObject);
2505     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2506     if (UNLIKELY(!castedThis)) {
2507         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2508             reportDeprecatedSetterError(*exec, "TestObj", "reflectedBooleanAttr");
2509         else
2510             throwSetterTypeError(*exec, "TestObj", "reflectedBooleanAttr");
2511         return;
2512     }
2513     TestObj& impl = castedThis->impl();
2514     bool nativeValue(value.toBoolean(exec));
2515     if (UNLIKELY(exec->hadException()))
2516         return;
2517     impl.setBooleanAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr, nativeValue);
2518 }
2519
2520
2521 void setJSTestObjReflectedURLAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2522 {
2523     JSValue value = JSValue::decode(encodedValue);
2524     UNUSED_PARAM(baseObject);
2525     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2526     if (UNLIKELY(!castedThis)) {
2527         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2528             reportDeprecatedSetterError(*exec, "TestObj", "reflectedURLAttr");
2529         else
2530             throwSetterTypeError(*exec, "TestObj", "reflectedURLAttr");
2531         return;
2532     }
2533     TestObj& impl = castedThis->impl();
2534     const String& nativeValue(valueToStringWithNullCheck(exec, value));
2535     if (UNLIKELY(exec->hadException()))
2536         return;
2537     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedurlattrAttr, nativeValue);
2538 }
2539
2540
2541 void setJSTestObjReflectedStringAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2542 {
2543     JSValue value = JSValue::decode(encodedValue);
2544     UNUSED_PARAM(baseObject);
2545     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2546     if (UNLIKELY(!castedThis)) {
2547         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2548             reportDeprecatedSetterError(*exec, "TestObj", "reflectedStringAttr");
2549         else
2550             throwSetterTypeError(*exec, "TestObj", "reflectedStringAttr");
2551         return;
2552     }
2553     TestObj& impl = castedThis->impl();
2554     const String& nativeValue(valueToStringWithNullCheck(exec, value));
2555     if (UNLIKELY(exec->hadException()))
2556         return;
2557     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::customContentStringAttrAttr, nativeValue);
2558 }
2559
2560
2561 void setJSTestObjReflectedCustomIntegralAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2562 {
2563     JSValue value = JSValue::decode(encodedValue);
2564     UNUSED_PARAM(baseObject);
2565     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2566     if (UNLIKELY(!castedThis)) {
2567         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2568             reportDeprecatedSetterError(*exec, "TestObj", "reflectedCustomIntegralAttr");
2569         else
2570             throwSetterTypeError(*exec, "TestObj", "reflectedCustomIntegralAttr");
2571         return;
2572     }
2573     TestObj& impl = castedThis->impl();
2574     int nativeValue(toInt32(exec, value, NormalConversion));
2575     if (UNLIKELY(exec->hadException()))
2576         return;
2577     impl.setIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr, nativeValue);
2578 }
2579
2580
2581 void setJSTestObjReflectedCustomBooleanAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2582 {
2583     JSValue value = JSValue::decode(encodedValue);
2584     UNUSED_PARAM(baseObject);
2585     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2586     if (UNLIKELY(!castedThis)) {
2587         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2588             reportDeprecatedSetterError(*exec, "TestObj", "reflectedCustomBooleanAttr");
2589         else
2590             throwSetterTypeError(*exec, "TestObj", "reflectedCustomBooleanAttr");
2591         return;
2592     }
2593     TestObj& impl = castedThis->impl();
2594     bool nativeValue(value.toBoolean(exec));
2595     if (UNLIKELY(exec->hadException()))
2596         return;
2597     impl.setBooleanAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr, nativeValue);
2598 }
2599
2600
2601 void setJSTestObjReflectedCustomURLAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2602 {
2603     JSValue value = JSValue::decode(encodedValue);
2604     UNUSED_PARAM(baseObject);
2605     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2606     if (UNLIKELY(!castedThis)) {
2607         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2608             reportDeprecatedSetterError(*exec, "TestObj", "reflectedCustomURLAttr");
2609         else
2610             throwSetterTypeError(*exec, "TestObj", "reflectedCustomURLAttr");
2611         return;
2612     }
2613     TestObj& impl = castedThis->impl();
2614     const String& nativeValue(valueToStringWithNullCheck(exec, value));
2615     if (UNLIKELY(exec->hadException()))
2616         return;
2617     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::customContentURLAttrAttr, nativeValue);
2618 }
2619
2620
2621 void setJSTestObjTypedArrayAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2622 {
2623     JSValue value = JSValue::decode(encodedValue);
2624     UNUSED_PARAM(baseObject);
2625     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2626     if (UNLIKELY(!castedThis)) {
2627         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2628             reportDeprecatedSetterError(*exec, "TestObj", "typedArrayAttr");
2629         else
2630             throwSetterTypeError(*exec, "TestObj", "typedArrayAttr");
2631         return;
2632     }
2633     TestObj& impl = castedThis->impl();
2634     RefPtr<Float32Array> nativeValue(toFloat32Array(value));
2635     if (UNLIKELY(exec->hadException()))
2636         return;
2637     impl.setTypedArrayAttr(nativeValue.get());
2638 }
2639
2640
2641 void setJSTestObjAttrWithGetterException(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2642 {
2643     JSValue value = JSValue::decode(encodedValue);
2644     UNUSED_PARAM(baseObject);
2645     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2646     if (UNLIKELY(!castedThis)) {
2647         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2648             reportDeprecatedSetterError(*exec, "TestObj", "attrWithGetterException");
2649         else
2650             throwSetterTypeError(*exec, "TestObj", "attrWithGetterException");
2651         return;
2652     }
2653     TestObj& impl = castedThis->impl();
2654     int nativeValue(toInt32(exec, value, NormalConversion));
2655     if (UNLIKELY(exec->hadException()))
2656         return;
2657     impl.setAttrWithGetterException(nativeValue);
2658 }
2659
2660
2661 void setJSTestObjAttrWithSetterException(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2662 {
2663     JSValue value = JSValue::decode(encodedValue);
2664     UNUSED_PARAM(baseObject);
2665     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2666     if (UNLIKELY(!castedThis)) {
2667         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2668             reportDeprecatedSetterError(*exec, "TestObj", "attrWithSetterException");
2669         else
2670             throwSetterTypeError(*exec, "TestObj", "attrWithSetterException");
2671         return;
2672     }
2673     TestObj& impl = castedThis->impl();
2674     ExceptionCode ec = 0;
2675     int nativeValue(toInt32(exec, value, NormalConversion));
2676     if (UNLIKELY(exec->hadException()))
2677         return;
2678     impl.setAttrWithSetterException(nativeValue, ec);
2679     setDOMException(exec, ec);
2680 }
2681
2682
2683 void setJSTestObjStringAttrWithGetterException(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2684 {
2685     JSValue value = JSValue::decode(encodedValue);
2686     UNUSED_PARAM(baseObject);
2687     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2688     if (UNLIKELY(!castedThis)) {
2689         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2690             reportDeprecatedSetterError(*exec, "TestObj", "stringAttrWithGetterException");
2691         else
2692             throwSetterTypeError(*exec, "TestObj", "stringAttrWithGetterException");
2693         return;
2694     }
2695     TestObj& impl = castedThis->impl();
2696     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
2697     if (UNLIKELY(exec->hadException()))
2698         return;
2699     impl.setStringAttrWithGetterException(nativeValue);
2700 }
2701
2702
2703 void setJSTestObjStringAttrWithSetterException(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2704 {
2705     JSValue value = JSValue::decode(encodedValue);
2706     UNUSED_PARAM(baseObject);
2707     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2708     if (UNLIKELY(!castedThis)) {
2709         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2710             reportDeprecatedSetterError(*exec, "TestObj", "stringAttrWithSetterException");
2711         else
2712             throwSetterTypeError(*exec, "TestObj", "stringAttrWithSetterException");
2713         return;
2714     }
2715     TestObj& impl = castedThis->impl();
2716     ExceptionCode ec = 0;
2717     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
2718     if (UNLIKELY(exec->hadException()))
2719         return;
2720     impl.setStringAttrWithSetterException(nativeValue, ec);
2721     setDOMException(exec, ec);
2722 }
2723
2724
2725 void setJSTestObjCustomAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2726 {
2727     JSValue value = JSValue::decode(encodedValue);
2728     UNUSED_PARAM(baseObject);
2729     UNUSED_PARAM(thisValue);
2730     JSTestObj* castedThis = jsCast<JSTestObj*>(baseObject);
2731     UNUSED_PARAM(thisValue);
2732     UNUSED_PARAM(exec);
2733     castedThis->setCustomAttr(exec, value);
2734 }
2735
2736
2737 void setJSTestObjWithScriptStateAttribute(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2738 {
2739     JSValue value = JSValue::decode(encodedValue);
2740     UNUSED_PARAM(baseObject);
2741     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2742     if (UNLIKELY(!castedThis)) {
2743         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2744             reportDeprecatedSetterError(*exec, "TestObj", "withScriptStateAttribute");
2745         else
2746             throwSetterTypeError(*exec, "TestObj", "withScriptStateAttribute");
2747         return;
2748     }
2749     TestObj& impl = castedThis->impl();
2750     int nativeValue(toInt32(exec, value, NormalConversion));
2751     if (UNLIKELY(exec->hadException()))
2752         return;
2753     impl.setWithScriptStateAttribute(exec, nativeValue);
2754 }
2755
2756
2757 void setJSTestObjWithScriptExecutionContextAttribute(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2758 {
2759     JSValue value = JSValue::decode(encodedValue);
2760     UNUSED_PARAM(baseObject);
2761     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2762     if (UNLIKELY(!castedThis)) {
2763         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2764             reportDeprecatedSetterError(*exec, "TestObj", "withScriptExecutionContextAttribute");
2765         else
2766             throwSetterTypeError(*exec, "TestObj", "withScriptExecutionContextAttribute");
2767         return;
2768     }
2769     TestObj& impl = castedThis->impl();
2770     TestObj* nativeValue(toTestObj(value));
2771     if (UNLIKELY(exec->hadException()))
2772         return;
2773     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2774     if (!scriptContext)
2775         return;
2776     impl.setWithScriptExecutionContextAttribute(scriptContext, nativeValue);
2777 }
2778
2779
2780 void setJSTestObjWithScriptStateAttributeRaises(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2781 {
2782     JSValue value = JSValue::decode(encodedValue);
2783     UNUSED_PARAM(baseObject);
2784     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2785     if (UNLIKELY(!castedThis)) {
2786         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2787             reportDeprecatedSetterError(*exec, "TestObj", "withScriptStateAttributeRaises");
2788         else
2789             throwSetterTypeError(*exec, "TestObj", "withScriptStateAttributeRaises");
2790         return;
2791     }
2792     TestObj& impl = castedThis->impl();
2793     TestObj* nativeValue(toTestObj(value));
2794     if (UNLIKELY(exec->hadException()))
2795         return;
2796     impl.setWithScriptStateAttributeRaises(exec, nativeValue);
2797 }
2798
2799
2800 void setJSTestObjWithScriptExecutionContextAttributeRaises(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2801 {
2802     JSValue value = JSValue::decode(encodedValue);
2803     UNUSED_PARAM(baseObject);
2804     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2805     if (UNLIKELY(!castedThis)) {
2806         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2807             reportDeprecatedSetterError(*exec, "TestObj", "withScriptExecutionContextAttributeRaises");
2808         else
2809             throwSetterTypeError(*exec, "TestObj", "withScriptExecutionContextAttributeRaises");
2810         return;
2811     }
2812     TestObj& impl = castedThis->impl();
2813     TestObj* nativeValue(toTestObj(value));
2814     if (UNLIKELY(exec->hadException()))
2815         return;
2816     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2817     if (!scriptContext)
2818         return;
2819     impl.setWithScriptExecutionContextAttributeRaises(scriptContext, nativeValue);
2820 }
2821
2822
2823 void setJSTestObjWithScriptExecutionContextAndScriptStateAttribute(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2824 {
2825     JSValue value = JSValue::decode(encodedValue);
2826     UNUSED_PARAM(baseObject);
2827     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2828     if (UNLIKELY(!castedThis)) {
2829         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2830             reportDeprecatedSetterError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateAttribute");
2831         else
2832             throwSetterTypeError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateAttribute");
2833         return;
2834     }
2835     TestObj& impl = castedThis->impl();
2836     TestObj* nativeValue(toTestObj(value));
2837     if (UNLIKELY(exec->hadException()))
2838         return;
2839     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2840     if (!scriptContext)
2841         return;
2842     impl.setWithScriptExecutionContextAndScriptStateAttribute(exec, scriptContext, nativeValue);
2843 }
2844
2845
2846 void setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2847 {
2848     JSValue value = JSValue::decode(encodedValue);
2849     UNUSED_PARAM(baseObject);
2850     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2851     if (UNLIKELY(!castedThis)) {
2852         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2853             reportDeprecatedSetterError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateAttributeRaises");
2854         else
2855             throwSetterTypeError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateAttributeRaises");
2856         return;
2857     }
2858     TestObj& impl = castedThis->impl();
2859     TestObj* nativeValue(toTestObj(value));
2860     if (UNLIKELY(exec->hadException()))
2861         return;
2862     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2863     if (!scriptContext)
2864         return;
2865     impl.setWithScriptExecutionContextAndScriptStateAttributeRaises(exec, scriptContext, nativeValue);
2866 }
2867
2868
2869 void setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2870 {
2871     JSValue value = JSValue::decode(encodedValue);
2872     UNUSED_PARAM(baseObject);
2873     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2874     if (UNLIKELY(!castedThis)) {
2875         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2876             reportDeprecatedSetterError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateWithSpacesAttribute");
2877         else
2878             throwSetterTypeError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateWithSpacesAttribute");
2879         return;
2880     }
2881     TestObj& impl = castedThis->impl();
2882     TestObj* nativeValue(toTestObj(value));
2883     if (UNLIKELY(exec->hadException()))
2884         return;
2885     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2886     if (!scriptContext)
2887         return;
2888     impl.setWithScriptExecutionContextAndScriptStateWithSpacesAttribute(exec, scriptContext, nativeValue);
2889 }
2890
2891
2892 void setJSTestObjWithScriptArgumentsAndCallStackAttribute(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2893 {
2894     JSValue value = JSValue::decode(encodedValue);
2895     UNUSED_PARAM(baseObject);
2896     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2897     if (UNLIKELY(!castedThis)) {
2898         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2899             reportDeprecatedSetterError(*exec, "TestObj", "withScriptArgumentsAndCallStackAttribute");
2900         else
2901             throwSetterTypeError(*exec, "TestObj", "withScriptArgumentsAndCallStackAttribute");
2902         return;
2903     }
2904     TestObj& impl = castedThis->impl();
2905     TestObj* nativeValue(toTestObj(value));
2906     if (UNLIKELY(exec->hadException()))
2907         return;
2908     impl.setWithScriptArgumentsAndCallStackAttribute(nativeValue);
2909 }
2910
2911
2912 #if ENABLE(Condition1)
2913 void setJSTestObjConditionalAttr1(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2914 {
2915     JSValue value = JSValue::decode(encodedValue);
2916     UNUSED_PARAM(baseObject);
2917     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2918     if (UNLIKELY(!castedThis)) {
2919         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2920             reportDeprecatedSetterError(*exec, "TestObj", "conditionalAttr1");
2921         else
2922             throwSetterTypeError(*exec, "TestObj", "conditionalAttr1");
2923         return;
2924     }
2925     TestObj& impl = castedThis->impl();
2926     int nativeValue(toInt32(exec, value, NormalConversion));
2927     if (UNLIKELY(exec->hadException()))
2928         return;
2929     impl.setConditionalAttr1(nativeValue);
2930 }
2931
2932 #endif
2933
2934 #if ENABLE(Condition1) && ENABLE(Condition2)
2935 void setJSTestObjConditionalAttr2(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2936 {
2937     JSValue value = JSValue::decode(encodedValue);
2938     UNUSED_PARAM(baseObject);
2939     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2940     if (UNLIKELY(!castedThis)) {
2941         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2942             reportDeprecatedSetterError(*exec, "TestObj", "conditionalAttr2");
2943         else
2944             throwSetterTypeError(*exec, "TestObj", "conditionalAttr2");
2945         return;
2946     }
2947     TestObj& impl = castedThis->impl();
2948     int nativeValue(toInt32(exec, value, NormalConversion));
2949     if (UNLIKELY(exec->hadException()))
2950         return;
2951     impl.setConditionalAttr2(nativeValue);
2952 }
2953
2954 #endif
2955
2956 #if ENABLE(Condition1) || ENABLE(Condition2)
2957 void setJSTestObjConditionalAttr3(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2958 {
2959     JSValue value = JSValue::decode(encodedValue);
2960     UNUSED_PARAM(baseObject);
2961     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2962     if (UNLIKELY(!castedThis)) {
2963         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
2964             reportDeprecatedSetterError(*exec, "TestObj", "conditionalAttr3");
2965         else
2966             throwSetterTypeError(*exec, "TestObj", "conditionalAttr3");
2967         return;
2968     }
2969     TestObj& impl = castedThis->impl();
2970     int nativeValue(toInt32(exec, value, NormalConversion));
2971     if (UNLIKELY(exec->hadException()))
2972         return;
2973     impl.setConditionalAttr3(nativeValue);
2974 }
2975
2976 #endif
2977
2978 #if ENABLE(Condition1)
2979 void setJSTestObjConditionalAttr4Constructor(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2980 {
2981     JSValue value = JSValue::decode(encodedValue);
2982     UNUSED_PARAM(baseObject);
2983     UNUSED_PARAM(thisValue);
2984     JSTestObj* castedThis = jsCast<JSTestObj*>(baseObject);
2985     UNUSED_PARAM(thisValue);
2986     UNUSED_PARAM(exec);
2987     // Shadowing a built-in constructor
2988     castedThis->putDirect(exec->vm(), Identifier(exec, "conditionalAttr4"), value);
2989 }
2990
2991 #endif
2992
2993 #if ENABLE(Condition1) && ENABLE(Condition2)
2994 void setJSTestObjConditionalAttr5Constructor(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2995 {
2996     JSValue value = JSValue::decode(encodedValue);
2997     UNUSED_PARAM(baseObject);
2998     UNUSED_PARAM(thisValue);
2999     JSTestObj* castedThis = jsCast<JSTestObj*>(baseObject);
3000     UNUSED_PARAM(thisValue);
3001     UNUSED_PARAM(exec);
3002     // Shadowing a built-in constructor
3003     castedThis->putDirect(exec->vm(), Identifier(exec, "conditionalAttr5"), value);
3004 }
3005
3006 #endif
3007
3008 #if ENABLE(Condition1) || ENABLE(Condition2)
3009 void setJSTestObjConditionalAttr6Constructor(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3010 {
3011     JSValue value = JSValue::decode(encodedValue);
3012     UNUSED_PARAM(baseObject);
3013     UNUSED_PARAM(thisValue);
3014     JSTestObj* castedThis = jsCast<JSTestObj*>(baseObject);
3015     UNUSED_PARAM(thisValue);
3016     UNUSED_PARAM(exec);
3017     // Shadowing a built-in constructor
3018     castedThis->putDirect(exec->vm(), Identifier(exec, "conditionalAttr6"), value);
3019 }
3020
3021 #endif
3022
3023 void setJSTestObjAnyAttribute(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3024 {
3025     JSValue value = JSValue::decode(encodedValue);
3026     UNUSED_PARAM(baseObject);
3027     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3028     if (UNLIKELY(!castedThis)) {
3029         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
3030             reportDeprecatedSetterError(*exec, "TestObj", "anyAttribute");
3031         else
3032             throwSetterTypeError(*exec, "TestObj", "anyAttribute");
3033         return;
3034     }
3035     TestObj& impl = castedThis->impl();
3036     Deprecated::ScriptValue nativeValue(exec->vm(), value);
3037     if (UNLIKELY(exec->hadException()))
3038         return;
3039     impl.setAnyAttribute(nativeValue);
3040 }
3041
3042
3043 void setJSTestObjMutablePoint(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3044 {
3045     JSValue value = JSValue::decode(encodedValue);
3046     UNUSED_PARAM(baseObject);
3047     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3048     if (UNLIKELY(!castedThis)) {
3049         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
3050             reportDeprecatedSetterError(*exec, "TestObj", "mutablePoint");
3051         else
3052             throwSetterTypeError(*exec, "TestObj", "mutablePoint");
3053         return;
3054     }
3055     TestObj& impl = castedThis->impl();
3056     SVGPropertyTearOff<SVGPoint>* nativeValue(toSVGPoint(value));
3057     if (UNLIKELY(exec->hadException()))
3058         return;
3059     impl.setMutablePoint(nativeValue);
3060 }
3061
3062
3063 void setJSTestObjImmutablePoint(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3064 {
3065     JSValue value = JSValue::decode(encodedValue);
3066     UNUSED_PARAM(baseObject);
3067     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3068     if (UNLIKELY(!castedThis)) {
3069         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
3070             reportDeprecatedSetterError(*exec, "TestObj", "immutablePoint");
3071         else
3072             throwSetterTypeError(*exec, "TestObj", "immutablePoint");
3073         return;
3074     }
3075     TestObj& impl = castedThis->impl();
3076     SVGPropertyTearOff<SVGPoint>* nativeValue(toSVGPoint(value));
3077     if (UNLIKELY(exec->hadException()))
3078         return;
3079     impl.setImmutablePoint(nativeValue);
3080 }
3081
3082
3083 void setJSTestObjStrawberry(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3084 {
3085     JSValue value = JSValue::decode(encodedValue);
3086     UNUSED_PARAM(baseObject);
3087     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3088     if (UNLIKELY(!castedThis)) {
3089         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
3090             reportDeprecatedSetterError(*exec, "TestObj", "strawberry");
3091         else
3092             throwSetterTypeError(*exec, "TestObj", "strawberry");
3093         return;
3094     }
3095     TestObj& impl = castedThis->impl();
3096     int nativeValue(toInt32(exec, value, NormalConversion));
3097     if (UNLIKELY(exec->hadException()))
3098         return;
3099     impl.setBlueberry(nativeValue);
3100 }
3101
3102
3103 void setJSTestObjStrictFloat(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3104 {
3105     JSValue value = JSValue::decode(encodedValue);
3106     UNUSED_PARAM(baseObject);
3107     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3108     if (UNLIKELY(!castedThis)) {
3109         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
3110             reportDeprecatedSetterError(*exec, "TestObj", "strictFloat");
3111         else
3112             throwSetterTypeError(*exec, "TestObj", "strictFloat");
3113         return;
3114     }
3115     TestObj& impl = castedThis->impl();
3116     float nativeValue(value.toFloat(exec));
3117     if (UNLIKELY(exec->hadException()))
3118         return;
3119     impl.setStrictFloat(nativeValue);
3120 }
3121
3122
3123 void setJSTestObjId(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3124 {
3125     JSValue value = JSValue::decode(encodedValue);
3126     UNUSED_PARAM(baseObject);
3127     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3128     if (UNLIKELY(!castedThis)) {
3129         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
3130             reportDeprecatedSetterError(*exec, "TestObj", "id");
3131         else
3132             throwSetterTypeError(*exec, "TestObj", "id");
3133         return;
3134     }
3135     TestObj& impl = castedThis->impl();
3136     int nativeValue(toInt32(exec, value, NormalConversion));
3137     if (UNLIKELY(exec->hadException()))
3138         return;
3139     impl.setId(nativeValue);
3140 }
3141
3142
3143 void setJSTestObjReplaceableAttribute(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3144 {
3145     JSValue value = JSValue::decode(encodedValue);
3146     UNUSED_PARAM(baseObject);
3147     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3148     if (UNLIKELY(!castedThis)) {
3149         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
3150             reportDeprecatedSetterError(*exec, "TestObj", "replaceableAttribute");
3151         else
3152             throwSetterTypeError(*exec, "TestObj", "replaceableAttribute");
3153         return;
3154     }
3155     // Shadowing a built-in object
3156     castedThis->putDirect(exec->vm(), Identifier(exec, "replaceableAttribute"), value);
3157 }
3158
3159
3160 void setJSTestObjNullableLongSettableAttribute(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3161 {
3162     JSValue value = JSValue::decode(encodedValue);
3163     UNUSED_PARAM(baseObject);
3164     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3165     if (UNLIKELY(!castedThis)) {
3166         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
3167             reportDeprecatedSetterError(*exec, "TestObj", "nullableLongSettableAttribute");
3168         else
3169             throwSetterTypeError(*exec, "TestObj", "nullableLongSettableAttribute");
3170         return;
3171     }
3172     TestObj& impl = castedThis->impl();
3173     int nativeValue(toInt32(exec, value, NormalConversion));
3174     if (UNLIKELY(exec->hadException()))
3175         return;
3176     impl.setNullableLongSettableAttribute(nativeValue);
3177 }
3178
3179
3180 void setJSTestObjNullableStringValue(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3181 {
3182     JSValue value = JSValue::decode(encodedValue);
3183     UNUSED_PARAM(baseObject);
3184     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3185     if (UNLIKELY(!castedThis)) {
3186         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
3187             reportDeprecatedSetterError(*exec, "TestObj", "nullableStringValue");
3188         else
3189             throwSetterTypeError(*exec, "TestObj", "nullableStringValue");
3190         return;
3191     }
3192     TestObj& impl = castedThis->impl();
3193     int nativeValue(toInt32(exec, value, NormalConversion));
3194     if (UNLIKELY(exec->hadException()))
3195         return;
3196     impl.setNullableStringValue(nativeValue);
3197 }
3198
3199
3200 void setJSTestObjAttributeWithReservedEnumType(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3201 {
3202     JSValue value = JSValue::decode(encodedValue);
3203     UNUSED_PARAM(baseObject);
3204     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3205     if (UNLIKELY(!castedThis)) {
3206         if (jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue)))
3207             reportDeprecatedSetterError(*exec, "TestObj", "attributeWithReservedEnumType");
3208         else
3209             throwSetterTypeError(*exec, "TestObj", "attributeWithReservedEnumType");
3210         return;
3211     }
3212     TestObj& impl = castedThis->impl();
3213     const String nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
3214     if (UNLIKELY(exec->hadException()))
3215         return;
3216     if (nativeValue != "" && nativeValue != "OptionalValue1" && nativeValue != "OptionalValue2" && nativeValue != "OptionalValue3")
3217         return;
3218     impl.setAttributeWithReservedEnumType(nativeValue);
3219 }
3220
3221
3222 JSValue JSTestObj::getConstructor(VM& vm, JSGlobalObject* globalObject)
3223 {
3224     return getDOMConstructor<JSTestObjConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
3225 }
3226
3227 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethod(ExecState* exec)
3228 {
3229     JSValue thisValue = exec->thisValue();
3230     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3231     if (UNLIKELY(!castedThis))
3232         return throwThisTypeError(*exec, "TestObj", "voidMethod");
3233     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3234     TestObj& impl = castedThis->impl();
3235     impl.voidMethod();
3236     return JSValue::encode(jsUndefined());
3237 }
3238
3239 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethodWithArgs(ExecState* exec)
3240 {
3241     JSValue thisValue = exec->thisValue();
3242     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3243     if (UNLIKELY(!castedThis))
3244         return throwThisTypeError(*exec, "TestObj", "voidMethodWithArgs");
3245     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3246     TestObj& impl = castedThis->impl();
3247     if (exec->argumentCount() < 3)
3248         return throwVMError(exec, createNotEnoughArgumentsError(exec));
3249     int longArg(toInt32(exec, exec->argument(0), NormalConversion));
3250     if (UNLIKELY(exec->hadException()))
3251         return JSValue::encode(jsUndefined());
3252     const String& strArg(exec->argument(1).isEmpty() ? String() : exec->argument(1).toString(exec)->value(exec));
3253     if (UNLIKELY(exec->hadException()))
3254         return JSValue::encode(jsUndefined());
3255     TestObj* objArg(toTestObj(exec->argument(2)));
3256     if (UNLIKELY(exec->hadException()))
3257         return JSValue::encode(jsUndefined());
3258     impl.voidMethodWithArgs(longArg, strArg, objArg);
3259     return JSValue::encode(jsUndefined());
3260 }
3261
3262 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionByteMethod(ExecState* exec)
3263 {
3264     JSValue thisValue = exec->thisValue();
3265     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3266     if (UNLIKELY(!castedThis))
3267         return throwThisTypeError(*exec, "TestObj", "byteMethod");
3268     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3269     TestObj& impl = castedThis->impl();
3270     JSValue result = jsNumber(impl.byteMethod());
3271     return JSValue::encode(result);
3272 }
3273
3274 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionByteMethodWithArgs(ExecState* exec)
3275 {
3276     JSValue thisValue = exec->thisValue();
3277     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3278     if (UNLIKELY(!castedThis))
3279         return throwThisTypeError(*exec, "TestObj", "byteMethodWithArgs");
3280     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3281     TestObj& impl = castedThis->impl();
3282     if (exec->argumentCount() < 3)
3283         return throwVMError(exec, createNotEnoughArgumentsError(exec));
3284     int8_t byteArg(toInt8(exec, exec->argument(0), NormalConversion));
3285     if (UNLIKELY(exec->hadException()))
3286         return JSValue::encode(jsUndefined());
3287     const String& strArg(exec->argument(1).isEmpty() ? String() : exec->argument(1).toString(exec)->value(exec));
3288     if (UNLIKELY(exec->hadException()))
3289         return JSValue::encode(jsUndefined());
3290     TestObj* objArg(toTestObj(exec->argument(2)));
3291     if (UNLIKELY(exec->hadException()))
3292         return JSValue::encode(jsUndefined());
3293     JSValue result = jsNumber(impl.byteMethodWithArgs(byteArg, strArg, objArg));
3294     return JSValue::encode(result);
3295 }
3296
3297 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOctetMethod(ExecState* exec)
3298 {
3299     JSValue thisValue = exec->thisValue();
3300     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3301     if (UNLIKELY(!castedThis))
3302         return throwThisTypeError(*exec, "TestObj", "octetMethod");
3303     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3304     TestObj& impl = castedThis->impl();
3305     JSValue result = jsNumber(impl.octetMethod());
3306     return JSValue::encode(result);
3307 }
3308
3309 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOctetMethodWithArgs(ExecState* exec)
3310 {
3311     JSValue thisValue = exec->thisValue();
3312     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3313     if (UNLIKELY(!castedThis))
3314         return throwThisTypeError(*exec, "TestObj", "octetMethodWithArgs");
3315     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3316     TestObj& impl = castedThis->impl();
3317     if (exec->argumentCount() < 3)
3318         return throwVMError(exec, createNotEnoughArgumentsError(exec));
3319     uint8_t octetArg(toUInt8(exec, exec->argument(0), NormalConversion));
3320     if (UNLIKELY(exec->hadException()))
3321         return JSValue::encode(jsUndefined());
3322     const String& strArg(exec->argument(1).isEmpty() ? String() : exec->argument(1).toString(exec)->value(exec));
3323     if (UNLIKELY(exec->hadException()))
3324         return JSValue::encode(jsUndefined());
3325     TestObj* objArg(toTestObj(exec->argument(2)));
3326     if (UNLIKELY(exec->hadException()))
3327         return JSValue::encode(jsUndefined());
3328     JSValue result = jsNumber(impl.octetMethodWithArgs(octetArg, strArg, objArg));
3329     return JSValue::encode(result);
3330 }
3331
3332 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethod(ExecState* exec)
3333 {
3334     JSValue thisValue = exec->thisValue();
3335     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3336     if (UNLIKELY(!castedThis))
3337         return throwThisTypeError(*exec, "TestObj", "longMethod");
3338     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3339     TestObj& impl = castedThis->impl();
3340     JSValue result = jsNumber(impl.longMethod());
3341     return JSValue::encode(result);
3342 }
3343
3344 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethodWithArgs(ExecState* exec)
3345 {
3346     JSValue thisValue = exec->thisValue();
3347     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3348     if (UNLIKELY(!castedThis))
3349         return throwThisTypeError(*exec, "TestObj", "longMethodWithArgs");
3350     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3351     TestObj& impl = castedThis->impl();
3352     if (exec->argumentCount() < 3)
3353         return throwVMError(exec, createNotEnoughArgumentsError(exec));
3354     int longArg(toInt32(exec, exec->argument(0), NormalConversion));
3355     if (UNLIKELY(exec->hadException()))
3356         return JSValue::encode(jsUndefined());
3357     const String& strArg(exec->argument(1).isEmpty() ? String() : exec->argument(1).toString(exec)->value(exec));
3358     if (UNLIKELY(exec->hadException()))
3359         return JSValue::encode(jsUndefined());
3360     TestObj* objArg(toTestObj(exec->argument(2)));
3361     if (UNLIKELY(exec->hadException()))
3362         return JSValue::encode(jsUndefined());
3363     JSValue result = jsNumber(impl.longMethodWithArgs(longArg, strArg, objArg));
3364     return JSValue::encode(result);
3365 }
3366
3367 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethod(ExecState* exec)
3368 {
3369     JSValue thisValue = exec->thisValue();
3370     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3371     if (UNLIKELY(!castedThis))
3372         return throwThisTypeError(*exec, "TestObj", "objMethod");
3373     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3374     TestObj& impl = castedThis->impl();
3375     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.objMethod()));
3376     return JSValue::encode(result);
3377 }
3378
3379 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethodWithArgs(ExecState* exec)
3380 {
3381     JSValue thisValue = exec->thisValue();
3382     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3383     if (UNLIKELY(!castedThis))
3384         return throwThisTypeError(*exec, "TestObj", "objMethodWithArgs");
3385     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3386     TestObj& impl = castedThis->impl();
3387     if (exec->argumentCount() < 3)
3388         return throwVMError(exec, createNotEnoughArgumentsError(exec));
3389     int longArg(toInt32(exec, exec->argument(0), NormalConversion));
3390     if (UNLIKELY(exec->hadException()))
3391         return JSValue::encode(jsUndefined());
3392     const String& strArg(exec->argument(1).isEmpty() ? String() : exec->argument(1).toString(exec)->value(exec));
3393     if (UNLIKELY(exec->hadException()))
3394         return JSValue::encode(jsUndefined());
3395     TestObj* objArg(toTestObj(exec->argument(2)));
3396     if (UNLIKELY(exec->hadException()))
3397         return JSValue::encode(jsUndefined());
3398     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.objMethodWithArgs(longArg, strArg, objArg)));
3399     return JSValue::encode(result);
3400 }
3401
3402 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithSequenceArg(ExecState* exec)
3403 {
3404     JSValue thisValue = exec->thisValue();
3405     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3406     if (UNLIKELY(!castedThis))
3407         return throwThisTypeError(*exec, "TestObj", "methodWithSequenceArg");
3408     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3409     TestObj& impl = castedThis->impl();
3410     if (exec->argumentCount() < 1)
3411         return throwVMError(exec, createNotEnoughArgumentsError(exec));
3412     Vector<RefPtr<ScriptProfile>> sequenceArg((toRefPtrNativeArray<ScriptProfile, JSScriptProfile>(exec, exec->argument(0), &toScriptProfile)));
3413     if (UNLIKELY(exec->hadException()))
3414         return JSValue::encode(jsUndefined());
3415     impl.methodWithSequenceArg(sequenceArg);
3416     return JSValue::encode(jsUndefined());
3417 }
3418
3419 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodReturningSequence(ExecState* exec)
3420 {
3421     JSValue thisValue = exec->thisValue();
3422     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3423     if (UNLIKELY(!castedThis))
3424         return throwThisTypeError(*exec, "TestObj", "methodReturningSequence");
3425     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3426     TestObj& impl = castedThis->impl();
3427     if (exec->argumentCount() < 1)
3428         return throwVMError(exec, createNotEnoughArgumentsError(exec));
3429     int longArg(toInt32(exec, exec->argument(0), NormalConversion));
3430     if (UNLIKELY(exec->hadException()))
3431         return JSValue::encode(jsUndefined());
3432     JSValue result = jsArray(exec, castedThis->globalObject(), impl.methodReturningSequence(longArg));
3433     return JSValue::encode(result);
3434 }
3435
3436 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithEnumArg(ExecState* exec)
3437 {
3438     JSValue thisValue = exec->thisValue();
3439     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3440     if (UNLIKELY(!castedThis))
3441         return throwThisTypeError(*exec, "TestObj", "methodWithEnumArg");
3442     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3443     TestObj& impl = castedThis->impl();
3444     if (exec->argumentCount() < 1)
3445         return throwVMError(exec, createNotEnoughArgumentsError(exec));
3446     const String enumArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
3447     if (UNLIKELY(exec->hadException()))
3448         return JSValue::encode(jsUndefined());
3449     if (enumArg != "" && enumArg != "EnumValue1" && enumArg != "EnumValue2" && enumArg != "EnumValue3")
3450         return throwArgumentMustBeEnumError(*exec, 0, "enumArg", "TestObj", "methodWithEnumArg", "\"\", \"EnumValue1\", \"EnumValue2\", \"EnumValue3\"");
3451     impl.methodWithEnumArg(enumArg);
3452     return JSValue::encode(jsUndefined());
3453 }
3454
3455 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows(ExecState* exec)
3456 {
3457     JSValue thisValue = exec->thisValue();
3458     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3459     if (UNLIKELY(!castedThis))
3460         return throwThisTypeError(*exec, "TestObj", "methodThatRequiresAllArgsAndThrows");
3461     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3462     TestObj& impl = castedThis->impl();
3463     if (exec->argumentCount() < 2)
3464         return throwVMError(exec, createNotEnoughArgumentsError(exec));
3465     ExceptionCode ec = 0;
3466     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
3467     if (UNLIKELY(exec->hadException()))
3468         return JSValue::encode(jsUndefined());
3469     TestObj* objArg(toTestObj(exec->argument(1)));
3470     if (UNLIKELY(exec->hadException()))
3471         return JSValue::encode(jsUndefined());
3472     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.methodThatRequiresAllArgsAndThrows(strArg, objArg, ec)));
3473
3474     setDOMException(exec, ec);
3475     return JSValue::encode(result);
3476 }
3477
3478 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionSerializedValue(ExecState* exec)
3479 {
3480     JSValue thisValue = exec->thisValue();
3481     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3482     if (UNLIKELY(!castedThis))
3483         return throwThisTypeError(*exec, "TestObj", "serializedValue");
3484     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3485     TestObj& impl = castedThis->impl();
3486     if (exec->argumentCount() < 1)
3487         return throwVMError(exec, createNotEnoughArgumentsError(exec));
3488     RefPtr<SerializedScriptValue> serializedArg(SerializedScriptValue::create(exec, exec->argument(0), 0, 0));
3489     if (UNLIKELY(exec->hadException()))
3490         return JSValue::encode(jsUndefined());
3491     impl.serializedValue(serializedArg);
3492     return JSValue::encode(jsUndefined());
3493 }
3494
3495 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOptionsObject(ExecState* exec)
3496 {
3497     JSValue thisValue = exec->thisValue();
3498     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3499     if (UNLIKELY(!castedThis))
3500         return throwThisTypeError(*exec, "TestObj", "optionsObject");
3501     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3502     TestObj& impl = castedThis->impl();
3503     if (exec->argumentCount() < 1)
3504         return throwVMError(exec, createNotEnoughArgumentsError(exec));
3505     Dictionary oo(exec, exec->argument(0));
3506     if (UNLIKELY(exec->hadException()))
3507         return JSValue::encode(jsUndefined());
3508     Dictionary ooo(exec, exec->argument(1));
3509     if (UNLIKELY(exec->hadException()))
3510         return JSValue::encode(jsUndefined());
3511     impl.optionsObject(oo, ooo);
3512     return JSValue::encode(jsUndefined());
3513 }
3514
3515 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithException(ExecState* exec)
3516 {
3517     JSValue thisValue = exec->thisValue();
3518     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3519     if (UNLIKELY(!castedThis))
3520         return throwThisTypeError(*exec, "TestObj", "methodWithException");
3521     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3522     TestObj& impl = castedThis->impl();
3523     ExceptionCode ec = 0;
3524     impl.methodWithException(ec);
3525     setDOMException(exec, ec);
3526     return JSValue::encode(jsUndefined());
3527 }
3528
3529 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethod(ExecState* exec)
3530 {
3531     JSValue thisValue = exec->thisValue();
3532     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3533     if (UNLIKELY(!castedThis))
3534         return throwThisTypeError(*exec, "TestObj", "customMethod");
3535     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3536     return JSValue::encode(castedThis->customMethod(exec));
3537 }
3538
3539 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethodWithArgs(ExecState* exec)
3540 {
3541     JSValue thisValue = exec->thisValue();
3542     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3543     if (UNLIKELY(!castedThis))
3544         return throwThisTypeError(*exec, "TestObj", "customMethodWithArgs");
3545     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3546     return JSValue::encode(castedThis->customMethodWithArgs(exec));
3547 }
3548
3549 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAddEventListener(ExecState* exec)
3550 {
3551     JSValue thisValue = exec->thisValue();
3552     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3553     if (UNLIKELY(!castedThis))
3554         return throwThisTypeError(*exec, "TestObj", "addEventListener");
3555     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3556     TestObj& impl = castedThis->impl();
3557     JSValue listener = exec->argument(1);
3558     if (!listener.isObject())
3559         return JSValue::encode(jsUndefined());
3560     impl.addEventListener(exec->argument(0).toString(exec)->value(exec), JSEventListener::create(asObject(listener), castedThis, false, currentWorld(exec)), exec->argument(2).toBoolean(exec));
3561     return JSValue::encode(jsUndefined());
3562 }
3563
3564 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionRemoveEventListener(ExecState* exec)
3565 {
3566     JSValue thisValue = exec->thisValue();
3567     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3568     if (UNLIKELY(!castedThis))
3569         return throwThisTypeError(*exec, "TestObj", "removeEventListener");
3570     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3571     TestObj& impl = castedThis->impl();
3572     JSValue listener = exec->argument(1);
3573     if (!listener.isObject())
3574         return JSValue::encode(jsUndefined());
3575     impl.removeEventListener(exec->argument(0).toString(exec)->value(exec), JSEventListener::create(asObject(listener), castedThis, false, currentWorld(exec)).get(), exec->argument(2).toBoolean(exec));
3576     return JSValue::encode(jsUndefined());
3577 }
3578
3579 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoid(ExecState* exec)
3580 {
3581     JSValue thisValue = exec->thisValue();
3582     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3583     if (UNLIKELY(!castedThis))
3584         return throwThisTypeError(*exec, "TestObj", "withScriptStateVoid");
3585     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3586     TestObj& impl = castedThis->impl();
3587     impl.withScriptStateVoid(exec);
3588     return JSValue::encode(jsUndefined());
3589 }
3590
3591 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObj(ExecState* exec)
3592 {
3593     JSValue thisValue = exec->thisValue();
3594     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3595     if (UNLIKELY(!castedThis))
3596         return throwThisTypeError(*exec, "TestObj", "withScriptStateObj");
3597     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3598     TestObj& impl = castedThis->impl();
3599     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateObj(exec)));
3600     if (UNLIKELY(exec->hadException()))
3601         return JSValue::encode(jsUndefined());
3602     return JSValue::encode(result);
3603 }
3604
3605 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoidException(ExecState* exec)
3606 {
3607     JSValue thisValue = exec->thisValue();
3608     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3609     if (UNLIKELY(!castedThis))
3610         return throwThisTypeError(*exec, "TestObj", "withScriptStateVoidException");
3611     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3612     TestObj& impl = castedThis->impl();
3613     ExceptionCode ec = 0;
3614     impl.withScriptStateVoidException(exec, ec);
3615     setDOMException(exec, ec);
3616     return JSValue::encode(jsUndefined());
3617 }
3618
3619 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObjException(ExecState* exec)
3620 {
3621     JSValue thisValue = exec->thisValue();
3622     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3623     if (UNLIKELY(!castedThis))
3624         return throwThisTypeError(*exec, "TestObj", "withScriptStateObjException");
3625     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3626     TestObj& impl = castedThis->impl();
3627     ExceptionCode ec = 0;
3628     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateObjException(exec, ec)));
3629
3630     setDOMException(exec, ec);
3631     if (UNLIKELY(exec->hadException()))
3632         return JSValue::encode(jsUndefined());
3633     return JSValue::encode(result);
3634 }
3635
3636 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContext(ExecState* exec)
3637 {
3638     JSValue thisValue = exec->thisValue();
3639     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3640     if (UNLIKELY(!castedThis))
3641         return throwThisTypeError(*exec, "TestObj", "withScriptExecutionContext");
3642     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3643     TestObj& impl = castedThis->impl();
3644     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
3645     if (!scriptContext)
3646         return JSValue::encode(jsUndefined());
3647     impl.withScriptExecutionContext(scriptContext);
3648     return JSValue::encode(jsUndefined());
3649 }
3650
3651 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptState(ExecState* exec)
3652 {
3653     JSValue thisValue = exec->thisValue();
3654     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3655     if (UNLIKELY(!castedThis))
3656         return throwThisTypeError(*exec, "TestObj", "withScriptExecutionContextAndScriptState");
3657     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3658     TestObj& impl = castedThis->impl();
3659     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
3660     if (!scriptContext)
3661         return JSValue::encode(jsUndefined());
3662     impl.withScriptExecutionContextAndScriptState(exec, scriptContext);
3663     return JSValue::encode(jsUndefined());
3664 }
3665
3666 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateObjException(ExecState* exec)
3667 {
3668     JSValue thisValue = exec->thisValue();
3669     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3670     if (UNLIKELY(!castedThis))
3671         return throwThisTypeError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateObjException");
3672     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3673     TestObj& impl = castedThis->impl();
3674     ExceptionCode ec = 0;
3675     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
3676     if (!scriptContext)
3677         return JSValue::encode(jsUndefined());
3678     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateObjException(exec, scriptContext, ec)));
3679
3680     setDOMException(exec, ec);
3681     if (UNLIKELY(exec->hadException()))
3682         return JSValue::encode(jsUndefined());
3683     return JSValue::encode(result);
3684 }
3685
3686 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateWithSpaces(ExecState* exec)
3687 {
3688     JSValue thisValue = exec->thisValue();
3689     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3690     if (UNLIKELY(!castedThis))
3691         return throwThisTypeError(*exec, "TestObj", "withScriptExecutionContextAndScriptStateWithSpaces");
3692     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3693     TestObj& impl = castedThis->impl();
3694     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
3695     if (!scriptContext)
3696         return JSValue::encode(jsUndefined());
3697     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateWithSpaces(exec, scriptContext)));
3698     if (UNLIKELY(exec->hadException()))
3699         return JSValue::encode(jsUndefined());
3700     return JSValue::encode(result);
3701 }
3702
3703 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptArgumentsAndCallStack(ExecState* exec)
3704 {
3705     JSValue thisValue = exec->thisValue();
3706     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3707     if (UNLIKELY(!castedThis))
3708         return throwThisTypeError(*exec, "TestObj", "withScriptArgumentsAndCallStack");
3709     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3710     TestObj& impl = castedThis->impl();
3711     RefPtr<Inspector::ScriptArguments> scriptArguments(Inspector::createScriptArguments(exec, 0));
3712     impl.withScriptArgumentsAndCallStack(scriptArguments.release());
3713     return JSValue::encode(jsUndefined());
3714 }
3715
3716 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArg(ExecState* exec)
3717 {
3718     JSValue thisValue = exec->thisValue();
3719     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);
3720     if (UNLIKELY(!castedThis))
3721         return throwThisTypeError(*exec, "TestObj", "methodWithOptionalArg");
3722     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
3723     TestObj& impl = castedThis->impl();
3724
3725     size_t argsCount = exec->argumentCount();
3726     if (argsCount <= 0) {
3727         impl.methodWithOptionalArg();
3728         return JSValue::encode(jsUndefined());
3729     }
3730
3731     int opt(toInt32(exec, exec->argument(0), NormalConversion));
3732     if (UNLIKELY(exec->hadException()))
3733         return JSValue::encode(jsUndefined());
3734     impl.methodWithOptionalArg(opt);
3735     return JSValue::encode(jsUndefined());
3736 }
3737
3738 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg(ExecState* exec)
3739 {
3740     JSValue thisValue = exec->thisValue();
3741     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(thisValue);