JSGenerateToNativeObject should use fast JSNode/JSElement casts.
[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 throwVMTypeError(exec, makeDOMBindingsTypeErrorString("Argument ", "1", " ('", "testCallback", "') to ", "the ", "TestObj", " constructor", " must be a function"));
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 }
248
249 bool JSTestObjConstructor::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
250 {
251     return getStaticPropertySlot<JSTestObjConstructor, JSDOMWrapper>(exec, JSTestObjConstructorTable, jsCast<JSTestObjConstructor*>(object), propertyName, slot);
252 }
253
254 ConstructType JSTestObjConstructor::getConstructData(JSCell*, ConstructData& constructData)
255 {
256     constructData.native.function = constructJSTestObj;
257     return ConstructTypeHost;
258 }
259
260 /* Hash table for prototype */
261
262 static const struct CompactHashIndex JSTestObjPrototypeTableIndex[530] = {
263     { -1, -1 },
264     { -1, -1 },
265     { -1, -1 },
266     { -1, -1 },
267     { -1, -1 },
268     { 23, -1 },
269     { -1, -1 },
270     { -1, -1 },
271     { -1, -1 },
272     { -1, -1 },
273     { -1, -1 },
274     { -1, -1 },
275     { -1, -1 },
276     { 49, -1 },
277     { -1, -1 },
278     { -1, -1 },
279     { -1, -1 },
280     { 16, 513 },
281     { -1, -1 },
282     { -1, -1 },
283     { -1, -1 },
284     { -1, -1 },
285     { -1, -1 },
286     { 47, -1 },
287     { 73, -1 },
288     { -1, -1 },
289     { 41, -1 },
290     { -1, -1 },
291     { -1, -1 },
292     { -1, -1 },
293     { -1, -1 },
294     { -1, -1 },
295     { -1, -1 },
296     { -1, -1 },
297     { -1, -1 },
298     { -1, -1 },
299     { 102, -1 },
300     { -1, -1 },
301     { -1, -1 },
302     { -1, -1 },
303     { -1, -1 },
304     { 15, -1 },
305     { -1, -1 },
306     { -1, -1 },
307     { -1, -1 },
308     { 110, -1 },
309     { -1, -1 },
310     { -1, -1 },
311     { -1, -1 },
312     { -1, -1 },
313     { -1, -1 },
314     { -1, -1 },
315     { -1, -1 },
316     { -1, -1 },
317     { -1, -1 },
318     { 27, 522 },
319     { -1, -1 },
320     { -1, -1 },
321     { -1, -1 },
322     { -1, -1 },
323     { -1, -1 },
324     { -1, -1 },
325     { 126, -1 },
326     { -1, -1 },
327     { -1, -1 },
328     { -1, -1 },
329     { 101, -1 },
330     { 100, -1 },
331     { -1, -1 },
332     { -1, -1 },
333     { -1, -1 },
334     { -1, -1 },
335     { -1, -1 },
336     { 4, -1 },
337     { -1, -1 },
338     { 17, -1 },
339     { -1, -1 },
340     { -1, -1 },
341     { -1, -1 },
342     { 5, -1 },
343     { 134, -1 },
344     { -1, -1 },
345     { -1, -1 },
346     { -1, -1 },
347     { -1, -1 },
348     { 53, -1 },
349     { 32, 517 },
350     { -1, -1 },
351     { -1, -1 },
352     { -1, -1 },
353     { -1, -1 },
354     { -1, -1 },
355     { -1, -1 },
356     { -1, -1 },
357     { 93, -1 },
358     { 87, -1 },
359     { -1, -1 },
360     { -1, -1 },
361     { -1, -1 },
362     { 31, -1 },
363     { -1, -1 },
364     { 55, -1 },
365     { -1, -1 },
366     { -1, -1 },
367     { -1, -1 },
368     { -1, -1 },
369     { -1, -1 },
370     { -1, -1 },
371     { -1, -1 },
372     { -1, -1 },
373     { -1, -1 },
374     { 117, -1 },
375     { -1, -1 },
376     { -1, -1 },
377     { 78, -1 },
378     { 70, -1 },
379     { -1, -1 },
380     { 25, -1 },
381     { -1, -1 },
382     { -1, -1 },
383     { 22, -1 },
384     { -1, -1 },
385     { -1, -1 },
386     { -1, -1 },
387     { -1, -1 },
388     { -1, -1 },
389     { -1, -1 },
390     { -1, -1 },
391     { -1, -1 },
392     { 96, -1 },
393     { -1, -1 },
394     { -1, -1 },
395     { -1, -1 },
396     { 114, -1 },
397     { -1, -1 },
398     { 6, -1 },
399     { -1, -1 },
400     { -1, -1 },
401     { -1, -1 },
402     { -1, -1 },
403     { -1, -1 },
404     { -1, -1 },
405     { -1, -1 },
406     { 86, -1 },
407     { -1, -1 },
408     { -1, -1 },
409     { 1, -1 },
410     { -1, -1 },
411     { -1, -1 },
412     { 33, -1 },
413     { 51, -1 },
414     { -1, -1 },
415     { 71, -1 },
416     { -1, -1 },
417     { -1, -1 },
418     { -1, -1 },
419     { -1, -1 },
420     { -1, -1 },
421     { -1, -1 },
422     { 92, -1 },
423     { -1, -1 },
424     { -1, -1 },
425     { -1, -1 },
426     { -1, -1 },
427     { -1, -1 },
428     { 127, -1 },
429     { -1, -1 },
430     { -1, -1 },
431     { -1, -1 },
432     { -1, -1 },
433     { 72, -1 },
434     { -1, -1 },
435     { -1, -1 },
436     { -1, -1 },
437     { -1, -1 },
438     { -1, -1 },
439     { -1, -1 },
440     { -1, -1 },
441     { -1, -1 },
442     { -1, -1 },
443     { 67, -1 },
444     { -1, -1 },
445     { -1, -1 },
446     { -1, -1 },
447     { -1, -1 },
448     { -1, -1 },
449     { -1, -1 },
450     { -1, -1 },
451     { -1, -1 },
452     { 24, -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     { -1, -1 },
464     { -1, -1 },
465     { -1, -1 },
466     { -1, -1 },
467     { 89, -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     { -1, -1 },
485     { -1, -1 },
486     { -1, -1 },
487     { -1, -1 },
488     { 82, -1 },
489     { -1, -1 },
490     { -1, -1 },
491     { -1, -1 },
492     { 3, -1 },
493     { -1, -1 },
494     { -1, -1 },
495     { -1, -1 },
496     { 45, -1 },
497     { -1, -1 },
498     { 77, -1 },
499     { -1, -1 },
500     { -1, -1 },
501     { -1, -1 },
502     { -1, -1 },
503     { -1, -1 },
504     { 36, 526 },
505     { -1, -1 },
506     { -1, -1 },
507     { -1, -1 },
508     { 8, 512 },
509     { -1, -1 },
510     { 130, -1 },
511     { -1, -1 },
512     { 58, 528 },
513     { 135, -1 },
514     { -1, -1 },
515     { -1, -1 },
516     { -1, -1 },
517     { -1, -1 },
518     { 64, 524 },
519     { -1, -1 },
520     { -1, -1 },
521     { -1, -1 },
522     { 131, -1 },
523     { -1, -1 },
524     { 103, -1 },
525     { -1, -1 },
526     { -1, -1 },
527     { -1, -1 },
528     { -1, -1 },
529     { -1, -1 },
530     { -1, -1 },
531     { -1, -1 },
532     { -1, -1 },
533     { -1, -1 },
534     { 39, 515 },
535     { -1, -1 },
536     { -1, -1 },
537     { 113, -1 },
538     { 90, -1 },
539     { 120, -1 },
540     { -1, -1 },
541     { -1, -1 },
542     { -1, -1 },
543     { -1, -1 },
544     { -1, -1 },
545     { -1, -1 },
546     { -1, -1 },
547     { -1, -1 },
548     { 34, -1 },
549     { -1, -1 },
550     { 18, -1 },
551     { -1, -1 },
552     { -1, -1 },
553     { -1, -1 },
554     { -1, -1 },
555     { 61, -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     { -1, -1 },
565     { -1, -1 },
566     { -1, -1 },
567     { -1, -1 },
568     { 128, -1 },
569     { 123, -1 },
570     { -1, -1 },
571     { -1, -1 },
572     { -1, -1 },
573     { 26, -1 },
574     { -1, -1 },
575     { -1, -1 },
576     { -1, -1 },
577     { -1, -1 },
578     { 76, -1 },
579     { -1, -1 },
580     { -1, -1 },
581     { -1, -1 },
582     { -1, -1 },
583     { -1, -1 },
584     { -1, -1 },
585     { -1, -1 },
586     { -1, -1 },
587     { 84, -1 },
588     { -1, -1 },
589     { -1, -1 },
590     { -1, -1 },
591     { -1, -1 },
592     { -1, -1 },
593     { 43, -1 },
594     { -1, -1 },
595     { -1, -1 },
596     { -1, -1 },
597     { -1, -1 },
598     { -1, -1 },
599     { -1, -1 },
600     { -1, -1 },
601     { -1, -1 },
602     { -1, -1 },
603     { 12, -1 },
604     { -1, -1 },
605     { 59, -1 },
606     { -1, -1 },
607     { -1, -1 },
608     { 0, -1 },
609     { -1, -1 },
610     { 99, -1 },
611     { -1, -1 },
612     { -1, -1 },
613     { -1, -1 },
614     { -1, -1 },
615     { 30, -1 },
616     { 28, -1 },
617     { -1, -1 },
618     { -1, -1 },
619     { 124, -1 },
620     { -1, -1 },
621     { 35, -1 },
622     { -1, -1 },
623     { -1, -1 },
624     { -1, -1 },
625     { -1, -1 },
626     { -1, -1 },
627     { 65, 518 },
628     { -1, -1 },
629     { -1, -1 },
630     { -1, -1 },
631     { -1, -1 },
632     { -1, -1 },
633     { 88, -1 },
634     { -1, -1 },
635     { -1, -1 },
636     { -1, -1 },
637     { -1, -1 },
638     { -1, -1 },
639     { 46, 521 },
640     { 80, -1 },
641     { -1, -1 },
642     { -1, -1 },
643     { -1, -1 },
644     { 44, -1 },
645     { -1, -1 },
646     { -1, -1 },
647     { -1, -1 },
648     { 69, -1 },
649     { -1, -1 },
650     { 62, -1 },
651     { -1, -1 },
652     { 2, -1 },
653     { -1, -1 },
654     { 50, -1 },
655     { -1, -1 },
656     { -1, -1 },
657     { -1, -1 },
658     { 95, -1 },
659     { -1, -1 },
660     { -1, -1 },
661     { -1, -1 },
662     { -1, -1 },
663     { -1, -1 },
664     { -1, -1 },
665     { -1, -1 },
666     { -1, -1 },
667     { -1, -1 },
668     { -1, -1 },
669     { 38, 523 },
670     { -1, -1 },
671     { -1, -1 },
672     { -1, -1 },
673     { 57, -1 },
674     { 68, -1 },
675     { -1, -1 },
676     { -1, -1 },
677     { 107, 527 },
678     { -1, -1 },
679     { 108, -1 },
680     { -1, -1 },
681     { -1, -1 },
682     { -1, -1 },
683     { -1, -1 },
684     { 14, -1 },
685     { 20, 529 },
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     { -1, -1 },
696     { -1, -1 },
697     { -1, -1 },
698     { -1, -1 },
699     { 112, -1 },
700     { -1, -1 },
701     { -1, -1 },
702     { -1, -1 },
703     { -1, -1 },
704     { -1, -1 },
705     { -1, -1 },
706     { -1, -1 },
707     { -1, -1 },
708     { 118, -1 },
709     { -1, -1 },
710     { -1, -1 },
711     { -1, -1 },
712     { -1, -1 },
713     { -1, -1 },
714     { -1, -1 },
715     { -1, -1 },
716     { 79, -1 },
717     { -1, -1 },
718     { -1, -1 },
719     { -1, -1 },
720     { 60, -1 },
721     { 52, -1 },
722     { -1, -1 },
723     { 74, -1 },
724     { 132, -1 },
725     { -1, -1 },
726     { -1, -1 },
727     { -1, -1 },
728     { 54, 516 },
729     { -1, -1 },
730     { 85, -1 },
731     { 9, -1 },
732     { -1, -1 },
733     { -1, -1 },
734     { -1, -1 },
735     { 105, -1 },
736     { 29, -1 },
737     { -1, -1 },
738     { -1, -1 },
739     { 37, -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     { -1, -1 },
749     { -1, -1 },
750     { -1, -1 },
751     { -1, -1 },
752     { 19, -1 },
753     { -1, -1 },
754     { -1, -1 },
755     { -1, -1 },
756     { 109, -1 },
757     { 13, 514 },
758     { 40, -1 },
759     { 111, -1 },
760     { -1, -1 },
761     { 7, 525 },
762     { -1, -1 },
763     { 125, -1 },
764     { 106, -1 },
765     { 75, 520 },
766     { -1, -1 },
767     { 122, -1 },
768     { 83, -1 },
769     { -1, -1 },
770     { -1, -1 },
771     { -1, -1 },
772     { 119, -1 },
773     { -1, -1 },
774     { 10, 519 },
775     { 11, -1 },
776     { 21, -1 },
777     { 42, -1 },
778     { 48, -1 },
779     { 56, -1 },
780     { 63, -1 },
781     { 66, -1 },
782     { 81, -1 },
783     { 91, -1 },
784     { 94, -1 },
785     { 97, -1 },
786     { 98, -1 },
787     { 104, -1 },
788     { 115, -1 },
789     { 116, -1 },
790     { 121, -1 },
791     { 129, -1 },
792     { 133, -1 },
793 };
794
795
796 static const HashTableValue JSTestObjPrototypeTableValues[] =
797 {
798     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
799     { "readOnlyLongAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
800     { "readOnlyStringAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
801     { "readOnlyTestObjAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
802     { "enumAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjEnumAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjEnumAttr) },
803     { "byteAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjByteAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjByteAttr) },
804     { "octetAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjOctetAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjOctetAttr) },
805     { "shortAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjShortAttr) },
806     { "unsignedShortAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjUnsignedShortAttr) },
807     { "longAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLongAttr) },
808     { "longLongAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLongLongAttr) },
809     { "unsignedLongLongAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjUnsignedLongLongAttr) },
810     { "stringAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttr) },
811     { "testObjAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestObjAttr) },
812     { "XMLObjAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjXMLObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjXMLObjAttr) },
813     { "create", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCreate), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjCreate) },
814     { "reflectedStringAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedStringAttr) },
815     { "reflectedIntegralAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedIntegralAttr) },
816     { "reflectedUnsignedIntegralAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedUnsignedIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedUnsignedIntegralAttr) },
817     { "reflectedBooleanAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedBooleanAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedBooleanAttr) },
818     { "reflectedURLAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedURLAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedURLAttr) },
819     { "reflectedStringAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedStringAttr) },
820     { "reflectedCustomIntegralAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomIntegralAttr) },
821     { "reflectedCustomBooleanAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomBooleanAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomBooleanAttr) },
822     { "reflectedCustomURLAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomURLAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomURLAttr) },
823     { "typedArrayAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTypedArrayAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTypedArrayAttr) },
824     { "attrWithGetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithGetterException) },
825     { "attrWithSetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithSetterException) },
826     { "stringAttrWithGetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrWithGetterException) },
827     { "stringAttrWithSetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrWithSetterException) },
828     { "withScriptStateAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptStateAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptStateAttribute) },
829     { "withScriptExecutionContextAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAttribute) },
830     { "withScriptStateAttributeRaises", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptStateAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptStateAttributeRaises) },
831     { "withScriptExecutionContextAttributeRaises", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAttributeRaises) },
832     { "withScriptExecutionContextAndScriptStateAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateAttribute) },
833     { "withScriptExecutionContextAndScriptStateAttributeRaises", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises) },
834     { "withScriptExecutionContextAndScriptStateWithSpacesAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute) },
835     { "withScriptArgumentsAndCallStackAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptArgumentsAndCallStackAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptArgumentsAndCallStackAttribute) },
836 #if ENABLE(Condition1)
837     { "conditionalAttr1", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr1) },
838 #else
839     { 0, 0, NoIntrinsic, 0, 0 },
840 #endif
841 #if ENABLE(Condition1) && ENABLE(Condition2)
842     { "conditionalAttr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr2) },
843 #else
844     { 0, 0, NoIntrinsic, 0, 0 },
845 #endif
846 #if ENABLE(Condition1) || ENABLE(Condition2)
847     { "conditionalAttr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr3) },
848 #else
849     { 0, 0, NoIntrinsic, 0, 0 },
850 #endif
851     { "cachedAttribute1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
852     { "cachedAttribute2", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
853     { "anyAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAnyAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAnyAttribute) },
854     { "mutablePoint", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjMutablePoint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjMutablePoint) },
855     { "immutablePoint", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjImmutablePoint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjImmutablePoint) },
856     { "strawberry", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrawberry), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrawberry) },
857     { "strictFloat", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrictFloat), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrictFloat) },
858     { "description", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjDescription), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
859     { "id", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjId), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjId) },
860     { "hash", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjHash), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
861     { "replaceableAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReplaceableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReplaceableAttribute) },
862     { "nullableDoubleAttribute", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableDoubleAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
863     { "nullableLongAttribute", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableLongAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
864     { "nullableBooleanAttribute", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableBooleanAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
865     { "nullableStringAttribute", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
866     { "nullableLongSettableAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableLongSettableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableLongSettableAttribute) },
867     { "nullableStringValue", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableStringValue) },
868     { "attribute", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
869     { "attributeWithReservedEnumType", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttributeWithReservedEnumType), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttributeWithReservedEnumType) },
870 #if ENABLE(Condition1)
871     { "CONDITIONAL_CONST", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONDITIONAL_CONST), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
872 #else
873     { 0, 0, NoIntrinsic, 0, 0 },
874 #endif
875     { "CONST_VALUE_0", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_0), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
876     { "CONST_VALUE_1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
877     { "CONST_VALUE_2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
878     { "CONST_VALUE_4", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_4), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
879     { "CONST_VALUE_8", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_8), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
880     { "CONST_VALUE_9", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_9), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
881     { "CONST_VALUE_10", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_10), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
882     { "CONST_VALUE_11", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_11), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
883     { "CONST_VALUE_12", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_12), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
884     { "CONST_VALUE_13", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_13), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
885     { "CONST_VALUE_14", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_14), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
886     { "CONST_JAVASCRIPT", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_JAVASCRIPT), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
887     { "readonly", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadonly), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
888     { "voidMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethod), (intptr_t) (0) },
889     { "voidMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethodWithArgs), (intptr_t) (3) },
890     { "byteMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionByteMethod), (intptr_t) (0) },
891     { "byteMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionByteMethodWithArgs), (intptr_t) (3) },
892     { "octetMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOctetMethod), (intptr_t) (0) },
893     { "octetMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOctetMethodWithArgs), (intptr_t) (3) },
894     { "longMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethod), (intptr_t) (0) },
895     { "longMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethodWithArgs), (intptr_t) (3) },
896     { "objMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethod), (intptr_t) (0) },
897     { "objMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethodWithArgs), (intptr_t) (3) },
898     { "methodWithSequenceArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithSequenceArg), (intptr_t) (1) },
899     { "methodReturningSequence", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodReturningSequence), (intptr_t) (1) },
900     { "methodWithEnumArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithEnumArg), (intptr_t) (1) },
901     { "methodThatRequiresAllArgsAndThrows", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows), (intptr_t) (2) },
902     { "serializedValue", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionSerializedValue), (intptr_t) (1) },
903     { "optionsObject", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOptionsObject), (intptr_t) (1) },
904     { "methodWithException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithException), (intptr_t) (0) },
905     { "customMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionCustomMethod), (intptr_t) (0) },
906     { "customMethodWithArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionCustomMethodWithArgs), (intptr_t) (3) },
907     { "addEventListener", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAddEventListener), (intptr_t) (2) },
908     { "removeEventListener", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionRemoveEventListener), (intptr_t) (2) },
909     { "withScriptStateVoid", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateVoid), (intptr_t) (0) },
910     { "withScriptStateObj", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObj), (intptr_t) (0) },
911     { "withScriptStateVoidException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateVoidException), (intptr_t) (0) },
912     { "withScriptStateObjException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObjException), (intptr_t) (0) },
913     { "withScriptExecutionContext", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContext), (intptr_t) (0) },
914     { "withScriptExecutionContextAndScriptState", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptState), (intptr_t) (0) },
915     { "withScriptExecutionContextAndScriptStateObjException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateObjException), (intptr_t) (0) },
916     { "withScriptExecutionContextAndScriptStateWithSpaces", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateWithSpaces), (intptr_t) (0) },
917     { "withScriptArgumentsAndCallStack", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptArgumentsAndCallStack), (intptr_t) (0) },
918     { "methodWithOptionalArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArg), (intptr_t) (0) },
919     { "methodWithNonOptionalArgAndOptionalArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg), (intptr_t) (1) },
920     { "methodWithNonOptionalArgAndTwoOptionalArgs", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs), (intptr_t) (1) },
921     { "methodWithOptionalString", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalString), (intptr_t) (0) },
922     { "methodWithOptionalStringIsUndefined", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsUndefined), (intptr_t) (0) },
923     { "methodWithOptionalStringIsNullString", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsNullString), (intptr_t) (0) },
924     { "methodWithCallbackArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackArg), (intptr_t) (1) },
925     { "methodWithNonCallbackArgAndCallbackArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackArg), (intptr_t) (2) },
926     { "methodWithCallbackAndOptionalArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackAndOptionalArg), (intptr_t) (0) },
927 #if ENABLE(Condition1)
928     { "conditionalMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod1), (intptr_t) (0) },
929 #else
930     { 0, 0, NoIntrinsic, 0, 0 },
931 #endif
932 #if ENABLE(Condition1) && ENABLE(Condition2)
933     { "conditionalMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod2), (intptr_t) (0) },
934 #else
935     { 0, 0, NoIntrinsic, 0, 0 },
936 #endif
937 #if ENABLE(Condition1) || ENABLE(Condition2)
938     { "conditionalMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod3), (intptr_t) (0) },
939 #else
940     { 0, 0, NoIntrinsic, 0, 0 },
941 #endif
942     { "overloadedMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOverloadedMethod), (intptr_t) (2) },
943     { "classMethodWithClamp", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionClassMethodWithClamp), (intptr_t) (2) },
944     { "methodWithUnsignedLongSequence", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithUnsignedLongSequence), (intptr_t) (1) },
945     { "stringArrayFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStringArrayFunction), (intptr_t) (1) },
946     { "domStringListFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionDomStringListFunction), (intptr_t) (1) },
947     { "getSVGDocument", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionGetSVGDocument), (intptr_t) (0) },
948     { "convert1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert1), (intptr_t) (1) },
949     { "convert2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert2), (intptr_t) (1) },
950     { "convert4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert4), (intptr_t) (1) },
951     { "convert5", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert5), (intptr_t) (1) },
952     { "mutablePointFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMutablePointFunction), (intptr_t) (0) },
953     { "immutablePointFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionImmutablePointFunction), (intptr_t) (0) },
954     { "orange", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOrange), (intptr_t) (0) },
955     { "strictFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunction), (intptr_t) (3) },
956     { "strictFunctionWithSequence", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunctionWithSequence), (intptr_t) (2) },
957     { "strictFunctionWithArray", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunctionWithArray), (intptr_t) (2) },
958     { "variadicStringMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicStringMethod), (intptr_t) (2) },
959     { "variadicDoubleMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicDoubleMethod), (intptr_t) (2) },
960     { "variadicNodeMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicNodeMethod), (intptr_t) (2) },
961     { "any", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAny), (intptr_t) (2) },
962 };
963
964 static const HashTable JSTestObjPrototypeTable = { 136, 511, true, JSTestObjPrototypeTableValues, 0, JSTestObjPrototypeTableIndex };
965 const ClassInfo JSTestObjPrototype::s_info = { "TestObjectPrototype", &Base::s_info, &JSTestObjPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestObjPrototype) };
966
967 JSObject* JSTestObjPrototype::self(VM& vm, JSGlobalObject* globalObject)
968 {
969     return getDOMPrototype<JSTestObj>(vm, globalObject);
970 }
971
972 bool JSTestObjPrototype::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
973 {
974     JSTestObjPrototype* thisObject = jsCast<JSTestObjPrototype*>(object);
975     return getStaticPropertySlot<JSTestObjPrototype, JSObject>(exec, JSTestObjPrototypeTable, thisObject, propertyName, slot);
976 }
977
978 const ClassInfo JSTestObj::s_info = { "TestObject", &Base::s_info, &JSTestObjTable, 0 , CREATE_METHOD_TABLE(JSTestObj) };
979
980 JSTestObj::JSTestObj(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestObj> impl)
981     : JSDOMWrapper(structure, globalObject)
982     , m_impl(impl.leakRef())
983 {
984 }
985
986 JSObject* JSTestObj::createPrototype(VM& vm, JSGlobalObject* globalObject)
987 {
988     return JSTestObjPrototype::create(vm, globalObject, JSTestObjPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
989 }
990
991 void JSTestObj::destroy(JSC::JSCell* cell)
992 {
993     JSTestObj* thisObject = static_cast<JSTestObj*>(cell);
994     thisObject->JSTestObj::~JSTestObj();
995 }
996
997 JSTestObj::~JSTestObj()
998 {
999     releaseImplIfNotNull();
1000 }
1001
1002 bool JSTestObj::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
1003 {
1004     JSTestObj* thisObject = jsCast<JSTestObj*>(object);
1005     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
1006     return getStaticValueSlot<JSTestObj, Base>(exec, JSTestObjTable, thisObject, propertyName, slot);
1007 }
1008
1009 EncodedJSValue jsTestObjReadOnlyLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1010 {
1011     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1012     UNUSED_PARAM(slotBase);
1013     if (UNLIKELY(!castedThis)) {
1014         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1015             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1016             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'readOnlyLongAttr' on a non-TestObj object."));
1017             return JSValue::encode(jsUndefined());
1018         }
1019         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "readOnlyLongAttr", " getter can only be used on instances of ", "TestObj"));
1020     }
1021     UNUSED_PARAM(exec);
1022     TestObj& impl = castedThis->impl();
1023     JSValue result = jsNumber(impl.readOnlyLongAttr());
1024     return JSValue::encode(result);
1025 }
1026
1027
1028 EncodedJSValue jsTestObjReadOnlyStringAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1029 {
1030     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1031     UNUSED_PARAM(slotBase);
1032     if (UNLIKELY(!castedThis)) {
1033         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1034             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1035             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'readOnlyStringAttr' on a non-TestObj object."));
1036             return JSValue::encode(jsUndefined());
1037         }
1038         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "readOnlyStringAttr", " getter can only be used on instances of ", "TestObj"));
1039     }
1040     UNUSED_PARAM(exec);
1041     TestObj& impl = castedThis->impl();
1042     JSValue result = jsStringWithCache(exec, impl.readOnlyStringAttr());
1043     return JSValue::encode(result);
1044 }
1045
1046
1047 EncodedJSValue jsTestObjReadOnlyTestObjAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1048 {
1049     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1050     UNUSED_PARAM(slotBase);
1051     if (UNLIKELY(!castedThis)) {
1052         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1053             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1054             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'readOnlyTestObjAttr' on a non-TestObj object."));
1055             return JSValue::encode(jsUndefined());
1056         }
1057         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "readOnlyTestObjAttr", " getter can only be used on instances of ", "TestObj"));
1058     }
1059     UNUSED_PARAM(exec);
1060     TestObj& impl = castedThis->impl();
1061     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.readOnlyTestObjAttr()));
1062     return JSValue::encode(result);
1063 }
1064
1065
1066 EncodedJSValue jsTestObjConstructorStaticReadOnlyLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1067 {
1068     UNUSED_PARAM(thisValue);
1069     UNUSED_PARAM(slotBase);
1070     UNUSED_PARAM(exec);
1071     JSValue result = jsNumber(TestObj::staticReadOnlyLongAttr());
1072     return JSValue::encode(result);
1073 }
1074
1075
1076 EncodedJSValue jsTestObjConstructorStaticStringAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1077 {
1078     UNUSED_PARAM(thisValue);
1079     UNUSED_PARAM(slotBase);
1080     UNUSED_PARAM(exec);
1081     JSValue result = jsStringWithCache(exec, TestObj::staticStringAttr());
1082     return JSValue::encode(result);
1083 }
1084
1085
1086 EncodedJSValue jsTestObjConstructorTestSubObj(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1087 {
1088     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1089     UNUSED_PARAM(slotBase);
1090     if (UNLIKELY(!castedThis)) {
1091         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1092             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1093             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'TestSubObj' on a non-TestObj object."));
1094             return JSValue::encode(jsUndefined());
1095         }
1096         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "TestSubObj", " getter can only be used on instances of ", "TestObj"));
1097     }
1098     return JSValue::encode(JSTestSubObj::getConstructor(exec->vm(), castedThis->globalObject()));
1099 }
1100
1101
1102 EncodedJSValue jsTestObjTestSubObjEnabledBySettingConstructor(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1103 {
1104     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1105     UNUSED_PARAM(slotBase);
1106     if (UNLIKELY(!castedThis)) {
1107         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1108             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1109             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'TestSubObjEnabledBySetting' on a non-TestObj object."));
1110             return JSValue::encode(jsUndefined());
1111         }
1112         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "TestSubObjEnabledBySetting", " getter can only be used on instances of ", "TestObj"));
1113     }
1114     if (!castedThis->impl().frame())
1115         return JSValue::encode(jsUndefined());
1116     Settings& settings = castedThis->impl().frame()->settings();
1117     if (!settings.testSettingEnabled())
1118         return JSValue::encode(jsUndefined());
1119     return JSValue::encode(JSTestSubObj::getConstructor(exec->vm(), castedThis->globalObject()));
1120 }
1121
1122
1123 EncodedJSValue jsTestObjEnumAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1124 {
1125     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1126     UNUSED_PARAM(slotBase);
1127     if (UNLIKELY(!castedThis)) {
1128         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1129             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1130             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'enumAttr' on a non-TestObj object."));
1131             return JSValue::encode(jsUndefined());
1132         }
1133         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "enumAttr", " getter can only be used on instances of ", "TestObj"));
1134     }
1135     UNUSED_PARAM(exec);
1136     TestObj& impl = castedThis->impl();
1137     JSValue result = jsStringWithCache(exec, impl.enumAttr());
1138     return JSValue::encode(result);
1139 }
1140
1141
1142 EncodedJSValue jsTestObjByteAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1143 {
1144     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1145     UNUSED_PARAM(slotBase);
1146     if (UNLIKELY(!castedThis)) {
1147         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1148             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1149             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'byteAttr' on a non-TestObj object."));
1150             return JSValue::encode(jsUndefined());
1151         }
1152         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "byteAttr", " getter can only be used on instances of ", "TestObj"));
1153     }
1154     UNUSED_PARAM(exec);
1155     TestObj& impl = castedThis->impl();
1156     JSValue result = jsNumber(impl.byteAttr());
1157     return JSValue::encode(result);
1158 }
1159
1160
1161 EncodedJSValue jsTestObjOctetAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1162 {
1163     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1164     UNUSED_PARAM(slotBase);
1165     if (UNLIKELY(!castedThis)) {
1166         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1167             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1168             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'octetAttr' on a non-TestObj object."));
1169             return JSValue::encode(jsUndefined());
1170         }
1171         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "octetAttr", " getter can only be used on instances of ", "TestObj"));
1172     }
1173     UNUSED_PARAM(exec);
1174     TestObj& impl = castedThis->impl();
1175     JSValue result = jsNumber(impl.octetAttr());
1176     return JSValue::encode(result);
1177 }
1178
1179
1180 EncodedJSValue jsTestObjShortAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1181 {
1182     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1183     UNUSED_PARAM(slotBase);
1184     if (UNLIKELY(!castedThis)) {
1185         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1186             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1187             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'shortAttr' on a non-TestObj object."));
1188             return JSValue::encode(jsUndefined());
1189         }
1190         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "shortAttr", " getter can only be used on instances of ", "TestObj"));
1191     }
1192     UNUSED_PARAM(exec);
1193     TestObj& impl = castedThis->impl();
1194     JSValue result = jsNumber(impl.shortAttr());
1195     return JSValue::encode(result);
1196 }
1197
1198
1199 EncodedJSValue jsTestObjUnsignedShortAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1200 {
1201     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1202     UNUSED_PARAM(slotBase);
1203     if (UNLIKELY(!castedThis)) {
1204         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1205             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1206             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'unsignedShortAttr' on a non-TestObj object."));
1207             return JSValue::encode(jsUndefined());
1208         }
1209         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "unsignedShortAttr", " getter can only be used on instances of ", "TestObj"));
1210     }
1211     UNUSED_PARAM(exec);
1212     TestObj& impl = castedThis->impl();
1213     JSValue result = jsNumber(impl.unsignedShortAttr());
1214     return JSValue::encode(result);
1215 }
1216
1217
1218 EncodedJSValue jsTestObjLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1219 {
1220     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1221     UNUSED_PARAM(slotBase);
1222     if (UNLIKELY(!castedThis)) {
1223         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1224             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1225             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'longAttr' on a non-TestObj object."));
1226             return JSValue::encode(jsUndefined());
1227         }
1228         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "longAttr", " getter can only be used on instances of ", "TestObj"));
1229     }
1230     UNUSED_PARAM(exec);
1231     TestObj& impl = castedThis->impl();
1232     JSValue result = jsNumber(impl.longAttr());
1233     return JSValue::encode(result);
1234 }
1235
1236
1237 EncodedJSValue jsTestObjLongLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1238 {
1239     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1240     UNUSED_PARAM(slotBase);
1241     if (UNLIKELY(!castedThis)) {
1242         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1243             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1244             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'longLongAttr' on a non-TestObj object."));
1245             return JSValue::encode(jsUndefined());
1246         }
1247         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "longLongAttr", " getter can only be used on instances of ", "TestObj"));
1248     }
1249     UNUSED_PARAM(exec);
1250     TestObj& impl = castedThis->impl();
1251     JSValue result = jsNumber(impl.longLongAttr());
1252     return JSValue::encode(result);
1253 }
1254
1255
1256 EncodedJSValue jsTestObjUnsignedLongLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1257 {
1258     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1259     UNUSED_PARAM(slotBase);
1260     if (UNLIKELY(!castedThis)) {
1261         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1262             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1263             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'unsignedLongLongAttr' on a non-TestObj object."));
1264             return JSValue::encode(jsUndefined());
1265         }
1266         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "unsignedLongLongAttr", " getter can only be used on instances of ", "TestObj"));
1267     }
1268     UNUSED_PARAM(exec);
1269     TestObj& impl = castedThis->impl();
1270     JSValue result = jsNumber(impl.unsignedLongLongAttr());
1271     return JSValue::encode(result);
1272 }
1273
1274
1275 EncodedJSValue jsTestObjStringAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1276 {
1277     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1278     UNUSED_PARAM(slotBase);
1279     if (UNLIKELY(!castedThis)) {
1280         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1281             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1282             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'stringAttr' on a non-TestObj object."));
1283             return JSValue::encode(jsUndefined());
1284         }
1285         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "stringAttr", " getter can only be used on instances of ", "TestObj"));
1286     }
1287     UNUSED_PARAM(exec);
1288     TestObj& impl = castedThis->impl();
1289     JSValue result = jsStringWithCache(exec, impl.stringAttr());
1290     return JSValue::encode(result);
1291 }
1292
1293
1294 EncodedJSValue jsTestObjTestObjAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1295 {
1296     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1297     UNUSED_PARAM(slotBase);
1298     if (UNLIKELY(!castedThis)) {
1299         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1300             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1301             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'testObjAttr' on a non-TestObj object."));
1302             return JSValue::encode(jsUndefined());
1303         }
1304         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "testObjAttr", " getter can only be used on instances of ", "TestObj"));
1305     }
1306     UNUSED_PARAM(exec);
1307     TestObj& impl = castedThis->impl();
1308     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.testObjAttr()));
1309     return JSValue::encode(result);
1310 }
1311
1312
1313 EncodedJSValue jsTestObjXMLObjAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1314 {
1315     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1316     UNUSED_PARAM(slotBase);
1317     if (UNLIKELY(!castedThis)) {
1318         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1319             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1320             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'XMLObjAttr' on a non-TestObj object."));
1321             return JSValue::encode(jsUndefined());
1322         }
1323         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "XMLObjAttr", " getter can only be used on instances of ", "TestObj"));
1324     }
1325     UNUSED_PARAM(exec);
1326     TestObj& impl = castedThis->impl();
1327     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.xmlObjAttr()));
1328     return JSValue::encode(result);
1329 }
1330
1331
1332 EncodedJSValue jsTestObjCreate(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1333 {
1334     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1335     UNUSED_PARAM(slotBase);
1336     if (UNLIKELY(!castedThis)) {
1337         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1338             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1339             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'create' on a non-TestObj object."));
1340             return JSValue::encode(jsUndefined());
1341         }
1342         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "create", " getter can only be used on instances of ", "TestObj"));
1343     }
1344     UNUSED_PARAM(exec);
1345     TestObj& impl = castedThis->impl();
1346     JSValue result = jsBoolean(impl.isCreate());
1347     return JSValue::encode(result);
1348 }
1349
1350
1351 EncodedJSValue jsTestObjReflectedStringAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1352 {
1353     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1354     UNUSED_PARAM(slotBase);
1355     if (UNLIKELY(!castedThis)) {
1356         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1357             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1358             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'reflectedStringAttr' on a non-TestObj object."));
1359             return JSValue::encode(jsUndefined());
1360         }
1361         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedStringAttr", " getter can only be used on instances of ", "TestObj"));
1362     }
1363     UNUSED_PARAM(exec);
1364     TestObj& impl = castedThis->impl();
1365     JSValue result = jsStringWithCache(exec, impl.fastGetAttribute(WebCore::HTMLNames::reflectedstringattrAttr));
1366     return JSValue::encode(result);
1367 }
1368
1369
1370 EncodedJSValue jsTestObjReflectedIntegralAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1371 {
1372     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1373     UNUSED_PARAM(slotBase);
1374     if (UNLIKELY(!castedThis)) {
1375         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1376             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1377             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'reflectedIntegralAttr' on a non-TestObj object."));
1378             return JSValue::encode(jsUndefined());
1379         }
1380         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedIntegralAttr", " getter can only be used on instances of ", "TestObj"));
1381     }
1382     UNUSED_PARAM(exec);
1383     TestObj& impl = castedThis->impl();
1384     JSValue result = jsNumber(impl.getIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr));
1385     return JSValue::encode(result);
1386 }
1387
1388
1389 EncodedJSValue jsTestObjReflectedUnsignedIntegralAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1390 {
1391     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1392     UNUSED_PARAM(slotBase);
1393     if (UNLIKELY(!castedThis)) {
1394         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1395             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1396             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'reflectedUnsignedIntegralAttr' on a non-TestObj object."));
1397             return JSValue::encode(jsUndefined());
1398         }
1399         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedUnsignedIntegralAttr", " getter can only be used on instances of ", "TestObj"));
1400     }
1401     UNUSED_PARAM(exec);
1402     TestObj& impl = castedThis->impl();
1403     JSValue result = jsNumber(std::max(0, impl.getIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr)));
1404     return JSValue::encode(result);
1405 }
1406
1407
1408 EncodedJSValue jsTestObjReflectedBooleanAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1409 {
1410     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1411     UNUSED_PARAM(slotBase);
1412     if (UNLIKELY(!castedThis)) {
1413         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1414             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1415             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'reflectedBooleanAttr' on a non-TestObj object."));
1416             return JSValue::encode(jsUndefined());
1417         }
1418         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedBooleanAttr", " getter can only be used on instances of ", "TestObj"));
1419     }
1420     UNUSED_PARAM(exec);
1421     TestObj& impl = castedThis->impl();
1422     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr));
1423     return JSValue::encode(result);
1424 }
1425
1426
1427 EncodedJSValue jsTestObjReflectedURLAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1428 {
1429     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1430     UNUSED_PARAM(slotBase);
1431     if (UNLIKELY(!castedThis)) {
1432         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1433             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1434             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'reflectedURLAttr' on a non-TestObj object."));
1435             return JSValue::encode(jsUndefined());
1436         }
1437         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedURLAttr", " getter can only be used on instances of ", "TestObj"));
1438     }
1439     UNUSED_PARAM(exec);
1440     TestObj& impl = castedThis->impl();
1441     JSValue result = jsStringWithCache(exec, impl.getURLAttribute(WebCore::HTMLNames::reflectedurlattrAttr));
1442     return JSValue::encode(result);
1443 }
1444
1445
1446 EncodedJSValue jsTestObjReflectedStringAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1447 {
1448     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1449     UNUSED_PARAM(slotBase);
1450     if (UNLIKELY(!castedThis)) {
1451         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1452             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1453             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'reflectedStringAttr' on a non-TestObj object."));
1454             return JSValue::encode(jsUndefined());
1455         }
1456         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedStringAttr", " getter can only be used on instances of ", "TestObj"));
1457     }
1458     UNUSED_PARAM(exec);
1459     TestObj& impl = castedThis->impl();
1460     JSValue result = jsStringWithCache(exec, impl.fastGetAttribute(WebCore::HTMLNames::customContentStringAttrAttr));
1461     return JSValue::encode(result);
1462 }
1463
1464
1465 EncodedJSValue jsTestObjReflectedCustomIntegralAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1466 {
1467     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1468     UNUSED_PARAM(slotBase);
1469     if (UNLIKELY(!castedThis)) {
1470         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1471             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1472             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'reflectedCustomIntegralAttr' on a non-TestObj object."));
1473             return JSValue::encode(jsUndefined());
1474         }
1475         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedCustomIntegralAttr", " getter can only be used on instances of ", "TestObj"));
1476     }
1477     UNUSED_PARAM(exec);
1478     TestObj& impl = castedThis->impl();
1479     JSValue result = jsNumber(impl.getIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr));
1480     return JSValue::encode(result);
1481 }
1482
1483
1484 EncodedJSValue jsTestObjReflectedCustomBooleanAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1485 {
1486     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1487     UNUSED_PARAM(slotBase);
1488     if (UNLIKELY(!castedThis)) {
1489         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1490             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1491             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'reflectedCustomBooleanAttr' on a non-TestObj object."));
1492             return JSValue::encode(jsUndefined());
1493         }
1494         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedCustomBooleanAttr", " getter can only be used on instances of ", "TestObj"));
1495     }
1496     UNUSED_PARAM(exec);
1497     TestObj& impl = castedThis->impl();
1498     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr));
1499     return JSValue::encode(result);
1500 }
1501
1502
1503 EncodedJSValue jsTestObjReflectedCustomURLAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1504 {
1505     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1506     UNUSED_PARAM(slotBase);
1507     if (UNLIKELY(!castedThis)) {
1508         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1509             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1510             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'reflectedCustomURLAttr' on a non-TestObj object."));
1511             return JSValue::encode(jsUndefined());
1512         }
1513         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedCustomURLAttr", " getter can only be used on instances of ", "TestObj"));
1514     }
1515     UNUSED_PARAM(exec);
1516     TestObj& impl = castedThis->impl();
1517     JSValue result = jsStringWithCache(exec, impl.getURLAttribute(WebCore::HTMLNames::customContentURLAttrAttr));
1518     return JSValue::encode(result);
1519 }
1520
1521
1522 EncodedJSValue jsTestObjTypedArrayAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1523 {
1524     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1525     UNUSED_PARAM(slotBase);
1526     if (UNLIKELY(!castedThis)) {
1527         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1528             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1529             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'typedArrayAttr' on a non-TestObj object."));
1530             return JSValue::encode(jsUndefined());
1531         }
1532         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "typedArrayAttr", " getter can only be used on instances of ", "TestObj"));
1533     }
1534     UNUSED_PARAM(exec);
1535     TestObj& impl = castedThis->impl();
1536     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.typedArrayAttr()));
1537     return JSValue::encode(result);
1538 }
1539
1540
1541 EncodedJSValue jsTestObjAttrWithGetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1542 {
1543     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1544     UNUSED_PARAM(slotBase);
1545     if (UNLIKELY(!castedThis)) {
1546         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1547             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1548             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'attrWithGetterException' on a non-TestObj object."));
1549             return JSValue::encode(jsUndefined());
1550         }
1551         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "attrWithGetterException", " getter can only be used on instances of ", "TestObj"));
1552     }
1553     ExceptionCode ec = 0;
1554     TestObj& impl = castedThis->impl();
1555     JSValue result = jsNumber(impl.attrWithGetterException(ec));
1556     setDOMException(exec, ec);
1557     return JSValue::encode(result);
1558 }
1559
1560
1561 EncodedJSValue jsTestObjAttrWithSetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1562 {
1563     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1564     UNUSED_PARAM(slotBase);
1565     if (UNLIKELY(!castedThis)) {
1566         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1567             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1568             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'attrWithSetterException' on a non-TestObj object."));
1569             return JSValue::encode(jsUndefined());
1570         }
1571         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "attrWithSetterException", " getter can only be used on instances of ", "TestObj"));
1572     }
1573     UNUSED_PARAM(exec);
1574     TestObj& impl = castedThis->impl();
1575     JSValue result = jsNumber(impl.attrWithSetterException());
1576     return JSValue::encode(result);
1577 }
1578
1579
1580 EncodedJSValue jsTestObjStringAttrWithGetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1581 {
1582     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1583     UNUSED_PARAM(slotBase);
1584     if (UNLIKELY(!castedThis)) {
1585         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1586             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1587             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'stringAttrWithGetterException' on a non-TestObj object."));
1588             return JSValue::encode(jsUndefined());
1589         }
1590         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "stringAttrWithGetterException", " getter can only be used on instances of ", "TestObj"));
1591     }
1592     ExceptionCode ec = 0;
1593     TestObj& impl = castedThis->impl();
1594     JSValue result = jsStringWithCache(exec, impl.stringAttrWithGetterException(ec));
1595     setDOMException(exec, ec);
1596     return JSValue::encode(result);
1597 }
1598
1599
1600 EncodedJSValue jsTestObjStringAttrWithSetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1601 {
1602     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1603     UNUSED_PARAM(slotBase);
1604     if (UNLIKELY(!castedThis)) {
1605         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1606             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1607             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'stringAttrWithSetterException' on a non-TestObj object."));
1608             return JSValue::encode(jsUndefined());
1609         }
1610         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "stringAttrWithSetterException", " getter can only be used on instances of ", "TestObj"));
1611     }
1612     UNUSED_PARAM(exec);
1613     TestObj& impl = castedThis->impl();
1614     JSValue result = jsStringWithCache(exec, impl.stringAttrWithSetterException());
1615     return JSValue::encode(result);
1616 }
1617
1618
1619 EncodedJSValue jsTestObjCustomAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1620 {
1621     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1622     UNUSED_PARAM(slotBase);
1623     if (UNLIKELY(!castedThis)) {
1624         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1625             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1626             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'customAttr' on a non-TestObj object."));
1627             return JSValue::encode(jsUndefined());
1628         }
1629         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "customAttr", " getter can only be used on instances of ", "TestObj"));
1630     }
1631     return JSValue::encode(castedThis->customAttr(exec));
1632 }
1633
1634
1635 EncodedJSValue jsTestObjWithScriptStateAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1636 {
1637     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1638     UNUSED_PARAM(slotBase);
1639     if (UNLIKELY(!castedThis)) {
1640         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1641             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1642             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'withScriptStateAttribute' on a non-TestObj object."));
1643             return JSValue::encode(jsUndefined());
1644         }
1645         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptStateAttribute", " getter can only be used on instances of ", "TestObj"));
1646     }
1647     TestObj& impl = castedThis->impl();
1648     JSValue result = jsNumber(impl.withScriptStateAttribute(exec));
1649     return JSValue::encode(result);
1650 }
1651
1652
1653 EncodedJSValue jsTestObjWithScriptExecutionContextAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1654 {
1655     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1656     UNUSED_PARAM(slotBase);
1657     if (UNLIKELY(!castedThis)) {
1658         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1659             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1660             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'withScriptExecutionContextAttribute' on a non-TestObj object."));
1661             return JSValue::encode(jsUndefined());
1662         }
1663         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptExecutionContextAttribute", " getter can only be used on instances of ", "TestObj"));
1664     }
1665     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1666     if (!scriptContext)
1667         return JSValue::encode(jsUndefined());
1668     TestObj& impl = castedThis->impl();
1669     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttribute(scriptContext)));
1670     return JSValue::encode(result);
1671 }
1672
1673
1674 EncodedJSValue jsTestObjWithScriptStateAttributeRaises(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1675 {
1676     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1677     UNUSED_PARAM(slotBase);
1678     if (UNLIKELY(!castedThis)) {
1679         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1680             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1681             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'withScriptStateAttributeRaises' on a non-TestObj object."));
1682             return JSValue::encode(jsUndefined());
1683         }
1684         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptStateAttributeRaises", " getter can only be used on instances of ", "TestObj"));
1685     }
1686     ExceptionCode ec = 0;
1687     TestObj& impl = castedThis->impl();
1688     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateAttributeRaises(exec, ec)));
1689     setDOMException(exec, ec);
1690     return JSValue::encode(result);
1691 }
1692
1693
1694 EncodedJSValue jsTestObjWithScriptExecutionContextAttributeRaises(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1695 {
1696     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1697     UNUSED_PARAM(slotBase);
1698     if (UNLIKELY(!castedThis)) {
1699         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1700             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1701             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'withScriptExecutionContextAttributeRaises' on a non-TestObj object."));
1702             return JSValue::encode(jsUndefined());
1703         }
1704         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptExecutionContextAttributeRaises", " getter can only be used on instances of ", "TestObj"));
1705     }
1706     ExceptionCode ec = 0;
1707     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1708     if (!scriptContext)
1709         return JSValue::encode(jsUndefined());
1710     TestObj& impl = castedThis->impl();
1711     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttributeRaises(scriptContext, ec)));
1712     setDOMException(exec, ec);
1713     return JSValue::encode(result);
1714 }
1715
1716
1717 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1718 {
1719     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1720     UNUSED_PARAM(slotBase);
1721     if (UNLIKELY(!castedThis)) {
1722         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1723             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1724             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'withScriptExecutionContextAndScriptStateAttribute' on a non-TestObj object."));
1725             return JSValue::encode(jsUndefined());
1726         }
1727         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptExecutionContextAndScriptStateAttribute", " getter can only be used on instances of ", "TestObj"));
1728     }
1729     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1730     if (!scriptContext)
1731         return JSValue::encode(jsUndefined());
1732     TestObj& impl = castedThis->impl();
1733     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttribute(exec, scriptContext)));
1734     return JSValue::encode(result);
1735 }
1736
1737
1738 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1739 {
1740     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1741     UNUSED_PARAM(slotBase);
1742     if (UNLIKELY(!castedThis)) {
1743         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1744             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1745             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'withScriptExecutionContextAndScriptStateAttributeRaises' on a non-TestObj object."));
1746             return JSValue::encode(jsUndefined());
1747         }
1748         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptExecutionContextAndScriptStateAttributeRaises", " getter can only be used on instances of ", "TestObj"));
1749     }
1750     ExceptionCode ec = 0;
1751     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1752     if (!scriptContext)
1753         return JSValue::encode(jsUndefined());
1754     TestObj& impl = castedThis->impl();
1755     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttributeRaises(exec, scriptContext, ec)));
1756     setDOMException(exec, ec);
1757     return JSValue::encode(result);
1758 }
1759
1760
1761 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1762 {
1763     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1764     UNUSED_PARAM(slotBase);
1765     if (UNLIKELY(!castedThis)) {
1766         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1767             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1768             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'withScriptExecutionContextAndScriptStateWithSpacesAttribute' on a non-TestObj object."));
1769             return JSValue::encode(jsUndefined());
1770         }
1771         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptExecutionContextAndScriptStateWithSpacesAttribute", " getter can only be used on instances of ", "TestObj"));
1772     }
1773     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1774     if (!scriptContext)
1775         return JSValue::encode(jsUndefined());
1776     TestObj& impl = castedThis->impl();
1777     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateWithSpacesAttribute(exec, scriptContext)));
1778     return JSValue::encode(result);
1779 }
1780
1781
1782 EncodedJSValue jsTestObjWithScriptArgumentsAndCallStackAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1783 {
1784     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1785     UNUSED_PARAM(slotBase);
1786     if (UNLIKELY(!castedThis)) {
1787         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1788             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1789             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'withScriptArgumentsAndCallStackAttribute' on a non-TestObj object."));
1790             return JSValue::encode(jsUndefined());
1791         }
1792         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptArgumentsAndCallStackAttribute", " getter can only be used on instances of ", "TestObj"));
1793     }
1794     TestObj& impl = castedThis->impl();
1795     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptArgumentsAndCallStackAttribute()));
1796     return JSValue::encode(result);
1797 }
1798
1799
1800 #if ENABLE(Condition1)
1801 EncodedJSValue jsTestObjConditionalAttr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1802 {
1803     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1804     UNUSED_PARAM(slotBase);
1805     if (UNLIKELY(!castedThis)) {
1806         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1807             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1808             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'conditionalAttr1' on a non-TestObj object."));
1809             return JSValue::encode(jsUndefined());
1810         }
1811         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr1", " getter can only be used on instances of ", "TestObj"));
1812     }
1813     UNUSED_PARAM(exec);
1814     TestObj& impl = castedThis->impl();
1815     JSValue result = jsNumber(impl.conditionalAttr1());
1816     return JSValue::encode(result);
1817 }
1818
1819 #endif
1820
1821 #if ENABLE(Condition1) && ENABLE(Condition2)
1822 EncodedJSValue jsTestObjConditionalAttr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1823 {
1824     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1825     UNUSED_PARAM(slotBase);
1826     if (UNLIKELY(!castedThis)) {
1827         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1828             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1829             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'conditionalAttr2' on a non-TestObj object."));
1830             return JSValue::encode(jsUndefined());
1831         }
1832         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr2", " getter can only be used on instances of ", "TestObj"));
1833     }
1834     UNUSED_PARAM(exec);
1835     TestObj& impl = castedThis->impl();
1836     JSValue result = jsNumber(impl.conditionalAttr2());
1837     return JSValue::encode(result);
1838 }
1839
1840 #endif
1841
1842 #if ENABLE(Condition1) || ENABLE(Condition2)
1843 EncodedJSValue jsTestObjConditionalAttr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1844 {
1845     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1846     UNUSED_PARAM(slotBase);
1847     if (UNLIKELY(!castedThis)) {
1848         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1849             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1850             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'conditionalAttr3' on a non-TestObj object."));
1851             return JSValue::encode(jsUndefined());
1852         }
1853         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr3", " getter can only be used on instances of ", "TestObj"));
1854     }
1855     UNUSED_PARAM(exec);
1856     TestObj& impl = castedThis->impl();
1857     JSValue result = jsNumber(impl.conditionalAttr3());
1858     return JSValue::encode(result);
1859 }
1860
1861 #endif
1862
1863 #if ENABLE(Condition1)
1864 EncodedJSValue jsTestObjConditionalAttr4Constructor(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1865 {
1866     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1867     UNUSED_PARAM(slotBase);
1868     if (UNLIKELY(!castedThis)) {
1869         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1870             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1871             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'conditionalAttr4' on a non-TestObj object."));
1872             return JSValue::encode(jsUndefined());
1873         }
1874         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr4", " getter can only be used on instances of ", "TestObj"));
1875     }
1876     return JSValue::encode(JSTestObjectA::getConstructor(exec->vm(), castedThis->globalObject()));
1877 }
1878
1879 #endif
1880
1881 #if ENABLE(Condition1) && ENABLE(Condition2)
1882 EncodedJSValue jsTestObjConditionalAttr5Constructor(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1883 {
1884     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1885     UNUSED_PARAM(slotBase);
1886     if (UNLIKELY(!castedThis)) {
1887         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1888             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1889             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'conditionalAttr5' on a non-TestObj object."));
1890             return JSValue::encode(jsUndefined());
1891         }
1892         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr5", " getter can only be used on instances of ", "TestObj"));
1893     }
1894     return JSValue::encode(JSTestObjectB::getConstructor(exec->vm(), castedThis->globalObject()));
1895 }
1896
1897 #endif
1898
1899 #if ENABLE(Condition1) || ENABLE(Condition2)
1900 EncodedJSValue jsTestObjConditionalAttr6Constructor(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1901 {
1902     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1903     UNUSED_PARAM(slotBase);
1904     if (UNLIKELY(!castedThis)) {
1905         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1906             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1907             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'conditionalAttr6' on a non-TestObj object."));
1908             return JSValue::encode(jsUndefined());
1909         }
1910         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr6", " getter can only be used on instances of ", "TestObj"));
1911     }
1912     return JSValue::encode(JSTestObjectC::getConstructor(exec->vm(), castedThis->globalObject()));
1913 }
1914
1915 #endif
1916
1917 EncodedJSValue jsTestObjCachedAttribute1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1918 {
1919     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1920     UNUSED_PARAM(slotBase);
1921     if (UNLIKELY(!castedThis)) {
1922         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1923             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1924             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'cachedAttribute1' on a non-TestObj object."));
1925             return JSValue::encode(jsUndefined());
1926         }
1927         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "cachedAttribute1", " getter can only be used on instances of ", "TestObj"));
1928     }
1929     UNUSED_PARAM(exec);
1930     if (JSValue cachedValue = castedThis->m_cachedAttribute1.get())
1931         return JSValue::encode(cachedValue);
1932     TestObj& impl = castedThis->impl();
1933     JSValue result = (impl.cachedAttribute1().hasNoValue() ? jsNull() : impl.cachedAttribute1().jsValue());
1934     castedThis->m_cachedAttribute1.set(exec->vm(), castedThis, result);
1935     return JSValue::encode(result);
1936 }
1937
1938
1939 EncodedJSValue jsTestObjCachedAttribute2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1940 {
1941     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1942     UNUSED_PARAM(slotBase);
1943     if (UNLIKELY(!castedThis)) {
1944         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1945             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1946             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'cachedAttribute2' on a non-TestObj object."));
1947             return JSValue::encode(jsUndefined());
1948         }
1949         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "cachedAttribute2", " getter can only be used on instances of ", "TestObj"));
1950     }
1951     UNUSED_PARAM(exec);
1952     if (JSValue cachedValue = castedThis->m_cachedAttribute2.get())
1953         return JSValue::encode(cachedValue);
1954     TestObj& impl = castedThis->impl();
1955     JSValue result = (impl.cachedAttribute2().hasNoValue() ? jsNull() : impl.cachedAttribute2().jsValue());
1956     castedThis->m_cachedAttribute2.set(exec->vm(), castedThis, result);
1957     return JSValue::encode(result);
1958 }
1959
1960
1961 EncodedJSValue jsTestObjAnyAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1962 {
1963     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1964     UNUSED_PARAM(slotBase);
1965     if (UNLIKELY(!castedThis)) {
1966         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1967             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1968             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'anyAttribute' on a non-TestObj object."));
1969             return JSValue::encode(jsUndefined());
1970         }
1971         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "anyAttribute", " getter can only be used on instances of ", "TestObj"));
1972     }
1973     UNUSED_PARAM(exec);
1974     TestObj& impl = castedThis->impl();
1975     JSValue result = (impl.anyAttribute().hasNoValue() ? jsNull() : impl.anyAttribute().jsValue());
1976     return JSValue::encode(result);
1977 }
1978
1979
1980 EncodedJSValue jsTestObjContentDocument(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1981 {
1982     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
1983     UNUSED_PARAM(slotBase);
1984     if (UNLIKELY(!castedThis)) {
1985         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
1986             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
1987             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'contentDocument' on a non-TestObj object."));
1988             return JSValue::encode(jsUndefined());
1989         }
1990         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "contentDocument", " getter can only be used on instances of ", "TestObj"));
1991     }
1992     TestObj& impl = castedThis->impl();
1993     return JSValue::encode(shouldAllowAccessToNode(exec, impl.contentDocument()) ? toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.contentDocument())) : jsNull());
1994 }
1995
1996
1997 EncodedJSValue jsTestObjMutablePoint(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
1998 {
1999     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2000     UNUSED_PARAM(slotBase);
2001     if (UNLIKELY(!castedThis)) {
2002         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2003             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2004             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'mutablePoint' on a non-TestObj object."));
2005             return JSValue::encode(jsUndefined());
2006         }
2007         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "mutablePoint", " getter can only be used on instances of ", "TestObj"));
2008     }
2009     UNUSED_PARAM(exec);
2010     TestObj& impl = castedThis->impl();
2011     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGStaticPropertyTearOff<TestObj, SVGPoint>::create(impl, impl.mutablePoint(), &TestObj::updateMutablePoint)));
2012     return JSValue::encode(result);
2013 }
2014
2015
2016 EncodedJSValue jsTestObjImmutablePoint(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2017 {
2018     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2019     UNUSED_PARAM(slotBase);
2020     if (UNLIKELY(!castedThis)) {
2021         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2022             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2023             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'immutablePoint' on a non-TestObj object."));
2024             return JSValue::encode(jsUndefined());
2025         }
2026         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "immutablePoint", " getter can only be used on instances of ", "TestObj"));
2027     }
2028     UNUSED_PARAM(exec);
2029     TestObj& impl = castedThis->impl();
2030     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePoint())));
2031     return JSValue::encode(result);
2032 }
2033
2034
2035 EncodedJSValue jsTestObjStrawberry(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2036 {
2037     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2038     UNUSED_PARAM(slotBase);
2039     if (UNLIKELY(!castedThis)) {
2040         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2041             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2042             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'strawberry' on a non-TestObj object."));
2043             return JSValue::encode(jsUndefined());
2044         }
2045         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "strawberry", " getter can only be used on instances of ", "TestObj"));
2046     }
2047     UNUSED_PARAM(exec);
2048     TestObj& impl = castedThis->impl();
2049     JSValue result = jsNumber(impl.blueberry());
2050     return JSValue::encode(result);
2051 }
2052
2053
2054 EncodedJSValue jsTestObjStrictFloat(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2055 {
2056     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2057     UNUSED_PARAM(slotBase);
2058     if (UNLIKELY(!castedThis)) {
2059         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2060             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2061             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'strictFloat' on a non-TestObj object."));
2062             return JSValue::encode(jsUndefined());
2063         }
2064         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "strictFloat", " getter can only be used on instances of ", "TestObj"));
2065     }
2066     UNUSED_PARAM(exec);
2067     TestObj& impl = castedThis->impl();
2068     JSValue result = jsNumber(impl.strictFloat());
2069     return JSValue::encode(result);
2070 }
2071
2072
2073 EncodedJSValue jsTestObjDescription(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2074 {
2075     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2076     UNUSED_PARAM(slotBase);
2077     if (UNLIKELY(!castedThis)) {
2078         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2079             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2080             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'description' on a non-TestObj object."));
2081             return JSValue::encode(jsUndefined());
2082         }
2083         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "description", " getter can only be used on instances of ", "TestObj"));
2084     }
2085     UNUSED_PARAM(exec);
2086     TestObj& impl = castedThis->impl();
2087     JSValue result = jsNumber(impl.description());
2088     return JSValue::encode(result);
2089 }
2090
2091
2092 EncodedJSValue jsTestObjId(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2093 {
2094     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2095     UNUSED_PARAM(slotBase);
2096     if (UNLIKELY(!castedThis)) {
2097         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2098             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2099             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'id' on a non-TestObj object."));
2100             return JSValue::encode(jsUndefined());
2101         }
2102         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "id", " getter can only be used on instances of ", "TestObj"));
2103     }
2104     UNUSED_PARAM(exec);
2105     TestObj& impl = castedThis->impl();
2106     JSValue result = jsNumber(impl.id());
2107     return JSValue::encode(result);
2108 }
2109
2110
2111 EncodedJSValue jsTestObjHash(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2112 {
2113     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2114     UNUSED_PARAM(slotBase);
2115     if (UNLIKELY(!castedThis)) {
2116         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2117             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2118             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'hash' on a non-TestObj object."));
2119             return JSValue::encode(jsUndefined());
2120         }
2121         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "hash", " getter can only be used on instances of ", "TestObj"));
2122     }
2123     UNUSED_PARAM(exec);
2124     TestObj& impl = castedThis->impl();
2125     JSValue result = jsStringWithCache(exec, impl.hash());
2126     return JSValue::encode(result);
2127 }
2128
2129
2130 EncodedJSValue jsTestObjReplaceableAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2131 {
2132     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2133     UNUSED_PARAM(slotBase);
2134     if (UNLIKELY(!castedThis)) {
2135         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2136             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2137             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'replaceableAttribute' on a non-TestObj object."));
2138             return JSValue::encode(jsUndefined());
2139         }
2140         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "replaceableAttribute", " getter can only be used on instances of ", "TestObj"));
2141     }
2142     UNUSED_PARAM(exec);
2143     TestObj& impl = castedThis->impl();
2144     JSValue result = jsNumber(impl.replaceableAttribute());
2145     return JSValue::encode(result);
2146 }
2147
2148
2149 EncodedJSValue jsTestObjNullableDoubleAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2150 {
2151     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2152     UNUSED_PARAM(slotBase);
2153     if (UNLIKELY(!castedThis)) {
2154         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2155             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2156             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'nullableDoubleAttribute' on a non-TestObj object."));
2157             return JSValue::encode(jsUndefined());
2158         }
2159         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "nullableDoubleAttribute", " getter can only be used on instances of ", "TestObj"));
2160     }
2161     UNUSED_PARAM(exec);
2162     bool isNull = false;
2163     TestObj& impl = castedThis->impl();
2164     JSValue result = jsNumber(impl.nullableDoubleAttribute(isNull));
2165     if (isNull)
2166         return JSValue::encode(jsNull());
2167     return JSValue::encode(result);
2168 }
2169
2170
2171 EncodedJSValue jsTestObjNullableLongAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2172 {
2173     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2174     UNUSED_PARAM(slotBase);
2175     if (UNLIKELY(!castedThis)) {
2176         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2177             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2178             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'nullableLongAttribute' on a non-TestObj object."));
2179             return JSValue::encode(jsUndefined());
2180         }
2181         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "nullableLongAttribute", " getter can only be used on instances of ", "TestObj"));
2182     }
2183     UNUSED_PARAM(exec);
2184     bool isNull = false;
2185     TestObj& impl = castedThis->impl();
2186     JSValue result = jsNumber(impl.nullableLongAttribute(isNull));
2187     if (isNull)
2188         return JSValue::encode(jsNull());
2189     return JSValue::encode(result);
2190 }
2191
2192
2193 EncodedJSValue jsTestObjNullableBooleanAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2194 {
2195     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2196     UNUSED_PARAM(slotBase);
2197     if (UNLIKELY(!castedThis)) {
2198         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2199             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2200             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'nullableBooleanAttribute' on a non-TestObj object."));
2201             return JSValue::encode(jsUndefined());
2202         }
2203         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "nullableBooleanAttribute", " getter can only be used on instances of ", "TestObj"));
2204     }
2205     UNUSED_PARAM(exec);
2206     bool isNull = false;
2207     TestObj& impl = castedThis->impl();
2208     JSValue result = jsBoolean(impl.nullableBooleanAttribute(isNull));
2209     if (isNull)
2210         return JSValue::encode(jsNull());
2211     return JSValue::encode(result);
2212 }
2213
2214
2215 EncodedJSValue jsTestObjNullableStringAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2216 {
2217     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2218     UNUSED_PARAM(slotBase);
2219     if (UNLIKELY(!castedThis)) {
2220         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2221             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2222             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'nullableStringAttribute' on a non-TestObj object."));
2223             return JSValue::encode(jsUndefined());
2224         }
2225         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "nullableStringAttribute", " getter can only be used on instances of ", "TestObj"));
2226     }
2227     UNUSED_PARAM(exec);
2228     bool isNull = false;
2229     TestObj& impl = castedThis->impl();
2230     JSValue result = jsStringWithCache(exec, impl.nullableStringAttribute(isNull));
2231     if (isNull)
2232         return JSValue::encode(jsNull());
2233     return JSValue::encode(result);
2234 }
2235
2236
2237 EncodedJSValue jsTestObjNullableLongSettableAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2238 {
2239     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2240     UNUSED_PARAM(slotBase);
2241     if (UNLIKELY(!castedThis)) {
2242         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2243             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2244             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'nullableLongSettableAttribute' on a non-TestObj object."));
2245             return JSValue::encode(jsUndefined());
2246         }
2247         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "nullableLongSettableAttribute", " getter can only be used on instances of ", "TestObj"));
2248     }
2249     UNUSED_PARAM(exec);
2250     bool isNull = false;
2251     TestObj& impl = castedThis->impl();
2252     JSValue result = jsNumber(impl.nullableLongSettableAttribute(isNull));
2253     if (isNull)
2254         return JSValue::encode(jsNull());
2255     return JSValue::encode(result);
2256 }
2257
2258
2259 EncodedJSValue jsTestObjNullableStringValue(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2260 {
2261     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2262     UNUSED_PARAM(slotBase);
2263     if (UNLIKELY(!castedThis)) {
2264         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2265             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2266             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'nullableStringValue' on a non-TestObj object."));
2267             return JSValue::encode(jsUndefined());
2268         }
2269         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "nullableStringValue", " getter can only be used on instances of ", "TestObj"));
2270     }
2271     ExceptionCode ec = 0;
2272     bool isNull = false;
2273     TestObj& impl = castedThis->impl();
2274     JSValue result = jsNumber(impl.nullableStringValue(isNull, ec));
2275     if (isNull)
2276         return JSValue::encode(jsNull());
2277     setDOMException(exec, ec);
2278     return JSValue::encode(result);
2279 }
2280
2281
2282 EncodedJSValue jsTestObjAttribute(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2283 {
2284     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2285     UNUSED_PARAM(slotBase);
2286     if (UNLIKELY(!castedThis)) {
2287         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2288             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2289             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'attribute' on a non-TestObj object."));
2290             return JSValue::encode(jsUndefined());
2291         }
2292         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "attribute", " getter can only be used on instances of ", "TestObj"));
2293     }
2294     UNUSED_PARAM(exec);
2295     TestObj& impl = castedThis->impl();
2296     JSValue result = jsStringWithCache(exec, impl.attribute());
2297     return JSValue::encode(result);
2298 }
2299
2300
2301 EncodedJSValue jsTestObjAttributeWithReservedEnumType(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
2302 {
2303     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2304     UNUSED_PARAM(slotBase);
2305     if (UNLIKELY(!castedThis)) {
2306         if (jsDynamicCast<JSTestObjPrototype*>(slotBase)) {
2307             ScriptExecutionContext* scriptExecutionContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2308             scriptExecutionContext->addConsoleMessage(MessageSource::JS, MessageLevel::Error, String("Deprecated attempt to access property 'attributeWithReservedEnumType' on a non-TestObj object."));
2309             return JSValue::encode(jsUndefined());
2310         }
2311         return throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "attributeWithReservedEnumType", " getter can only be used on instances of ", "TestObj"));
2312     }
2313     UNUSED_PARAM(exec);
2314     TestObj& impl = castedThis->impl();
2315     JSValue result = jsStringWithCache(exec, impl.attributeWithReservedEnumType());
2316     return JSValue::encode(result);
2317 }
2318
2319
2320 EncodedJSValue jsTestObjConstructor(ExecState* exec, JSObject* baseValue, EncodedJSValue thisValue, PropertyName)
2321 {
2322     UNUSED_PARAM(baseValue);
2323     UNUSED_PARAM(thisValue);
2324     JSTestObjPrototype* domObject = jsDynamicCast<JSTestObjPrototype*>(baseValue);
2325     if (!domObject)
2326         return throwVMTypeError(exec);
2327     return JSValue::encode(JSTestObj::getConstructor(exec->vm(), domObject->globalObject()));
2328 }
2329
2330 void setJSTestObjConstructorStaticStringAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue, EncodedJSValue encodedValue)
2331 {
2332     JSValue value = JSValue::decode(encodedValue);
2333     UNUSED_PARAM(exec);
2334     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
2335     if (UNLIKELY(exec->hadException()))
2336         return;
2337     TestObj::setStaticStringAttr(nativeValue);
2338 }
2339
2340
2341 void setJSTestObjTestSubObjEnabledBySettingConstructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2342 {
2343     JSValue value = JSValue::decode(encodedValue);
2344     UNUSED_PARAM(exec);
2345     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2346     if (UNLIKELY(!castedThis)) {
2347         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "TestSubObjEnabledBySetting", " setter can only be used on instances of ", "TestObj"));
2348         return;
2349     }
2350     // Shadowing a built-in constructor
2351     castedThis->putDirect(exec->vm(), Identifier(exec, "TestSubObjEnabledBySetting"), value);
2352 }
2353
2354
2355 void setJSTestObjEnumAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2356 {
2357     JSValue value = JSValue::decode(encodedValue);
2358     UNUSED_PARAM(exec);
2359     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2360     if (UNLIKELY(!castedThis)) {
2361         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "enumAttr", " setter can only be used on instances of ", "TestObj"));
2362         return;
2363     }
2364     TestObj& impl = castedThis->impl();
2365     const String nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
2366     if (UNLIKELY(exec->hadException()))
2367         return;
2368     if (nativeValue != "" && nativeValue != "EnumValue1" && nativeValue != "EnumValue2" && nativeValue != "EnumValue3")
2369         return;
2370     impl.setEnumAttr(nativeValue);
2371 }
2372
2373
2374 void setJSTestObjByteAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2375 {
2376     JSValue value = JSValue::decode(encodedValue);
2377     UNUSED_PARAM(exec);
2378     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2379     if (UNLIKELY(!castedThis)) {
2380         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "byteAttr", " setter can only be used on instances of ", "TestObj"));
2381         return;
2382     }
2383     TestObj& impl = castedThis->impl();
2384     int8_t nativeValue(toInt8(exec, value, NormalConversion));
2385     if (UNLIKELY(exec->hadException()))
2386         return;
2387     impl.setByteAttr(nativeValue);
2388 }
2389
2390
2391 void setJSTestObjOctetAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2392 {
2393     JSValue value = JSValue::decode(encodedValue);
2394     UNUSED_PARAM(exec);
2395     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2396     if (UNLIKELY(!castedThis)) {
2397         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "octetAttr", " setter can only be used on instances of ", "TestObj"));
2398         return;
2399     }
2400     TestObj& impl = castedThis->impl();
2401     uint8_t nativeValue(toUInt8(exec, value, NormalConversion));
2402     if (UNLIKELY(exec->hadException()))
2403         return;
2404     impl.setOctetAttr(nativeValue);
2405 }
2406
2407
2408 void setJSTestObjShortAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2409 {
2410     JSValue value = JSValue::decode(encodedValue);
2411     UNUSED_PARAM(exec);
2412     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2413     if (UNLIKELY(!castedThis)) {
2414         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "shortAttr", " setter can only be used on instances of ", "TestObj"));
2415         return;
2416     }
2417     TestObj& impl = castedThis->impl();
2418     int16_t nativeValue(toInt16(exec, value, NormalConversion));
2419     if (UNLIKELY(exec->hadException()))
2420         return;
2421     impl.setShortAttr(nativeValue);
2422 }
2423
2424
2425 void setJSTestObjUnsignedShortAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2426 {
2427     JSValue value = JSValue::decode(encodedValue);
2428     UNUSED_PARAM(exec);
2429     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2430     if (UNLIKELY(!castedThis)) {
2431         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "unsignedShortAttr", " setter can only be used on instances of ", "TestObj"));
2432         return;
2433     }
2434     TestObj& impl = castedThis->impl();
2435     uint16_t nativeValue(toUInt16(exec, value, NormalConversion));
2436     if (UNLIKELY(exec->hadException()))
2437         return;
2438     impl.setUnsignedShortAttr(nativeValue);
2439 }
2440
2441
2442 void setJSTestObjLongAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2443 {
2444     JSValue value = JSValue::decode(encodedValue);
2445     UNUSED_PARAM(exec);
2446     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2447     if (UNLIKELY(!castedThis)) {
2448         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "longAttr", " setter can only be used on instances of ", "TestObj"));
2449         return;
2450     }
2451     TestObj& impl = castedThis->impl();
2452     int nativeValue(toInt32(exec, value, NormalConversion));
2453     if (UNLIKELY(exec->hadException()))
2454         return;
2455     impl.setLongAttr(nativeValue);
2456 }
2457
2458
2459 void setJSTestObjLongLongAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2460 {
2461     JSValue value = JSValue::decode(encodedValue);
2462     UNUSED_PARAM(exec);
2463     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2464     if (UNLIKELY(!castedThis)) {
2465         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "longLongAttr", " setter can only be used on instances of ", "TestObj"));
2466         return;
2467     }
2468     TestObj& impl = castedThis->impl();
2469     long long nativeValue(toInt64(exec, value, NormalConversion));
2470     if (UNLIKELY(exec->hadException()))
2471         return;
2472     impl.setLongLongAttr(nativeValue);
2473 }
2474
2475
2476 void setJSTestObjUnsignedLongLongAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2477 {
2478     JSValue value = JSValue::decode(encodedValue);
2479     UNUSED_PARAM(exec);
2480     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2481     if (UNLIKELY(!castedThis)) {
2482         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "unsignedLongLongAttr", " setter can only be used on instances of ", "TestObj"));
2483         return;
2484     }
2485     TestObj& impl = castedThis->impl();
2486     unsigned long long nativeValue(toUInt64(exec, value, NormalConversion));
2487     if (UNLIKELY(exec->hadException()))
2488         return;
2489     impl.setUnsignedLongLongAttr(nativeValue);
2490 }
2491
2492
2493 void setJSTestObjStringAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2494 {
2495     JSValue value = JSValue::decode(encodedValue);
2496     UNUSED_PARAM(exec);
2497     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2498     if (UNLIKELY(!castedThis)) {
2499         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "stringAttr", " setter can only be used on instances of ", "TestObj"));
2500         return;
2501     }
2502     TestObj& impl = castedThis->impl();
2503     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
2504     if (UNLIKELY(exec->hadException()))
2505         return;
2506     impl.setStringAttr(nativeValue);
2507 }
2508
2509
2510 void setJSTestObjTestObjAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2511 {
2512     JSValue value = JSValue::decode(encodedValue);
2513     UNUSED_PARAM(exec);
2514     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2515     if (UNLIKELY(!castedThis)) {
2516         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "testObjAttr", " setter can only be used on instances of ", "TestObj"));
2517         return;
2518     }
2519     TestObj& impl = castedThis->impl();
2520     TestObj* nativeValue(toTestObj(value));
2521     if (UNLIKELY(exec->hadException()))
2522         return;
2523     impl.setTestObjAttr(nativeValue);
2524 }
2525
2526
2527 void setJSTestObjXMLObjAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2528 {
2529     JSValue value = JSValue::decode(encodedValue);
2530     UNUSED_PARAM(exec);
2531     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2532     if (UNLIKELY(!castedThis)) {
2533         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "XMLObjAttr", " setter can only be used on instances of ", "TestObj"));
2534         return;
2535     }
2536     TestObj& impl = castedThis->impl();
2537     TestObj* nativeValue(toTestObj(value));
2538     if (UNLIKELY(exec->hadException()))
2539         return;
2540     impl.setXMLObjAttr(nativeValue);
2541 }
2542
2543
2544 void setJSTestObjCreate(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2545 {
2546     JSValue value = JSValue::decode(encodedValue);
2547     UNUSED_PARAM(exec);
2548     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2549     if (UNLIKELY(!castedThis)) {
2550         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "create", " setter can only be used on instances of ", "TestObj"));
2551         return;
2552     }
2553     TestObj& impl = castedThis->impl();
2554     bool nativeValue(value.toBoolean(exec));
2555     if (UNLIKELY(exec->hadException()))
2556         return;
2557     impl.setCreate(nativeValue);
2558 }
2559
2560
2561 void setJSTestObjReflectedStringAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2562 {
2563     JSValue value = JSValue::decode(encodedValue);
2564     UNUSED_PARAM(exec);
2565     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2566     if (UNLIKELY(!castedThis)) {
2567         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedStringAttr", " setter can only be used on instances of ", "TestObj"));
2568         return;
2569     }
2570     TestObj& impl = castedThis->impl();
2571     const String& nativeValue(valueToStringWithNullCheck(exec, value));
2572     if (UNLIKELY(exec->hadException()))
2573         return;
2574     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedstringattrAttr, nativeValue);
2575 }
2576
2577
2578 void setJSTestObjReflectedIntegralAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2579 {
2580     JSValue value = JSValue::decode(encodedValue);
2581     UNUSED_PARAM(exec);
2582     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2583     if (UNLIKELY(!castedThis)) {
2584         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedIntegralAttr", " setter can only be used on instances of ", "TestObj"));
2585         return;
2586     }
2587     TestObj& impl = castedThis->impl();
2588     int nativeValue(toInt32(exec, value, NormalConversion));
2589     if (UNLIKELY(exec->hadException()))
2590         return;
2591     impl.setIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr, nativeValue);
2592 }
2593
2594
2595 void setJSTestObjReflectedUnsignedIntegralAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2596 {
2597     JSValue value = JSValue::decode(encodedValue);
2598     UNUSED_PARAM(exec);
2599     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2600     if (UNLIKELY(!castedThis)) {
2601         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedUnsignedIntegralAttr", " setter can only be used on instances of ", "TestObj"));
2602         return;
2603     }
2604     TestObj& impl = castedThis->impl();
2605     unsigned nativeValue(toUInt32(exec, value, NormalConversion));
2606     if (UNLIKELY(exec->hadException()))
2607         return;
2608     impl.setUnsignedIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr, nativeValue);
2609 }
2610
2611
2612 void setJSTestObjReflectedBooleanAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2613 {
2614     JSValue value = JSValue::decode(encodedValue);
2615     UNUSED_PARAM(exec);
2616     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2617     if (UNLIKELY(!castedThis)) {
2618         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedBooleanAttr", " setter can only be used on instances of ", "TestObj"));
2619         return;
2620     }
2621     TestObj& impl = castedThis->impl();
2622     bool nativeValue(value.toBoolean(exec));
2623     if (UNLIKELY(exec->hadException()))
2624         return;
2625     impl.setBooleanAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr, nativeValue);
2626 }
2627
2628
2629 void setJSTestObjReflectedURLAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2630 {
2631     JSValue value = JSValue::decode(encodedValue);
2632     UNUSED_PARAM(exec);
2633     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2634     if (UNLIKELY(!castedThis)) {
2635         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedURLAttr", " setter can only be used on instances of ", "TestObj"));
2636         return;
2637     }
2638     TestObj& impl = castedThis->impl();
2639     const String& nativeValue(valueToStringWithNullCheck(exec, value));
2640     if (UNLIKELY(exec->hadException()))
2641         return;
2642     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedurlattrAttr, nativeValue);
2643 }
2644
2645
2646 void setJSTestObjReflectedStringAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2647 {
2648     JSValue value = JSValue::decode(encodedValue);
2649     UNUSED_PARAM(exec);
2650     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2651     if (UNLIKELY(!castedThis)) {
2652         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedStringAttr", " setter can only be used on instances of ", "TestObj"));
2653         return;
2654     }
2655     TestObj& impl = castedThis->impl();
2656     const String& nativeValue(valueToStringWithNullCheck(exec, value));
2657     if (UNLIKELY(exec->hadException()))
2658         return;
2659     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::customContentStringAttrAttr, nativeValue);
2660 }
2661
2662
2663 void setJSTestObjReflectedCustomIntegralAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2664 {
2665     JSValue value = JSValue::decode(encodedValue);
2666     UNUSED_PARAM(exec);
2667     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2668     if (UNLIKELY(!castedThis)) {
2669         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedCustomIntegralAttr", " setter can only be used on instances of ", "TestObj"));
2670         return;
2671     }
2672     TestObj& impl = castedThis->impl();
2673     int nativeValue(toInt32(exec, value, NormalConversion));
2674     if (UNLIKELY(exec->hadException()))
2675         return;
2676     impl.setIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr, nativeValue);
2677 }
2678
2679
2680 void setJSTestObjReflectedCustomBooleanAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2681 {
2682     JSValue value = JSValue::decode(encodedValue);
2683     UNUSED_PARAM(exec);
2684     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2685     if (UNLIKELY(!castedThis)) {
2686         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedCustomBooleanAttr", " setter can only be used on instances of ", "TestObj"));
2687         return;
2688     }
2689     TestObj& impl = castedThis->impl();
2690     bool nativeValue(value.toBoolean(exec));
2691     if (UNLIKELY(exec->hadException()))
2692         return;
2693     impl.setBooleanAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr, nativeValue);
2694 }
2695
2696
2697 void setJSTestObjReflectedCustomURLAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2698 {
2699     JSValue value = JSValue::decode(encodedValue);
2700     UNUSED_PARAM(exec);
2701     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2702     if (UNLIKELY(!castedThis)) {
2703         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "reflectedCustomURLAttr", " setter can only be used on instances of ", "TestObj"));
2704         return;
2705     }
2706     TestObj& impl = castedThis->impl();
2707     const String& nativeValue(valueToStringWithNullCheck(exec, value));
2708     if (UNLIKELY(exec->hadException()))
2709         return;
2710     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::customContentURLAttrAttr, nativeValue);
2711 }
2712
2713
2714 void setJSTestObjTypedArrayAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2715 {
2716     JSValue value = JSValue::decode(encodedValue);
2717     UNUSED_PARAM(exec);
2718     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2719     if (UNLIKELY(!castedThis)) {
2720         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "typedArrayAttr", " setter can only be used on instances of ", "TestObj"));
2721         return;
2722     }
2723     TestObj& impl = castedThis->impl();
2724     RefPtr<Float32Array> nativeValue(toFloat32Array(value));
2725     if (UNLIKELY(exec->hadException()))
2726         return;
2727     impl.setTypedArrayAttr(nativeValue.get());
2728 }
2729
2730
2731 void setJSTestObjAttrWithGetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2732 {
2733     JSValue value = JSValue::decode(encodedValue);
2734     UNUSED_PARAM(exec);
2735     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2736     if (UNLIKELY(!castedThis)) {
2737         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "attrWithGetterException", " setter can only be used on instances of ", "TestObj"));
2738         return;
2739     }
2740     TestObj& impl = castedThis->impl();
2741     int nativeValue(toInt32(exec, value, NormalConversion));
2742     if (UNLIKELY(exec->hadException()))
2743         return;
2744     impl.setAttrWithGetterException(nativeValue);
2745 }
2746
2747
2748 void setJSTestObjAttrWithSetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2749 {
2750     JSValue value = JSValue::decode(encodedValue);
2751     UNUSED_PARAM(exec);
2752     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2753     if (UNLIKELY(!castedThis)) {
2754         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "attrWithSetterException", " setter can only be used on instances of ", "TestObj"));
2755         return;
2756     }
2757     TestObj& impl = castedThis->impl();
2758     ExceptionCode ec = 0;
2759     int nativeValue(toInt32(exec, value, NormalConversion));
2760     if (UNLIKELY(exec->hadException()))
2761         return;
2762     impl.setAttrWithSetterException(nativeValue, ec);
2763     setDOMException(exec, ec);
2764 }
2765
2766
2767 void setJSTestObjStringAttrWithGetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2768 {
2769     JSValue value = JSValue::decode(encodedValue);
2770     UNUSED_PARAM(exec);
2771     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2772     if (UNLIKELY(!castedThis)) {
2773         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "stringAttrWithGetterException", " setter can only be used on instances of ", "TestObj"));
2774         return;
2775     }
2776     TestObj& impl = castedThis->impl();
2777     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
2778     if (UNLIKELY(exec->hadException()))
2779         return;
2780     impl.setStringAttrWithGetterException(nativeValue);
2781 }
2782
2783
2784 void setJSTestObjStringAttrWithSetterException(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2785 {
2786     JSValue value = JSValue::decode(encodedValue);
2787     UNUSED_PARAM(exec);
2788     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2789     if (UNLIKELY(!castedThis)) {
2790         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "stringAttrWithSetterException", " setter can only be used on instances of ", "TestObj"));
2791         return;
2792     }
2793     TestObj& impl = castedThis->impl();
2794     ExceptionCode ec = 0;
2795     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
2796     if (UNLIKELY(exec->hadException()))
2797         return;
2798     impl.setStringAttrWithSetterException(nativeValue, ec);
2799     setDOMException(exec, ec);
2800 }
2801
2802
2803 void setJSTestObjCustomAttr(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2804 {
2805     JSValue value = JSValue::decode(encodedValue);
2806     UNUSED_PARAM(exec);
2807     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2808     if (UNLIKELY(!castedThis)) {
2809         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "customAttr", " setter can only be used on instances of ", "TestObj"));
2810         return;
2811     }
2812     castedThis->setCustomAttr(exec, value);
2813 }
2814
2815
2816 void setJSTestObjWithScriptStateAttribute(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2817 {
2818     JSValue value = JSValue::decode(encodedValue);
2819     UNUSED_PARAM(exec);
2820     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2821     if (UNLIKELY(!castedThis)) {
2822         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptStateAttribute", " setter can only be used on instances of ", "TestObj"));
2823         return;
2824     }
2825     TestObj& impl = castedThis->impl();
2826     int nativeValue(toInt32(exec, value, NormalConversion));
2827     if (UNLIKELY(exec->hadException()))
2828         return;
2829     impl.setWithScriptStateAttribute(exec, nativeValue);
2830 }
2831
2832
2833 void setJSTestObjWithScriptExecutionContextAttribute(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2834 {
2835     JSValue value = JSValue::decode(encodedValue);
2836     UNUSED_PARAM(exec);
2837     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2838     if (UNLIKELY(!castedThis)) {
2839         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptExecutionContextAttribute", " setter can only be used on instances of ", "TestObj"));
2840         return;
2841     }
2842     TestObj& impl = castedThis->impl();
2843     TestObj* nativeValue(toTestObj(value));
2844     if (UNLIKELY(exec->hadException()))
2845         return;
2846     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2847     if (!scriptContext)
2848         return;
2849     impl.setWithScriptExecutionContextAttribute(scriptContext, nativeValue);
2850 }
2851
2852
2853 void setJSTestObjWithScriptStateAttributeRaises(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2854 {
2855     JSValue value = JSValue::decode(encodedValue);
2856     UNUSED_PARAM(exec);
2857     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2858     if (UNLIKELY(!castedThis)) {
2859         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptStateAttributeRaises", " setter can only be used on instances of ", "TestObj"));
2860         return;
2861     }
2862     TestObj& impl = castedThis->impl();
2863     TestObj* nativeValue(toTestObj(value));
2864     if (UNLIKELY(exec->hadException()))
2865         return;
2866     impl.setWithScriptStateAttributeRaises(exec, nativeValue);
2867 }
2868
2869
2870 void setJSTestObjWithScriptExecutionContextAttributeRaises(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2871 {
2872     JSValue value = JSValue::decode(encodedValue);
2873     UNUSED_PARAM(exec);
2874     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2875     if (UNLIKELY(!castedThis)) {
2876         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptExecutionContextAttributeRaises", " setter can only be used on instances of ", "TestObj"));
2877         return;
2878     }
2879     TestObj& impl = castedThis->impl();
2880     TestObj* nativeValue(toTestObj(value));
2881     if (UNLIKELY(exec->hadException()))
2882         return;
2883     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2884     if (!scriptContext)
2885         return;
2886     impl.setWithScriptExecutionContextAttributeRaises(scriptContext, nativeValue);
2887 }
2888
2889
2890 void setJSTestObjWithScriptExecutionContextAndScriptStateAttribute(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2891 {
2892     JSValue value = JSValue::decode(encodedValue);
2893     UNUSED_PARAM(exec);
2894     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2895     if (UNLIKELY(!castedThis)) {
2896         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptExecutionContextAndScriptStateAttribute", " setter can only be used on instances of ", "TestObj"));
2897         return;
2898     }
2899     TestObj& impl = castedThis->impl();
2900     TestObj* nativeValue(toTestObj(value));
2901     if (UNLIKELY(exec->hadException()))
2902         return;
2903     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2904     if (!scriptContext)
2905         return;
2906     impl.setWithScriptExecutionContextAndScriptStateAttribute(exec, scriptContext, nativeValue);
2907 }
2908
2909
2910 void setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2911 {
2912     JSValue value = JSValue::decode(encodedValue);
2913     UNUSED_PARAM(exec);
2914     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2915     if (UNLIKELY(!castedThis)) {
2916         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptExecutionContextAndScriptStateAttributeRaises", " setter can only be used on instances of ", "TestObj"));
2917         return;
2918     }
2919     TestObj& impl = castedThis->impl();
2920     TestObj* nativeValue(toTestObj(value));
2921     if (UNLIKELY(exec->hadException()))
2922         return;
2923     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2924     if (!scriptContext)
2925         return;
2926     impl.setWithScriptExecutionContextAndScriptStateAttributeRaises(exec, scriptContext, nativeValue);
2927 }
2928
2929
2930 void setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2931 {
2932     JSValue value = JSValue::decode(encodedValue);
2933     UNUSED_PARAM(exec);
2934     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2935     if (UNLIKELY(!castedThis)) {
2936         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptExecutionContextAndScriptStateWithSpacesAttribute", " setter can only be used on instances of ", "TestObj"));
2937         return;
2938     }
2939     TestObj& impl = castedThis->impl();
2940     TestObj* nativeValue(toTestObj(value));
2941     if (UNLIKELY(exec->hadException()))
2942         return;
2943     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
2944     if (!scriptContext)
2945         return;
2946     impl.setWithScriptExecutionContextAndScriptStateWithSpacesAttribute(exec, scriptContext, nativeValue);
2947 }
2948
2949
2950 void setJSTestObjWithScriptArgumentsAndCallStackAttribute(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2951 {
2952     JSValue value = JSValue::decode(encodedValue);
2953     UNUSED_PARAM(exec);
2954     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2955     if (UNLIKELY(!castedThis)) {
2956         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "withScriptArgumentsAndCallStackAttribute", " setter can only be used on instances of ", "TestObj"));
2957         return;
2958     }
2959     TestObj& impl = castedThis->impl();
2960     TestObj* nativeValue(toTestObj(value));
2961     if (UNLIKELY(exec->hadException()))
2962         return;
2963     impl.setWithScriptArgumentsAndCallStackAttribute(nativeValue);
2964 }
2965
2966
2967 #if ENABLE(Condition1)
2968 void setJSTestObjConditionalAttr1(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2969 {
2970     JSValue value = JSValue::decode(encodedValue);
2971     UNUSED_PARAM(exec);
2972     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2973     if (UNLIKELY(!castedThis)) {
2974         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr1", " setter can only be used on instances of ", "TestObj"));
2975         return;
2976     }
2977     TestObj& impl = castedThis->impl();
2978     int nativeValue(toInt32(exec, value, NormalConversion));
2979     if (UNLIKELY(exec->hadException()))
2980         return;
2981     impl.setConditionalAttr1(nativeValue);
2982 }
2983
2984 #endif
2985
2986 #if ENABLE(Condition1) && ENABLE(Condition2)
2987 void setJSTestObjConditionalAttr2(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2988 {
2989     JSValue value = JSValue::decode(encodedValue);
2990     UNUSED_PARAM(exec);
2991     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2992     if (UNLIKELY(!castedThis)) {
2993         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr2", " setter can only be used on instances of ", "TestObj"));
2994         return;
2995     }
2996     TestObj& impl = castedThis->impl();
2997     int nativeValue(toInt32(exec, value, NormalConversion));
2998     if (UNLIKELY(exec->hadException()))
2999         return;
3000     impl.setConditionalAttr2(nativeValue);
3001 }
3002
3003 #endif
3004
3005 #if ENABLE(Condition1) || ENABLE(Condition2)
3006 void setJSTestObjConditionalAttr3(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3007 {
3008     JSValue value = JSValue::decode(encodedValue);
3009     UNUSED_PARAM(exec);
3010     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3011     if (UNLIKELY(!castedThis)) {
3012         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr3", " setter can only be used on instances of ", "TestObj"));
3013         return;
3014     }
3015     TestObj& impl = castedThis->impl();
3016     int nativeValue(toInt32(exec, value, NormalConversion));
3017     if (UNLIKELY(exec->hadException()))
3018         return;
3019     impl.setConditionalAttr3(nativeValue);
3020 }
3021
3022 #endif
3023
3024 #if ENABLE(Condition1)
3025 void setJSTestObjConditionalAttr4Constructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3026 {
3027     JSValue value = JSValue::decode(encodedValue);
3028     UNUSED_PARAM(exec);
3029     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3030     if (UNLIKELY(!castedThis)) {
3031         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr4", " setter can only be used on instances of ", "TestObj"));
3032         return;
3033     }
3034     // Shadowing a built-in constructor
3035     castedThis->putDirect(exec->vm(), Identifier(exec, "conditionalAttr4"), value);
3036 }
3037
3038 #endif
3039
3040 #if ENABLE(Condition1) && ENABLE(Condition2)
3041 void setJSTestObjConditionalAttr5Constructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3042 {
3043     JSValue value = JSValue::decode(encodedValue);
3044     UNUSED_PARAM(exec);
3045     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3046     if (UNLIKELY(!castedThis)) {
3047         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr5", " setter can only be used on instances of ", "TestObj"));
3048         return;
3049     }
3050     // Shadowing a built-in constructor
3051     castedThis->putDirect(exec->vm(), Identifier(exec, "conditionalAttr5"), value);
3052 }
3053
3054 #endif
3055
3056 #if ENABLE(Condition1) || ENABLE(Condition2)
3057 void setJSTestObjConditionalAttr6Constructor(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3058 {
3059     JSValue value = JSValue::decode(encodedValue);
3060     UNUSED_PARAM(exec);
3061     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3062     if (UNLIKELY(!castedThis)) {
3063         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "conditionalAttr6", " setter can only be used on instances of ", "TestObj"));
3064         return;
3065     }
3066     // Shadowing a built-in constructor
3067     castedThis->putDirect(exec->vm(), Identifier(exec, "conditionalAttr6"), value);
3068 }
3069
3070 #endif
3071
3072 void setJSTestObjAnyAttribute(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3073 {
3074     JSValue value = JSValue::decode(encodedValue);
3075     UNUSED_PARAM(exec);
3076     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3077     if (UNLIKELY(!castedThis)) {
3078         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "anyAttribute", " setter can only be used on instances of ", "TestObj"));
3079         return;
3080     }
3081     TestObj& impl = castedThis->impl();
3082     Deprecated::ScriptValue nativeValue(exec->vm(), value);
3083     if (UNLIKELY(exec->hadException()))
3084         return;
3085     impl.setAnyAttribute(nativeValue);
3086 }
3087
3088
3089 void setJSTestObjMutablePoint(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3090 {
3091     JSValue value = JSValue::decode(encodedValue);
3092     UNUSED_PARAM(exec);
3093     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3094     if (UNLIKELY(!castedThis)) {
3095         throwVMTypeError(exec, makeDOMBindingsTypeErrorString("The ", "TestObj", ".", "mutablePoint", " setter can only be used on instances of ", "TestObj"));
3096         return;
3097     }
3098     TestObj& impl = castedThis->impl();
3099     SVGPropertyTearOff<SVGPoint>* nativeValue(toSVGPoint(value));
3100     if (UNLIKELY(exec->hadException()))
3101         return;
3102     impl.setMutablePoint(nativeValue);
3103 }
3104
3105
3106 void setJSTestObjImmutablePoint(ExecState* exec, JSObject* /* baseObject */, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3107 {
3108     JSValue value = JSValue::decode(encodedValue);
3109     UNUSED_PARAM(exec);