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 "JSHTMLTableCellElement.h"
23
24#include "CustomElementReactionQueue.h"
25#include "HTMLNames.h"
26#include "JSDOMAttribute.h"
27#include "JSDOMBinding.h"
28#include "JSDOMConstructorNotConstructable.h"
29#include "JSDOMConvertBoolean.h"
30#include "JSDOMConvertNumbers.h"
31#include "JSDOMConvertStrings.h"
32#include "JSDOMExceptionHandling.h"
33#include "JSDOMWrapperCache.h"
34#include "ScriptExecutionContext.h"
35#include <JavaScriptCore/HeapSnapshotBuilder.h>
36#include <JavaScriptCore/JSCInlines.h>
37#include <wtf/GetPtr.h>
38#include <wtf/PointerPreparations.h>
39#include <wtf/URL.h>
40
41
42namespace WebCore {
43using namespace JSC;
44
45// Attributes
46
47JSC::EncodedJSValue jsHTMLTableCellElementConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
48bool setJSHTMLTableCellElementConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
49JSC::EncodedJSValue jsHTMLTableCellElementCellIndex(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
50JSC::EncodedJSValue jsHTMLTableCellElementAlign(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
51bool setJSHTMLTableCellElementAlign(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
52JSC::EncodedJSValue jsHTMLTableCellElementAxis(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
53bool setJSHTMLTableCellElementAxis(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
54JSC::EncodedJSValue jsHTMLTableCellElementBgColor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
55bool setJSHTMLTableCellElementBgColor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
56JSC::EncodedJSValue jsHTMLTableCellElementCh(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
57bool setJSHTMLTableCellElementCh(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
58JSC::EncodedJSValue jsHTMLTableCellElementChOff(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
59bool setJSHTMLTableCellElementChOff(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
60JSC::EncodedJSValue jsHTMLTableCellElementColSpan(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
61bool setJSHTMLTableCellElementColSpan(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
62JSC::EncodedJSValue jsHTMLTableCellElementRowSpan(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
63bool setJSHTMLTableCellElementRowSpan(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
64JSC::EncodedJSValue jsHTMLTableCellElementHeaders(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
65bool setJSHTMLTableCellElementHeaders(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
66JSC::EncodedJSValue jsHTMLTableCellElementHeight(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
67bool setJSHTMLTableCellElementHeight(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
68JSC::EncodedJSValue jsHTMLTableCellElementNoWrap(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
69bool setJSHTMLTableCellElementNoWrap(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
70JSC::EncodedJSValue jsHTMLTableCellElementVAlign(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
71bool setJSHTMLTableCellElementVAlign(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
72JSC::EncodedJSValue jsHTMLTableCellElementWidth(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
73bool setJSHTMLTableCellElementWidth(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
74JSC::EncodedJSValue jsHTMLTableCellElementAbbr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
75bool setJSHTMLTableCellElementAbbr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
76JSC::EncodedJSValue jsHTMLTableCellElementScope(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
77bool setJSHTMLTableCellElementScope(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
78
79class JSHTMLTableCellElementPrototype : public JSC::JSNonFinalObject {
80public:
81 using Base = JSC::JSNonFinalObject;
82 static JSHTMLTableCellElementPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
83 {
84 JSHTMLTableCellElementPrototype* ptr = new (NotNull, JSC::allocateCell<JSHTMLTableCellElementPrototype>(vm.heap)) JSHTMLTableCellElementPrototype(vm, globalObject, structure);
85 ptr->finishCreation(vm);
86 return ptr;
87 }
88
89 DECLARE_INFO;
90 static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
91 {
92 return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
93 }
94
95private:
96 JSHTMLTableCellElementPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
97 : JSC::JSNonFinalObject(vm, structure)
98 {
99 }
100
101 void finishCreation(JSC::VM&);
102};
103
104using JSHTMLTableCellElementConstructor = JSDOMConstructorNotConstructable<JSHTMLTableCellElement>;
105
106template<> JSValue JSHTMLTableCellElementConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
107{
108 return JSHTMLElement::getConstructor(vm, &globalObject);
109}
110
111template<> void JSHTMLTableCellElementConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
112{
113 putDirect(vm, vm.propertyNames->prototype, JSHTMLTableCellElement::prototype(vm, globalObject), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
114 putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String("HTMLTableCellElement"_s)), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
115 putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
116}
117
118template<> const ClassInfo JSHTMLTableCellElementConstructor::s_info = { "HTMLTableCellElement", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTMLTableCellElementConstructor) };
119
120/* Hash table for prototype */
121
122static const HashTableValue JSHTMLTableCellElementPrototypeTableValues[] =
123{
124 { "constructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementConstructor) } },
125 { "cellIndex", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementCellIndex), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
126 { "align", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementAlign), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementAlign) } },
127 { "axis", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementAxis), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementAxis) } },
128 { "bgColor", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementBgColor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementBgColor) } },
129 { "ch", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementCh), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementCh) } },
130 { "chOff", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementChOff), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementChOff) } },
131 { "colSpan", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementColSpan), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementColSpan) } },
132 { "rowSpan", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementRowSpan), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementRowSpan) } },
133 { "headers", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementHeaders), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementHeaders) } },
134 { "height", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementHeight), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementHeight) } },
135 { "noWrap", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementNoWrap), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementNoWrap) } },
136 { "vAlign", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementVAlign), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementVAlign) } },
137 { "width", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementWidth), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementWidth) } },
138 { "abbr", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementAbbr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementAbbr) } },
139 { "scope", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsHTMLTableCellElementScope), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSHTMLTableCellElementScope) } },
140};
141
142const ClassInfo JSHTMLTableCellElementPrototype::s_info = { "HTMLTableCellElementPrototype", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTMLTableCellElementPrototype) };
143
144void JSHTMLTableCellElementPrototype::finishCreation(VM& vm)
145{
146 Base::finishCreation(vm);
147 reifyStaticProperties(vm, JSHTMLTableCellElement::info(), JSHTMLTableCellElementPrototypeTableValues, *this);
148}
149
150const ClassInfo JSHTMLTableCellElement::s_info = { "HTMLTableCellElement", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTMLTableCellElement) };
151
152JSHTMLTableCellElement::JSHTMLTableCellElement(Structure* structure, JSDOMGlobalObject& globalObject, Ref<HTMLTableCellElement>&& impl)
153 : JSHTMLElement(structure, globalObject, WTFMove(impl))
154{
155}
156
157void JSHTMLTableCellElement::finishCreation(VM& vm)
158{
159 Base::finishCreation(vm);
160 ASSERT(inherits(vm, info()));
161
162}
163
164JSObject* JSHTMLTableCellElement::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
165{
166 return JSHTMLTableCellElementPrototype::create(vm, &globalObject, JSHTMLTableCellElementPrototype::createStructure(vm, &globalObject, JSHTMLElement::prototype(vm, globalObject)));
167}
168
169JSObject* JSHTMLTableCellElement::prototype(VM& vm, JSDOMGlobalObject& globalObject)
170{
171 return getDOMPrototype<JSHTMLTableCellElement>(vm, globalObject);
172}
173
174JSValue JSHTMLTableCellElement::getConstructor(VM& vm, const JSGlobalObject* globalObject)
175{
176 return getDOMConstructor<JSHTMLTableCellElementConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
177}
178
179template<> inline JSHTMLTableCellElement* IDLAttribute<JSHTMLTableCellElement>::cast(ExecState& state, EncodedJSValue thisValue)
180{
181 return jsDynamicCast<JSHTMLTableCellElement*>(state.vm(), JSValue::decode(thisValue));
182}
183
184EncodedJSValue jsHTMLTableCellElementConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
185{
186 VM& vm = state->vm();
187 auto throwScope = DECLARE_THROW_SCOPE(vm);
188 auto* prototype = jsDynamicCast<JSHTMLTableCellElementPrototype*>(vm, JSValue::decode(thisValue));
189 if (UNLIKELY(!prototype))
190 return throwVMTypeError(state, throwScope);
191 return JSValue::encode(JSHTMLTableCellElement::getConstructor(state->vm(), prototype->globalObject()));
192}
193
194bool setJSHTMLTableCellElementConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
195{
196 VM& vm = state->vm();
197 auto throwScope = DECLARE_THROW_SCOPE(vm);
198 auto* prototype = jsDynamicCast<JSHTMLTableCellElementPrototype*>(vm, JSValue::decode(thisValue));
199 if (UNLIKELY(!prototype)) {
200 throwVMTypeError(state, throwScope);
201 return false;
202 }
203 // Shadowing a built-in constructor
204 return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));
205}
206
207static inline JSValue jsHTMLTableCellElementCellIndexGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
208{
209 UNUSED_PARAM(throwScope);
210 UNUSED_PARAM(state);
211 auto& impl = thisObject.wrapped();
212 JSValue result = toJS<IDLLong>(state, throwScope, impl.cellIndex());
213 return result;
214}
215
216EncodedJSValue jsHTMLTableCellElementCellIndex(ExecState* state, EncodedJSValue thisValue, PropertyName)
217{
218 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementCellIndexGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "cellIndex");
219}
220
221static inline JSValue jsHTMLTableCellElementAlignGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
222{
223 UNUSED_PARAM(throwScope);
224 UNUSED_PARAM(state);
225 auto& impl = thisObject.wrapped();
226 JSValue result = toJS<IDLDOMString>(state, throwScope, impl.attributeWithoutSynchronization(WebCore::HTMLNames::alignAttr));
227 return result;
228}
229
230EncodedJSValue jsHTMLTableCellElementAlign(ExecState* state, EncodedJSValue thisValue, PropertyName)
231{
232 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementAlignGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "align");
233}
234
235static inline bool setJSHTMLTableCellElementAlignSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
236{
237 UNUSED_PARAM(throwScope);
238 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
239 auto& impl = thisObject.wrapped();
240 auto nativeValue = convert<IDLDOMString>(state, value);
241 RETURN_IF_EXCEPTION(throwScope, false);
242 AttributeSetter::call(state, throwScope, [&] {
243 return impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::alignAttr, WTFMove(nativeValue));
244 });
245 return true;
246}
247
248bool setJSHTMLTableCellElementAlign(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
249{
250 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementAlignSetter>(*state, thisValue, encodedValue, "align");
251}
252
253static inline JSValue jsHTMLTableCellElementAxisGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
254{
255 UNUSED_PARAM(throwScope);
256 UNUSED_PARAM(state);
257 auto& impl = thisObject.wrapped();
258 JSValue result = toJS<IDLDOMString>(state, throwScope, impl.attributeWithoutSynchronization(WebCore::HTMLNames::axisAttr));
259 return result;
260}
261
262EncodedJSValue jsHTMLTableCellElementAxis(ExecState* state, EncodedJSValue thisValue, PropertyName)
263{
264 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementAxisGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "axis");
265}
266
267static inline bool setJSHTMLTableCellElementAxisSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
268{
269 UNUSED_PARAM(throwScope);
270 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
271 auto& impl = thisObject.wrapped();
272 auto nativeValue = convert<IDLDOMString>(state, value);
273 RETURN_IF_EXCEPTION(throwScope, false);
274 AttributeSetter::call(state, throwScope, [&] {
275 return impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::axisAttr, WTFMove(nativeValue));
276 });
277 return true;
278}
279
280bool setJSHTMLTableCellElementAxis(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
281{
282 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementAxisSetter>(*state, thisValue, encodedValue, "axis");
283}
284
285static inline JSValue jsHTMLTableCellElementBgColorGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
286{
287 UNUSED_PARAM(throwScope);
288 UNUSED_PARAM(state);
289 auto& impl = thisObject.wrapped();
290 JSValue result = toJS<IDLTreatNullAsEmptyAdaptor<IDLDOMString>>(state, throwScope, impl.attributeWithoutSynchronization(WebCore::HTMLNames::bgcolorAttr));
291 return result;
292}
293
294EncodedJSValue jsHTMLTableCellElementBgColor(ExecState* state, EncodedJSValue thisValue, PropertyName)
295{
296 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementBgColorGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "bgColor");
297}
298
299static inline bool setJSHTMLTableCellElementBgColorSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
300{
301 UNUSED_PARAM(throwScope);
302 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
303 auto& impl = thisObject.wrapped();
304 auto nativeValue = convert<IDLTreatNullAsEmptyAdaptor<IDLDOMString>>(state, value);
305 RETURN_IF_EXCEPTION(throwScope, false);
306 AttributeSetter::call(state, throwScope, [&] {
307 return impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::bgcolorAttr, WTFMove(nativeValue));
308 });
309 return true;
310}
311
312bool setJSHTMLTableCellElementBgColor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
313{
314 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementBgColorSetter>(*state, thisValue, encodedValue, "bgColor");
315}
316
317static inline JSValue jsHTMLTableCellElementChGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
318{
319 UNUSED_PARAM(throwScope);
320 UNUSED_PARAM(state);
321 auto& impl = thisObject.wrapped();
322 JSValue result = toJS<IDLDOMString>(state, throwScope, impl.attributeWithoutSynchronization(WebCore::HTMLNames::charAttr));
323 return result;
324}
325
326EncodedJSValue jsHTMLTableCellElementCh(ExecState* state, EncodedJSValue thisValue, PropertyName)
327{
328 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementChGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "ch");
329}
330
331static inline bool setJSHTMLTableCellElementChSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
332{
333 UNUSED_PARAM(throwScope);
334 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
335 auto& impl = thisObject.wrapped();
336 auto nativeValue = convert<IDLDOMString>(state, value);
337 RETURN_IF_EXCEPTION(throwScope, false);
338 AttributeSetter::call(state, throwScope, [&] {
339 return impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::charAttr, WTFMove(nativeValue));
340 });
341 return true;
342}
343
344bool setJSHTMLTableCellElementCh(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
345{
346 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementChSetter>(*state, thisValue, encodedValue, "ch");
347}
348
349static inline JSValue jsHTMLTableCellElementChOffGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
350{
351 UNUSED_PARAM(throwScope);
352 UNUSED_PARAM(state);
353 auto& impl = thisObject.wrapped();
354 JSValue result = toJS<IDLDOMString>(state, throwScope, impl.attributeWithoutSynchronization(WebCore::HTMLNames::charoffAttr));
355 return result;
356}
357
358EncodedJSValue jsHTMLTableCellElementChOff(ExecState* state, EncodedJSValue thisValue, PropertyName)
359{
360 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementChOffGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "chOff");
361}
362
363static inline bool setJSHTMLTableCellElementChOffSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
364{
365 UNUSED_PARAM(throwScope);
366 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
367 auto& impl = thisObject.wrapped();
368 auto nativeValue = convert<IDLDOMString>(state, value);
369 RETURN_IF_EXCEPTION(throwScope, false);
370 AttributeSetter::call(state, throwScope, [&] {
371 return impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::charoffAttr, WTFMove(nativeValue));
372 });
373 return true;
374}
375
376bool setJSHTMLTableCellElementChOff(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
377{
378 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementChOffSetter>(*state, thisValue, encodedValue, "chOff");
379}
380
381static inline JSValue jsHTMLTableCellElementColSpanGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
382{
383 UNUSED_PARAM(throwScope);
384 UNUSED_PARAM(state);
385 auto& impl = thisObject.wrapped();
386 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.colSpan());
387 return result;
388}
389
390EncodedJSValue jsHTMLTableCellElementColSpan(ExecState* state, EncodedJSValue thisValue, PropertyName)
391{
392 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementColSpanGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "colSpan");
393}
394
395static inline bool setJSHTMLTableCellElementColSpanSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
396{
397 UNUSED_PARAM(throwScope);
398 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
399 auto& impl = thisObject.wrapped();
400 auto nativeValue = convert<IDLUnsignedLong>(state, value);
401 RETURN_IF_EXCEPTION(throwScope, false);
402 AttributeSetter::call(state, throwScope, [&] {
403 return impl.setColSpan(WTFMove(nativeValue));
404 });
405 return true;
406}
407
408bool setJSHTMLTableCellElementColSpan(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
409{
410 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementColSpanSetter>(*state, thisValue, encodedValue, "colSpan");
411}
412
413static inline JSValue jsHTMLTableCellElementRowSpanGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
414{
415 UNUSED_PARAM(throwScope);
416 UNUSED_PARAM(state);
417 auto& impl = thisObject.wrapped();
418 JSValue result = toJS<IDLUnsignedLong>(state, throwScope, impl.rowSpanForBindings());
419 return result;
420}
421
422EncodedJSValue jsHTMLTableCellElementRowSpan(ExecState* state, EncodedJSValue thisValue, PropertyName)
423{
424 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementRowSpanGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "rowSpan");
425}
426
427static inline bool setJSHTMLTableCellElementRowSpanSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
428{
429 UNUSED_PARAM(throwScope);
430 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
431 auto& impl = thisObject.wrapped();
432 auto nativeValue = convert<IDLUnsignedLong>(state, value);
433 RETURN_IF_EXCEPTION(throwScope, false);
434 AttributeSetter::call(state, throwScope, [&] {
435 return impl.setRowSpanForBindings(WTFMove(nativeValue));
436 });
437 return true;
438}
439
440bool setJSHTMLTableCellElementRowSpan(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
441{
442 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementRowSpanSetter>(*state, thisValue, encodedValue, "rowSpan");
443}
444
445static inline JSValue jsHTMLTableCellElementHeadersGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
446{
447 UNUSED_PARAM(throwScope);
448 UNUSED_PARAM(state);
449 auto& impl = thisObject.wrapped();
450 JSValue result = toJS<IDLDOMString>(state, throwScope, impl.attributeWithoutSynchronization(WebCore::HTMLNames::headersAttr));
451 return result;
452}
453
454EncodedJSValue jsHTMLTableCellElementHeaders(ExecState* state, EncodedJSValue thisValue, PropertyName)
455{
456 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementHeadersGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "headers");
457}
458
459static inline bool setJSHTMLTableCellElementHeadersSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
460{
461 UNUSED_PARAM(throwScope);
462 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
463 auto& impl = thisObject.wrapped();
464 auto nativeValue = convert<IDLDOMString>(state, value);
465 RETURN_IF_EXCEPTION(throwScope, false);
466 AttributeSetter::call(state, throwScope, [&] {
467 return impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::headersAttr, WTFMove(nativeValue));
468 });
469 return true;
470}
471
472bool setJSHTMLTableCellElementHeaders(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
473{
474 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementHeadersSetter>(*state, thisValue, encodedValue, "headers");
475}
476
477static inline JSValue jsHTMLTableCellElementHeightGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
478{
479 UNUSED_PARAM(throwScope);
480 UNUSED_PARAM(state);
481 auto& impl = thisObject.wrapped();
482 JSValue result = toJS<IDLDOMString>(state, throwScope, impl.attributeWithoutSynchronization(WebCore::HTMLNames::heightAttr));
483 return result;
484}
485
486EncodedJSValue jsHTMLTableCellElementHeight(ExecState* state, EncodedJSValue thisValue, PropertyName)
487{
488 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementHeightGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "height");
489}
490
491static inline bool setJSHTMLTableCellElementHeightSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
492{
493 UNUSED_PARAM(throwScope);
494 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
495 auto& impl = thisObject.wrapped();
496 auto nativeValue = convert<IDLDOMString>(state, value);
497 RETURN_IF_EXCEPTION(throwScope, false);
498 AttributeSetter::call(state, throwScope, [&] {
499 return impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::heightAttr, WTFMove(nativeValue));
500 });
501 return true;
502}
503
504bool setJSHTMLTableCellElementHeight(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
505{
506 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementHeightSetter>(*state, thisValue, encodedValue, "height");
507}
508
509static inline JSValue jsHTMLTableCellElementNoWrapGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
510{
511 UNUSED_PARAM(throwScope);
512 UNUSED_PARAM(state);
513 auto& impl = thisObject.wrapped();
514 JSValue result = toJS<IDLBoolean>(state, throwScope, impl.hasAttributeWithoutSynchronization(WebCore::HTMLNames::nowrapAttr));
515 return result;
516}
517
518EncodedJSValue jsHTMLTableCellElementNoWrap(ExecState* state, EncodedJSValue thisValue, PropertyName)
519{
520 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementNoWrapGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "noWrap");
521}
522
523static inline bool setJSHTMLTableCellElementNoWrapSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
524{
525 UNUSED_PARAM(throwScope);
526 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
527 auto& impl = thisObject.wrapped();
528 auto nativeValue = convert<IDLBoolean>(state, value);
529 RETURN_IF_EXCEPTION(throwScope, false);
530 AttributeSetter::call(state, throwScope, [&] {
531 return impl.setBooleanAttribute(WebCore::HTMLNames::nowrapAttr, WTFMove(nativeValue));
532 });
533 return true;
534}
535
536bool setJSHTMLTableCellElementNoWrap(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
537{
538 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementNoWrapSetter>(*state, thisValue, encodedValue, "noWrap");
539}
540
541static inline JSValue jsHTMLTableCellElementVAlignGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
542{
543 UNUSED_PARAM(throwScope);
544 UNUSED_PARAM(state);
545 auto& impl = thisObject.wrapped();
546 JSValue result = toJS<IDLDOMString>(state, throwScope, impl.attributeWithoutSynchronization(WebCore::HTMLNames::valignAttr));
547 return result;
548}
549
550EncodedJSValue jsHTMLTableCellElementVAlign(ExecState* state, EncodedJSValue thisValue, PropertyName)
551{
552 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementVAlignGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "vAlign");
553}
554
555static inline bool setJSHTMLTableCellElementVAlignSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
556{
557 UNUSED_PARAM(throwScope);
558 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
559 auto& impl = thisObject.wrapped();
560 auto nativeValue = convert<IDLDOMString>(state, value);
561 RETURN_IF_EXCEPTION(throwScope, false);
562 AttributeSetter::call(state, throwScope, [&] {
563 return impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::valignAttr, WTFMove(nativeValue));
564 });
565 return true;
566}
567
568bool setJSHTMLTableCellElementVAlign(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
569{
570 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementVAlignSetter>(*state, thisValue, encodedValue, "vAlign");
571}
572
573static inline JSValue jsHTMLTableCellElementWidthGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
574{
575 UNUSED_PARAM(throwScope);
576 UNUSED_PARAM(state);
577 auto& impl = thisObject.wrapped();
578 JSValue result = toJS<IDLDOMString>(state, throwScope, impl.attributeWithoutSynchronization(WebCore::HTMLNames::widthAttr));
579 return result;
580}
581
582EncodedJSValue jsHTMLTableCellElementWidth(ExecState* state, EncodedJSValue thisValue, PropertyName)
583{
584 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementWidthGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "width");
585}
586
587static inline bool setJSHTMLTableCellElementWidthSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
588{
589 UNUSED_PARAM(throwScope);
590 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
591 auto& impl = thisObject.wrapped();
592 auto nativeValue = convert<IDLDOMString>(state, value);
593 RETURN_IF_EXCEPTION(throwScope, false);
594 AttributeSetter::call(state, throwScope, [&] {
595 return impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::widthAttr, WTFMove(nativeValue));
596 });
597 return true;
598}
599
600bool setJSHTMLTableCellElementWidth(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
601{
602 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementWidthSetter>(*state, thisValue, encodedValue, "width");
603}
604
605static inline JSValue jsHTMLTableCellElementAbbrGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
606{
607 UNUSED_PARAM(throwScope);
608 UNUSED_PARAM(state);
609 auto& impl = thisObject.wrapped();
610 JSValue result = toJS<IDLDOMString>(state, throwScope, impl.attributeWithoutSynchronization(WebCore::HTMLNames::abbrAttr));
611 return result;
612}
613
614EncodedJSValue jsHTMLTableCellElementAbbr(ExecState* state, EncodedJSValue thisValue, PropertyName)
615{
616 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementAbbrGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "abbr");
617}
618
619static inline bool setJSHTMLTableCellElementAbbrSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
620{
621 UNUSED_PARAM(throwScope);
622 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
623 auto& impl = thisObject.wrapped();
624 auto nativeValue = convert<IDLDOMString>(state, value);
625 RETURN_IF_EXCEPTION(throwScope, false);
626 AttributeSetter::call(state, throwScope, [&] {
627 return impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::abbrAttr, WTFMove(nativeValue));
628 });
629 return true;
630}
631
632bool setJSHTMLTableCellElementAbbr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
633{
634 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementAbbrSetter>(*state, thisValue, encodedValue, "abbr");
635}
636
637static inline JSValue jsHTMLTableCellElementScopeGetter(ExecState& state, JSHTMLTableCellElement& thisObject, ThrowScope& throwScope)
638{
639 UNUSED_PARAM(throwScope);
640 UNUSED_PARAM(state);
641 auto& impl = thisObject.wrapped();
642 JSValue result = toJS<IDLDOMString>(state, throwScope, impl.scope());
643 return result;
644}
645
646EncodedJSValue jsHTMLTableCellElementScope(ExecState* state, EncodedJSValue thisValue, PropertyName)
647{
648 return IDLAttribute<JSHTMLTableCellElement>::get<jsHTMLTableCellElementScopeGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "scope");
649}
650
651static inline bool setJSHTMLTableCellElementScopeSetter(ExecState& state, JSHTMLTableCellElement& thisObject, JSValue value, ThrowScope& throwScope)
652{
653 UNUSED_PARAM(throwScope);
654 CustomElementReactionDisallowedScope customElementReactionDisallowedScope;
655 auto& impl = thisObject.wrapped();
656 auto nativeValue = convert<IDLDOMString>(state, value);
657 RETURN_IF_EXCEPTION(throwScope, false);
658 AttributeSetter::call(state, throwScope, [&] {
659 return impl.setScope(WTFMove(nativeValue));
660 });
661 return true;
662}
663
664bool setJSHTMLTableCellElementScope(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
665{
666 return IDLAttribute<JSHTMLTableCellElement>::set<setJSHTMLTableCellElementScopeSetter>(*state, thisValue, encodedValue, "scope");
667}
668
669void JSHTMLTableCellElement::heapSnapshot(JSCell* cell, HeapSnapshotBuilder& builder)
670{
671 auto* thisObject = jsCast<JSHTMLTableCellElement*>(cell);
672 builder.setWrappedObjectForCell(cell, &thisObject->wrapped());
673 if (thisObject->scriptExecutionContext())
674 builder.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
675 Base::heapSnapshot(cell, builder);
676}
677
678
679}
680