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 "JSSVGPathElement.h"
23
24#include "JSDOMAttribute.h"
25#include "JSDOMBinding.h"
26#include "JSDOMConstructorNotConstructable.h"
27#include "JSDOMConvertBoolean.h"
28#include "JSDOMConvertInterface.h"
29#include "JSDOMConvertNumbers.h"
30#include "JSDOMExceptionHandling.h"
31#include "JSDOMGlobalObject.h"
32#include "JSDOMOperation.h"
33#include "JSDOMWrapperCache.h"
34#include "JSSVGAnimatedBoolean.h"
35#include "JSSVGPathSegArcAbs.h"
36#include "JSSVGPathSegArcRel.h"
37#include "JSSVGPathSegClosePath.h"
38#include "JSSVGPathSegCurvetoCubicAbs.h"
39#include "JSSVGPathSegCurvetoCubicRel.h"
40#include "JSSVGPathSegCurvetoCubicSmoothAbs.h"
41#include "JSSVGPathSegCurvetoCubicSmoothRel.h"
42#include "JSSVGPathSegCurvetoQuadraticAbs.h"
43#include "JSSVGPathSegCurvetoQuadraticRel.h"
44#include "JSSVGPathSegCurvetoQuadraticSmoothAbs.h"
45#include "JSSVGPathSegCurvetoQuadraticSmoothRel.h"
46#include "JSSVGPathSegLinetoAbs.h"
47#include "JSSVGPathSegLinetoHorizontalAbs.h"
48#include "JSSVGPathSegLinetoHorizontalRel.h"
49#include "JSSVGPathSegLinetoRel.h"
50#include "JSSVGPathSegLinetoVerticalAbs.h"
51#include "JSSVGPathSegLinetoVerticalRel.h"
52#include "JSSVGPathSegList.h"
53#include "JSSVGPathSegMovetoAbs.h"
54#include "JSSVGPathSegMovetoRel.h"
55#include "ScriptExecutionContext.h"
56#include <JavaScriptCore/HeapSnapshotBuilder.h>
57#include <JavaScriptCore/JSCInlines.h>
58#include <wtf/GetPtr.h>
59#include <wtf/PointerPreparations.h>
60#include <wtf/URL.h>
61
62
63namespace WebCore {
64using namespace JSC;
65
66// Functions
67
68JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionGetPathSegAtLength(JSC::ExecState*);
69JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegClosePath(JSC::ExecState*);
70JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoAbs(JSC::ExecState*);
71JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoRel(JSC::ExecState*);
72JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoAbs(JSC::ExecState*);
73JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoRel(JSC::ExecState*);
74JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicAbs(JSC::ExecState*);
75JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicRel(JSC::ExecState*);
76JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticAbs(JSC::ExecState*);
77JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticRel(JSC::ExecState*);
78JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcAbs(JSC::ExecState*);
79JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcRel(JSC::ExecState*);
80JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalAbs(JSC::ExecState*);
81JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalRel(JSC::ExecState*);
82JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalAbs(JSC::ExecState*);
83JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalRel(JSC::ExecState*);
84JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothAbs(JSC::ExecState*);
85JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothRel(JSC::ExecState*);
86JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothAbs(JSC::ExecState*);
87JSC::EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothRel(JSC::ExecState*);
88
89// Attributes
90
91JSC::EncodedJSValue jsSVGPathElementConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
92bool setJSSVGPathElementConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
93JSC::EncodedJSValue jsSVGPathElementPathSegList(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
94JSC::EncodedJSValue jsSVGPathElementNormalizedPathSegList(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
95JSC::EncodedJSValue jsSVGPathElementAnimatedPathSegList(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
96JSC::EncodedJSValue jsSVGPathElementAnimatedNormalizedPathSegList(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
97JSC::EncodedJSValue jsSVGPathElementExternalResourcesRequired(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
98
99class JSSVGPathElementPrototype : public JSC::JSNonFinalObject {
100public:
101 using Base = JSC::JSNonFinalObject;
102 static JSSVGPathElementPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
103 {
104 JSSVGPathElementPrototype* ptr = new (NotNull, JSC::allocateCell<JSSVGPathElementPrototype>(vm.heap)) JSSVGPathElementPrototype(vm, globalObject, structure);
105 ptr->finishCreation(vm);
106 return ptr;
107 }
108
109 DECLARE_INFO;
110 static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
111 {
112 return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
113 }
114
115private:
116 JSSVGPathElementPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
117 : JSC::JSNonFinalObject(vm, structure)
118 {
119 }
120
121 void finishCreation(JSC::VM&);
122};
123
124using JSSVGPathElementConstructor = JSDOMConstructorNotConstructable<JSSVGPathElement>;
125
126template<> JSValue JSSVGPathElementConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
127{
128 return JSSVGGeometryElement::getConstructor(vm, &globalObject);
129}
130
131template<> void JSSVGPathElementConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
132{
133 putDirect(vm, vm.propertyNames->prototype, JSSVGPathElement::prototype(vm, globalObject), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
134 putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String("SVGPathElement"_s)), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
135 putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
136}
137
138template<> const ClassInfo JSSVGPathElementConstructor::s_info = { "SVGPathElement", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSVGPathElementConstructor) };
139
140/* Hash table for prototype */
141
142static const HashTableValue JSSVGPathElementPrototypeTableValues[] =
143{
144 { "constructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSSVGPathElementConstructor) } },
145 { "pathSegList", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementPathSegList), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
146 { "normalizedPathSegList", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementNormalizedPathSegList), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
147 { "animatedPathSegList", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementAnimatedPathSegList), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
148 { "animatedNormalizedPathSegList", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementAnimatedNormalizedPathSegList), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
149 { "externalResourcesRequired", static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsSVGPathElementExternalResourcesRequired), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
150 { "getPathSegAtLength", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionGetPathSegAtLength), (intptr_t) (0) } },
151 { "createSVGPathSegClosePath", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegClosePath), (intptr_t) (0) } },
152 { "createSVGPathSegMovetoAbs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoAbs), (intptr_t) (0) } },
153 { "createSVGPathSegMovetoRel", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoRel), (intptr_t) (0) } },
154 { "createSVGPathSegLinetoAbs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoAbs), (intptr_t) (0) } },
155 { "createSVGPathSegLinetoRel", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoRel), (intptr_t) (0) } },
156 { "createSVGPathSegCurvetoCubicAbs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicAbs), (intptr_t) (0) } },
157 { "createSVGPathSegCurvetoCubicRel", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicRel), (intptr_t) (0) } },
158 { "createSVGPathSegCurvetoQuadraticAbs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticAbs), (intptr_t) (0) } },
159 { "createSVGPathSegCurvetoQuadraticRel", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticRel), (intptr_t) (0) } },
160 { "createSVGPathSegArcAbs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcAbs), (intptr_t) (0) } },
161 { "createSVGPathSegArcRel", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcRel), (intptr_t) (0) } },
162 { "createSVGPathSegLinetoHorizontalAbs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalAbs), (intptr_t) (0) } },
163 { "createSVGPathSegLinetoHorizontalRel", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalRel), (intptr_t) (0) } },
164 { "createSVGPathSegLinetoVerticalAbs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalAbs), (intptr_t) (0) } },
165 { "createSVGPathSegLinetoVerticalRel", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalRel), (intptr_t) (0) } },
166 { "createSVGPathSegCurvetoCubicSmoothAbs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothAbs), (intptr_t) (0) } },
167 { "createSVGPathSegCurvetoCubicSmoothRel", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothRel), (intptr_t) (0) } },
168 { "createSVGPathSegCurvetoQuadraticSmoothAbs", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothAbs), (intptr_t) (0) } },
169 { "createSVGPathSegCurvetoQuadraticSmoothRel", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothRel), (intptr_t) (0) } },
170};
171
172const ClassInfo JSSVGPathElementPrototype::s_info = { "SVGPathElementPrototype", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSVGPathElementPrototype) };
173
174void JSSVGPathElementPrototype::finishCreation(VM& vm)
175{
176 Base::finishCreation(vm);
177 reifyStaticProperties(vm, JSSVGPathElement::info(), JSSVGPathElementPrototypeTableValues, *this);
178}
179
180const ClassInfo JSSVGPathElement::s_info = { "SVGPathElement", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSVGPathElement) };
181
182JSSVGPathElement::JSSVGPathElement(Structure* structure, JSDOMGlobalObject& globalObject, Ref<SVGPathElement>&& impl)
183 : JSSVGGeometryElement(structure, globalObject, WTFMove(impl))
184{
185}
186
187void JSSVGPathElement::finishCreation(VM& vm)
188{
189 Base::finishCreation(vm);
190 ASSERT(inherits(vm, info()));
191
192}
193
194JSObject* JSSVGPathElement::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
195{
196 return JSSVGPathElementPrototype::create(vm, &globalObject, JSSVGPathElementPrototype::createStructure(vm, &globalObject, JSSVGGeometryElement::prototype(vm, globalObject)));
197}
198
199JSObject* JSSVGPathElement::prototype(VM& vm, JSDOMGlobalObject& globalObject)
200{
201 return getDOMPrototype<JSSVGPathElement>(vm, globalObject);
202}
203
204JSValue JSSVGPathElement::getConstructor(VM& vm, const JSGlobalObject* globalObject)
205{
206 return getDOMConstructor<JSSVGPathElementConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
207}
208
209template<> inline JSSVGPathElement* IDLAttribute<JSSVGPathElement>::cast(ExecState& state, EncodedJSValue thisValue)
210{
211 return jsDynamicCast<JSSVGPathElement*>(state.vm(), JSValue::decode(thisValue));
212}
213
214template<> inline JSSVGPathElement* IDLOperation<JSSVGPathElement>::cast(ExecState& state)
215{
216 return jsDynamicCast<JSSVGPathElement*>(state.vm(), state.thisValue());
217}
218
219EncodedJSValue jsSVGPathElementConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
220{
221 VM& vm = state->vm();
222 auto throwScope = DECLARE_THROW_SCOPE(vm);
223 auto* prototype = jsDynamicCast<JSSVGPathElementPrototype*>(vm, JSValue::decode(thisValue));
224 if (UNLIKELY(!prototype))
225 return throwVMTypeError(state, throwScope);
226 return JSValue::encode(JSSVGPathElement::getConstructor(state->vm(), prototype->globalObject()));
227}
228
229bool setJSSVGPathElementConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
230{
231 VM& vm = state->vm();
232 auto throwScope = DECLARE_THROW_SCOPE(vm);
233 auto* prototype = jsDynamicCast<JSSVGPathElementPrototype*>(vm, JSValue::decode(thisValue));
234 if (UNLIKELY(!prototype)) {
235 throwVMTypeError(state, throwScope);
236 return false;
237 }
238 // Shadowing a built-in constructor
239 return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));
240}
241
242static inline JSValue jsSVGPathElementPathSegListGetter(ExecState& state, JSSVGPathElement& thisObject, ThrowScope& throwScope)
243{
244 UNUSED_PARAM(throwScope);
245 UNUSED_PARAM(state);
246 auto& impl = thisObject.wrapped();
247 JSValue result = toJS<IDLInterface<SVGPathSegList>>(state, *thisObject.globalObject(), throwScope, impl.pathSegList());
248 return result;
249}
250
251EncodedJSValue jsSVGPathElementPathSegList(ExecState* state, EncodedJSValue thisValue, PropertyName)
252{
253 return IDLAttribute<JSSVGPathElement>::get<jsSVGPathElementPathSegListGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "pathSegList");
254}
255
256static inline JSValue jsSVGPathElementNormalizedPathSegListGetter(ExecState& state, JSSVGPathElement& thisObject, ThrowScope& throwScope)
257{
258 UNUSED_PARAM(throwScope);
259 UNUSED_PARAM(state);
260 auto& impl = thisObject.wrapped();
261 JSValue result = toJS<IDLInterface<SVGPathSegList>>(state, *thisObject.globalObject(), throwScope, impl.normalizedPathSegList());
262 return result;
263}
264
265EncodedJSValue jsSVGPathElementNormalizedPathSegList(ExecState* state, EncodedJSValue thisValue, PropertyName)
266{
267 return IDLAttribute<JSSVGPathElement>::get<jsSVGPathElementNormalizedPathSegListGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "normalizedPathSegList");
268}
269
270static inline JSValue jsSVGPathElementAnimatedPathSegListGetter(ExecState& state, JSSVGPathElement& thisObject, ThrowScope& throwScope)
271{
272 UNUSED_PARAM(throwScope);
273 UNUSED_PARAM(state);
274 auto& impl = thisObject.wrapped();
275 JSValue result = toJS<IDLInterface<SVGPathSegList>>(state, *thisObject.globalObject(), throwScope, impl.animatedPathSegList());
276 return result;
277}
278
279EncodedJSValue jsSVGPathElementAnimatedPathSegList(ExecState* state, EncodedJSValue thisValue, PropertyName)
280{
281 return IDLAttribute<JSSVGPathElement>::get<jsSVGPathElementAnimatedPathSegListGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "animatedPathSegList");
282}
283
284static inline JSValue jsSVGPathElementAnimatedNormalizedPathSegListGetter(ExecState& state, JSSVGPathElement& thisObject, ThrowScope& throwScope)
285{
286 UNUSED_PARAM(throwScope);
287 UNUSED_PARAM(state);
288 auto& impl = thisObject.wrapped();
289 JSValue result = toJS<IDLInterface<SVGPathSegList>>(state, *thisObject.globalObject(), throwScope, impl.animatedNormalizedPathSegList());
290 return result;
291}
292
293EncodedJSValue jsSVGPathElementAnimatedNormalizedPathSegList(ExecState* state, EncodedJSValue thisValue, PropertyName)
294{
295 return IDLAttribute<JSSVGPathElement>::get<jsSVGPathElementAnimatedNormalizedPathSegListGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "animatedNormalizedPathSegList");
296}
297
298static inline JSValue jsSVGPathElementExternalResourcesRequiredGetter(ExecState& state, JSSVGPathElement& thisObject, ThrowScope& throwScope)
299{
300 UNUSED_PARAM(throwScope);
301 UNUSED_PARAM(state);
302 auto& impl = thisObject.wrapped();
303 JSValue result = toJS<IDLInterface<SVGAnimatedBoolean>>(state, *thisObject.globalObject(), throwScope, impl.externalResourcesRequiredAnimated());
304 return result;
305}
306
307EncodedJSValue jsSVGPathElementExternalResourcesRequired(ExecState* state, EncodedJSValue thisValue, PropertyName)
308{
309 return IDLAttribute<JSSVGPathElement>::get<jsSVGPathElementExternalResourcesRequiredGetter, CastedThisErrorBehavior::Assert>(*state, thisValue, "externalResourcesRequired");
310}
311
312static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionGetPathSegAtLengthBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
313{
314 UNUSED_PARAM(state);
315 UNUSED_PARAM(throwScope);
316 auto& impl = castedThis->wrapped();
317 auto distance = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
318 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
319 return JSValue::encode(toJS<IDLUnsignedLong>(impl.getPathSegAtLength(WTFMove(distance))));
320}
321
322EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionGetPathSegAtLength(ExecState* state)
323{
324 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionGetPathSegAtLengthBody>(*state, "getPathSegAtLength");
325}
326
327static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegClosePathBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
328{
329 UNUSED_PARAM(state);
330 UNUSED_PARAM(throwScope);
331 auto& impl = castedThis->wrapped();
332 return JSValue::encode(toJS<IDLInterface<SVGPathSegClosePath>>(*state, *castedThis->globalObject(), impl.createSVGPathSegClosePath()));
333}
334
335EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegClosePath(ExecState* state)
336{
337 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegClosePathBody>(*state, "createSVGPathSegClosePath");
338}
339
340static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoAbsBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
341{
342 UNUSED_PARAM(state);
343 UNUSED_PARAM(throwScope);
344 auto& impl = castedThis->wrapped();
345 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
346 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
347 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
348 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
349 return JSValue::encode(toJS<IDLInterface<SVGPathSegMovetoAbs>>(*state, *castedThis->globalObject(), impl.createSVGPathSegMovetoAbs(WTFMove(x), WTFMove(y))));
350}
351
352EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoAbs(ExecState* state)
353{
354 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoAbsBody>(*state, "createSVGPathSegMovetoAbs");
355}
356
357static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoRelBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
358{
359 UNUSED_PARAM(state);
360 UNUSED_PARAM(throwScope);
361 auto& impl = castedThis->wrapped();
362 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
363 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
364 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
365 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
366 return JSValue::encode(toJS<IDLInterface<SVGPathSegMovetoRel>>(*state, *castedThis->globalObject(), impl.createSVGPathSegMovetoRel(WTFMove(x), WTFMove(y))));
367}
368
369EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoRel(ExecState* state)
370{
371 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegMovetoRelBody>(*state, "createSVGPathSegMovetoRel");
372}
373
374static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoAbsBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
375{
376 UNUSED_PARAM(state);
377 UNUSED_PARAM(throwScope);
378 auto& impl = castedThis->wrapped();
379 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
380 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
381 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
382 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
383 return JSValue::encode(toJS<IDLInterface<SVGPathSegLinetoAbs>>(*state, *castedThis->globalObject(), impl.createSVGPathSegLinetoAbs(WTFMove(x), WTFMove(y))));
384}
385
386EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoAbs(ExecState* state)
387{
388 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoAbsBody>(*state, "createSVGPathSegLinetoAbs");
389}
390
391static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoRelBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
392{
393 UNUSED_PARAM(state);
394 UNUSED_PARAM(throwScope);
395 auto& impl = castedThis->wrapped();
396 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
397 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
398 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
399 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
400 return JSValue::encode(toJS<IDLInterface<SVGPathSegLinetoRel>>(*state, *castedThis->globalObject(), impl.createSVGPathSegLinetoRel(WTFMove(x), WTFMove(y))));
401}
402
403EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoRel(ExecState* state)
404{
405 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoRelBody>(*state, "createSVGPathSegLinetoRel");
406}
407
408static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicAbsBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
409{
410 UNUSED_PARAM(state);
411 UNUSED_PARAM(throwScope);
412 auto& impl = castedThis->wrapped();
413 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
414 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
415 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
416 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
417 auto x1 = convert<IDLUnrestrictedFloat>(*state, state->argument(2));
418 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
419 auto y1 = convert<IDLUnrestrictedFloat>(*state, state->argument(3));
420 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
421 auto x2 = convert<IDLUnrestrictedFloat>(*state, state->argument(4));
422 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
423 auto y2 = convert<IDLUnrestrictedFloat>(*state, state->argument(5));
424 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
425 return JSValue::encode(toJS<IDLInterface<SVGPathSegCurvetoCubicAbs>>(*state, *castedThis->globalObject(), impl.createSVGPathSegCurvetoCubicAbs(WTFMove(x), WTFMove(y), WTFMove(x1), WTFMove(y1), WTFMove(x2), WTFMove(y2))));
426}
427
428EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicAbs(ExecState* state)
429{
430 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicAbsBody>(*state, "createSVGPathSegCurvetoCubicAbs");
431}
432
433static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicRelBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
434{
435 UNUSED_PARAM(state);
436 UNUSED_PARAM(throwScope);
437 auto& impl = castedThis->wrapped();
438 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
439 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
440 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
441 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
442 auto x1 = convert<IDLUnrestrictedFloat>(*state, state->argument(2));
443 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
444 auto y1 = convert<IDLUnrestrictedFloat>(*state, state->argument(3));
445 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
446 auto x2 = convert<IDLUnrestrictedFloat>(*state, state->argument(4));
447 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
448 auto y2 = convert<IDLUnrestrictedFloat>(*state, state->argument(5));
449 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
450 return JSValue::encode(toJS<IDLInterface<SVGPathSegCurvetoCubicRel>>(*state, *castedThis->globalObject(), impl.createSVGPathSegCurvetoCubicRel(WTFMove(x), WTFMove(y), WTFMove(x1), WTFMove(y1), WTFMove(x2), WTFMove(y2))));
451}
452
453EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicRel(ExecState* state)
454{
455 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicRelBody>(*state, "createSVGPathSegCurvetoCubicRel");
456}
457
458static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticAbsBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
459{
460 UNUSED_PARAM(state);
461 UNUSED_PARAM(throwScope);
462 auto& impl = castedThis->wrapped();
463 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
464 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
465 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
466 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
467 auto x1 = convert<IDLUnrestrictedFloat>(*state, state->argument(2));
468 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
469 auto y1 = convert<IDLUnrestrictedFloat>(*state, state->argument(3));
470 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
471 return JSValue::encode(toJS<IDLInterface<SVGPathSegCurvetoQuadraticAbs>>(*state, *castedThis->globalObject(), impl.createSVGPathSegCurvetoQuadraticAbs(WTFMove(x), WTFMove(y), WTFMove(x1), WTFMove(y1))));
472}
473
474EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticAbs(ExecState* state)
475{
476 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticAbsBody>(*state, "createSVGPathSegCurvetoQuadraticAbs");
477}
478
479static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticRelBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
480{
481 UNUSED_PARAM(state);
482 UNUSED_PARAM(throwScope);
483 auto& impl = castedThis->wrapped();
484 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
485 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
486 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
487 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
488 auto x1 = convert<IDLUnrestrictedFloat>(*state, state->argument(2));
489 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
490 auto y1 = convert<IDLUnrestrictedFloat>(*state, state->argument(3));
491 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
492 return JSValue::encode(toJS<IDLInterface<SVGPathSegCurvetoQuadraticRel>>(*state, *castedThis->globalObject(), impl.createSVGPathSegCurvetoQuadraticRel(WTFMove(x), WTFMove(y), WTFMove(x1), WTFMove(y1))));
493}
494
495EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticRel(ExecState* state)
496{
497 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticRelBody>(*state, "createSVGPathSegCurvetoQuadraticRel");
498}
499
500static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcAbsBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
501{
502 UNUSED_PARAM(state);
503 UNUSED_PARAM(throwScope);
504 auto& impl = castedThis->wrapped();
505 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
506 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
507 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
508 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
509 auto r1 = convert<IDLUnrestrictedFloat>(*state, state->argument(2));
510 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
511 auto r2 = convert<IDLUnrestrictedFloat>(*state, state->argument(3));
512 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
513 auto angle = convert<IDLUnrestrictedFloat>(*state, state->argument(4));
514 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
515 auto largeArcFlag = convert<IDLBoolean>(*state, state->argument(5));
516 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
517 auto sweepFlag = convert<IDLBoolean>(*state, state->argument(6));
518 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
519 return JSValue::encode(toJS<IDLInterface<SVGPathSegArcAbs>>(*state, *castedThis->globalObject(), impl.createSVGPathSegArcAbs(WTFMove(x), WTFMove(y), WTFMove(r1), WTFMove(r2), WTFMove(angle), WTFMove(largeArcFlag), WTFMove(sweepFlag))));
520}
521
522EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcAbs(ExecState* state)
523{
524 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcAbsBody>(*state, "createSVGPathSegArcAbs");
525}
526
527static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcRelBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
528{
529 UNUSED_PARAM(state);
530 UNUSED_PARAM(throwScope);
531 auto& impl = castedThis->wrapped();
532 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
533 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
534 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
535 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
536 auto r1 = convert<IDLUnrestrictedFloat>(*state, state->argument(2));
537 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
538 auto r2 = convert<IDLUnrestrictedFloat>(*state, state->argument(3));
539 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
540 auto angle = convert<IDLUnrestrictedFloat>(*state, state->argument(4));
541 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
542 auto largeArcFlag = convert<IDLBoolean>(*state, state->argument(5));
543 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
544 auto sweepFlag = convert<IDLBoolean>(*state, state->argument(6));
545 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
546 return JSValue::encode(toJS<IDLInterface<SVGPathSegArcRel>>(*state, *castedThis->globalObject(), impl.createSVGPathSegArcRel(WTFMove(x), WTFMove(y), WTFMove(r1), WTFMove(r2), WTFMove(angle), WTFMove(largeArcFlag), WTFMove(sweepFlag))));
547}
548
549EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcRel(ExecState* state)
550{
551 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegArcRelBody>(*state, "createSVGPathSegArcRel");
552}
553
554static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalAbsBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
555{
556 UNUSED_PARAM(state);
557 UNUSED_PARAM(throwScope);
558 auto& impl = castedThis->wrapped();
559 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
560 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
561 return JSValue::encode(toJS<IDLInterface<SVGPathSegLinetoHorizontalAbs>>(*state, *castedThis->globalObject(), impl.createSVGPathSegLinetoHorizontalAbs(WTFMove(x))));
562}
563
564EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalAbs(ExecState* state)
565{
566 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalAbsBody>(*state, "createSVGPathSegLinetoHorizontalAbs");
567}
568
569static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalRelBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
570{
571 UNUSED_PARAM(state);
572 UNUSED_PARAM(throwScope);
573 auto& impl = castedThis->wrapped();
574 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
575 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
576 return JSValue::encode(toJS<IDLInterface<SVGPathSegLinetoHorizontalRel>>(*state, *castedThis->globalObject(), impl.createSVGPathSegLinetoHorizontalRel(WTFMove(x))));
577}
578
579EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalRel(ExecState* state)
580{
581 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoHorizontalRelBody>(*state, "createSVGPathSegLinetoHorizontalRel");
582}
583
584static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalAbsBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
585{
586 UNUSED_PARAM(state);
587 UNUSED_PARAM(throwScope);
588 auto& impl = castedThis->wrapped();
589 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
590 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
591 return JSValue::encode(toJS<IDLInterface<SVGPathSegLinetoVerticalAbs>>(*state, *castedThis->globalObject(), impl.createSVGPathSegLinetoVerticalAbs(WTFMove(y))));
592}
593
594EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalAbs(ExecState* state)
595{
596 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalAbsBody>(*state, "createSVGPathSegLinetoVerticalAbs");
597}
598
599static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalRelBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
600{
601 UNUSED_PARAM(state);
602 UNUSED_PARAM(throwScope);
603 auto& impl = castedThis->wrapped();
604 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
605 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
606 return JSValue::encode(toJS<IDLInterface<SVGPathSegLinetoVerticalRel>>(*state, *castedThis->globalObject(), impl.createSVGPathSegLinetoVerticalRel(WTFMove(y))));
607}
608
609EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalRel(ExecState* state)
610{
611 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegLinetoVerticalRelBody>(*state, "createSVGPathSegLinetoVerticalRel");
612}
613
614static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothAbsBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
615{
616 UNUSED_PARAM(state);
617 UNUSED_PARAM(throwScope);
618 auto& impl = castedThis->wrapped();
619 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
620 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
621 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
622 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
623 auto x2 = convert<IDLUnrestrictedFloat>(*state, state->argument(2));
624 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
625 auto y2 = convert<IDLUnrestrictedFloat>(*state, state->argument(3));
626 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
627 return JSValue::encode(toJS<IDLInterface<SVGPathSegCurvetoCubicSmoothAbs>>(*state, *castedThis->globalObject(), impl.createSVGPathSegCurvetoCubicSmoothAbs(WTFMove(x), WTFMove(y), WTFMove(x2), WTFMove(y2))));
628}
629
630EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothAbs(ExecState* state)
631{
632 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothAbsBody>(*state, "createSVGPathSegCurvetoCubicSmoothAbs");
633}
634
635static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothRelBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
636{
637 UNUSED_PARAM(state);
638 UNUSED_PARAM(throwScope);
639 auto& impl = castedThis->wrapped();
640 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
641 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
642 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
643 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
644 auto x2 = convert<IDLUnrestrictedFloat>(*state, state->argument(2));
645 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
646 auto y2 = convert<IDLUnrestrictedFloat>(*state, state->argument(3));
647 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
648 return JSValue::encode(toJS<IDLInterface<SVGPathSegCurvetoCubicSmoothRel>>(*state, *castedThis->globalObject(), impl.createSVGPathSegCurvetoCubicSmoothRel(WTFMove(x), WTFMove(y), WTFMove(x2), WTFMove(y2))));
649}
650
651EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothRel(ExecState* state)
652{
653 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoCubicSmoothRelBody>(*state, "createSVGPathSegCurvetoCubicSmoothRel");
654}
655
656static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothAbsBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
657{
658 UNUSED_PARAM(state);
659 UNUSED_PARAM(throwScope);
660 auto& impl = castedThis->wrapped();
661 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
662 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
663 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
664 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
665 return JSValue::encode(toJS<IDLInterface<SVGPathSegCurvetoQuadraticSmoothAbs>>(*state, *castedThis->globalObject(), impl.createSVGPathSegCurvetoQuadraticSmoothAbs(WTFMove(x), WTFMove(y))));
666}
667
668EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothAbs(ExecState* state)
669{
670 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothAbsBody>(*state, "createSVGPathSegCurvetoQuadraticSmoothAbs");
671}
672
673static inline JSC::EncodedJSValue jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothRelBody(JSC::ExecState* state, typename IDLOperation<JSSVGPathElement>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
674{
675 UNUSED_PARAM(state);
676 UNUSED_PARAM(throwScope);
677 auto& impl = castedThis->wrapped();
678 auto x = convert<IDLUnrestrictedFloat>(*state, state->argument(0));
679 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
680 auto y = convert<IDLUnrestrictedFloat>(*state, state->argument(1));
681 RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
682 return JSValue::encode(toJS<IDLInterface<SVGPathSegCurvetoQuadraticSmoothRel>>(*state, *castedThis->globalObject(), impl.createSVGPathSegCurvetoQuadraticSmoothRel(WTFMove(x), WTFMove(y))));
683}
684
685EncodedJSValue JSC_HOST_CALL jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothRel(ExecState* state)
686{
687 return IDLOperation<JSSVGPathElement>::call<jsSVGPathElementPrototypeFunctionCreateSVGPathSegCurvetoQuadraticSmoothRelBody>(*state, "createSVGPathSegCurvetoQuadraticSmoothRel");
688}
689
690void JSSVGPathElement::heapSnapshot(JSCell* cell, HeapSnapshotBuilder& builder)
691{
692 auto* thisObject = jsCast<JSSVGPathElement*>(cell);
693 builder.setWrappedObjectForCell(cell, &thisObject->wrapped());
694 if (thisObject->scriptExecutionContext())
695 builder.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
696 Base::heapSnapshot(cell, builder);
697}
698
699
700}
701