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