1#![allow(non_camel_case_types,non_upper_case_globals,unsafe_op_in_unsafe_fn,unused_imports,unused_variables,unused_assignments,unused_mut,clippy::approx_constant,clippy::enum_variant_names,clippy::let_unit_value,clippy::needless_return,clippy::too_many_arguments,clippy::unnecessary_cast,clippy::upper_case_acronyms)]
4
5use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
6use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
7use crate::codegen::GenericBindings::HTMLElementBinding::HTMLElement_Binding;
8use crate::codegen::GenericBindings::HTMLFormElementBinding::SelectionMode;
9use crate::codegen::GenericBindings::HTMLFormElementBinding::SelectionModeValues;
10use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
11use crate::import::base::*;
12
13pub use self::HTMLInputElement_Binding::{Wrap, HTMLInputElementMethods, GetProtoObject, GetConstructorObject, DefineDOMInterface};
14pub mod HTMLInputElement_Binding {
15use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
16use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
17use crate::codegen::GenericBindings::HTMLElementBinding::HTMLElement_Binding;
18use crate::codegen::GenericBindings::HTMLFormElementBinding::SelectionMode;
19use crate::codegen::GenericBindings::HTMLFormElementBinding::SelectionModeValues;
20use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
21use crate::import::module::*;
22
23unsafe extern "C" fn get_accept<D: DomTypes>
24(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
25 let mut result = false;
26 wrap_panic(&mut || result = (|| {
27 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
28 let this = &*(this as *const D::HTMLInputElement);
29 <D as DomHelpers<D>>::push_new_element_queue();
30
31 let result: DOMString = this.Accept();
32 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
33
34
35 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
36 return true;
37 })());
38 result
39}
40
41unsafe extern "C" fn set_accept<D: DomTypes>
42(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
43 let mut result = false;
44 wrap_panic(&mut || result = (|| {
45 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
46 let this = &*(this as *const D::HTMLInputElement);
47 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
48 Ok(ConversionResult::Success(value)) => value,
49 Ok(ConversionResult::Failure(error)) => {
50 throw_type_error(cx.raw_cx(), &error);
51 return false;
52
53 }
54 _ => {
55 return false;
56
57 },
58 }
59 ;
60 <D as DomHelpers<D>>::push_new_element_queue();
61
62 let result: () = this.SetAccept(arg0);
63 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
64
65
66 true
67 })());
68 result
69}
70
71
72static accept_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
73
74pub(crate) fn init_accept_getterinfo<D: DomTypes>() {
75 accept_getterinfo.set(JSJitInfo {
76 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
77 getter: Some(get_accept::<D>)
78 },
79 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
80 protoID: PrototypeList::ID::HTMLInputElement as u16,
81 },
82 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
83 _bitfield_align_1: [],
84 _bitfield_1: __BindgenBitfieldUnit::new(
85 new_jsjitinfo_bitfield_1!(
86 JSJitInfo_OpType::Getter as u8,
87 JSJitInfo_AliasSet::AliasEverything as u8,
88 JSValueType::JSVAL_TYPE_STRING as u8,
89 true,
90 false,
91 false,
92 false,
93 false,
94 false,
95 0,
96 ).to_ne_bytes()
97 ),
98});
99}
100static accept_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
101
102pub(crate) fn init_accept_setterinfo<D: DomTypes>() {
103 accept_setterinfo.set(JSJitInfo {
104 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
105 setter: Some(set_accept::<D>)
106 },
107 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
108 protoID: PrototypeList::ID::HTMLInputElement as u16,
109 },
110 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
111 _bitfield_align_1: [],
112 _bitfield_1: __BindgenBitfieldUnit::new(
113 new_jsjitinfo_bitfield_1!(
114 JSJitInfo_OpType::Setter as u8,
115 JSJitInfo_AliasSet::AliasEverything as u8,
116 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
117 false,
118 false,
119 false,
120 false,
121 false,
122 false,
123 0,
124 ).to_ne_bytes()
125 ),
126});
127}
128unsafe extern "C" fn get_alt<D: DomTypes>
129(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
130 let mut result = false;
131 wrap_panic(&mut || result = (|| {
132 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
133 let this = &*(this as *const D::HTMLInputElement);
134 <D as DomHelpers<D>>::push_new_element_queue();
135
136 let result: DOMString = this.Alt();
137 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
138
139
140 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
141 return true;
142 })());
143 result
144}
145
146unsafe extern "C" fn set_alt<D: DomTypes>
147(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
148 let mut result = false;
149 wrap_panic(&mut || result = (|| {
150 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
151 let this = &*(this as *const D::HTMLInputElement);
152 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
153 Ok(ConversionResult::Success(value)) => value,
154 Ok(ConversionResult::Failure(error)) => {
155 throw_type_error(cx.raw_cx(), &error);
156 return false;
157
158 }
159 _ => {
160 return false;
161
162 },
163 }
164 ;
165 <D as DomHelpers<D>>::push_new_element_queue();
166
167 let result: () = this.SetAlt(arg0);
168 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
169
170
171 true
172 })());
173 result
174}
175
176
177static alt_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
178
179pub(crate) fn init_alt_getterinfo<D: DomTypes>() {
180 alt_getterinfo.set(JSJitInfo {
181 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
182 getter: Some(get_alt::<D>)
183 },
184 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
185 protoID: PrototypeList::ID::HTMLInputElement as u16,
186 },
187 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
188 _bitfield_align_1: [],
189 _bitfield_1: __BindgenBitfieldUnit::new(
190 new_jsjitinfo_bitfield_1!(
191 JSJitInfo_OpType::Getter as u8,
192 JSJitInfo_AliasSet::AliasEverything as u8,
193 JSValueType::JSVAL_TYPE_STRING as u8,
194 true,
195 false,
196 false,
197 false,
198 false,
199 false,
200 0,
201 ).to_ne_bytes()
202 ),
203});
204}
205static alt_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
206
207pub(crate) fn init_alt_setterinfo<D: DomTypes>() {
208 alt_setterinfo.set(JSJitInfo {
209 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
210 setter: Some(set_alt::<D>)
211 },
212 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
213 protoID: PrototypeList::ID::HTMLInputElement as u16,
214 },
215 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
216 _bitfield_align_1: [],
217 _bitfield_1: __BindgenBitfieldUnit::new(
218 new_jsjitinfo_bitfield_1!(
219 JSJitInfo_OpType::Setter as u8,
220 JSJitInfo_AliasSet::AliasEverything as u8,
221 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
222 false,
223 false,
224 false,
225 false,
226 false,
227 false,
228 0,
229 ).to_ne_bytes()
230 ),
231});
232}
233unsafe extern "C" fn get_defaultChecked<D: DomTypes>
234(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
235 let mut result = false;
236 wrap_panic(&mut || result = (|| {
237 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
238 let this = &*(this as *const D::HTMLInputElement);
239 <D as DomHelpers<D>>::push_new_element_queue();
240
241 let result: bool = this.DefaultChecked();
242 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
243
244
245 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
246 return true;
247 })());
248 result
249}
250
251unsafe extern "C" fn set_defaultChecked<D: DomTypes>
252(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
253 let mut result = false;
254 wrap_panic(&mut || result = (|| {
255 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
256 let this = &*(this as *const D::HTMLInputElement);
257 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
258 Ok(ConversionResult::Success(value)) => value,
259 Ok(ConversionResult::Failure(error)) => {
260 throw_type_error(cx.raw_cx(), &error);
261 return false;
262
263 }
264 _ => {
265 return false;
266
267 },
268 }
269 ;
270 <D as DomHelpers<D>>::push_new_element_queue();
271
272 let result: () = this.SetDefaultChecked(arg0);
273 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
274
275
276 true
277 })());
278 result
279}
280
281
282static defaultChecked_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
283
284pub(crate) fn init_defaultChecked_getterinfo<D: DomTypes>() {
285 defaultChecked_getterinfo.set(JSJitInfo {
286 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
287 getter: Some(get_defaultChecked::<D>)
288 },
289 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
290 protoID: PrototypeList::ID::HTMLInputElement as u16,
291 },
292 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
293 _bitfield_align_1: [],
294 _bitfield_1: __BindgenBitfieldUnit::new(
295 new_jsjitinfo_bitfield_1!(
296 JSJitInfo_OpType::Getter as u8,
297 JSJitInfo_AliasSet::AliasEverything as u8,
298 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
299 true,
300 false,
301 false,
302 false,
303 false,
304 false,
305 0,
306 ).to_ne_bytes()
307 ),
308});
309}
310static defaultChecked_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
311
312pub(crate) fn init_defaultChecked_setterinfo<D: DomTypes>() {
313 defaultChecked_setterinfo.set(JSJitInfo {
314 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
315 setter: Some(set_defaultChecked::<D>)
316 },
317 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
318 protoID: PrototypeList::ID::HTMLInputElement as u16,
319 },
320 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
321 _bitfield_align_1: [],
322 _bitfield_1: __BindgenBitfieldUnit::new(
323 new_jsjitinfo_bitfield_1!(
324 JSJitInfo_OpType::Setter as u8,
325 JSJitInfo_AliasSet::AliasEverything as u8,
326 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
327 false,
328 false,
329 false,
330 false,
331 false,
332 false,
333 0,
334 ).to_ne_bytes()
335 ),
336});
337}
338unsafe extern "C" fn get_checked<D: DomTypes>
339(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
340 let mut result = false;
341 wrap_panic(&mut || result = (|| {
342 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
343 let this = &*(this as *const D::HTMLInputElement);
344 let result: bool = this.Checked();
345
346 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
347 return true;
348 })());
349 result
350}
351
352unsafe extern "C" fn set_checked<D: DomTypes>
353(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
354 let mut result = false;
355 wrap_panic(&mut || result = (|| {
356 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
357 let this = &*(this as *const D::HTMLInputElement);
358 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
359 Ok(ConversionResult::Success(value)) => value,
360 Ok(ConversionResult::Failure(error)) => {
361 throw_type_error(cx.raw_cx(), &error);
362 return false;
363
364 }
365 _ => {
366 return false;
367
368 },
369 }
370 ;
371 let result: () = this.SetChecked(arg0, CanGc::note());
372
373 true
374 })());
375 result
376}
377
378
379static checked_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
380
381pub(crate) fn init_checked_getterinfo<D: DomTypes>() {
382 checked_getterinfo.set(JSJitInfo {
383 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
384 getter: Some(get_checked::<D>)
385 },
386 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
387 protoID: PrototypeList::ID::HTMLInputElement as u16,
388 },
389 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
390 _bitfield_align_1: [],
391 _bitfield_1: __BindgenBitfieldUnit::new(
392 new_jsjitinfo_bitfield_1!(
393 JSJitInfo_OpType::Getter as u8,
394 JSJitInfo_AliasSet::AliasEverything as u8,
395 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
396 true,
397 false,
398 false,
399 false,
400 false,
401 false,
402 0,
403 ).to_ne_bytes()
404 ),
405});
406}
407static checked_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
408
409pub(crate) fn init_checked_setterinfo<D: DomTypes>() {
410 checked_setterinfo.set(JSJitInfo {
411 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
412 setter: Some(set_checked::<D>)
413 },
414 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
415 protoID: PrototypeList::ID::HTMLInputElement as u16,
416 },
417 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
418 _bitfield_align_1: [],
419 _bitfield_1: __BindgenBitfieldUnit::new(
420 new_jsjitinfo_bitfield_1!(
421 JSJitInfo_OpType::Setter as u8,
422 JSJitInfo_AliasSet::AliasEverything as u8,
423 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
424 false,
425 false,
426 false,
427 false,
428 false,
429 false,
430 0,
431 ).to_ne_bytes()
432 ),
433});
434}
435unsafe extern "C" fn get_dirName<D: DomTypes>
436(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
437 let mut result = false;
438 wrap_panic(&mut || result = (|| {
439 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
440 let this = &*(this as *const D::HTMLInputElement);
441 <D as DomHelpers<D>>::push_new_element_queue();
442
443 let result: DOMString = this.DirName();
444 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
445
446
447 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
448 return true;
449 })());
450 result
451}
452
453unsafe extern "C" fn set_dirName<D: DomTypes>
454(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
455 let mut result = false;
456 wrap_panic(&mut || result = (|| {
457 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
458 let this = &*(this as *const D::HTMLInputElement);
459 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
460 Ok(ConversionResult::Success(value)) => value,
461 Ok(ConversionResult::Failure(error)) => {
462 throw_type_error(cx.raw_cx(), &error);
463 return false;
464
465 }
466 _ => {
467 return false;
468
469 },
470 }
471 ;
472 <D as DomHelpers<D>>::push_new_element_queue();
473
474 let result: () = this.SetDirName(arg0);
475 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
476
477
478 true
479 })());
480 result
481}
482
483
484static dirName_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
485
486pub(crate) fn init_dirName_getterinfo<D: DomTypes>() {
487 dirName_getterinfo.set(JSJitInfo {
488 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
489 getter: Some(get_dirName::<D>)
490 },
491 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
492 protoID: PrototypeList::ID::HTMLInputElement as u16,
493 },
494 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
495 _bitfield_align_1: [],
496 _bitfield_1: __BindgenBitfieldUnit::new(
497 new_jsjitinfo_bitfield_1!(
498 JSJitInfo_OpType::Getter as u8,
499 JSJitInfo_AliasSet::AliasEverything as u8,
500 JSValueType::JSVAL_TYPE_STRING as u8,
501 true,
502 false,
503 false,
504 false,
505 false,
506 false,
507 0,
508 ).to_ne_bytes()
509 ),
510});
511}
512static dirName_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
513
514pub(crate) fn init_dirName_setterinfo<D: DomTypes>() {
515 dirName_setterinfo.set(JSJitInfo {
516 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
517 setter: Some(set_dirName::<D>)
518 },
519 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
520 protoID: PrototypeList::ID::HTMLInputElement as u16,
521 },
522 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
523 _bitfield_align_1: [],
524 _bitfield_1: __BindgenBitfieldUnit::new(
525 new_jsjitinfo_bitfield_1!(
526 JSJitInfo_OpType::Setter as u8,
527 JSJitInfo_AliasSet::AliasEverything as u8,
528 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
529 false,
530 false,
531 false,
532 false,
533 false,
534 false,
535 0,
536 ).to_ne_bytes()
537 ),
538});
539}
540unsafe extern "C" fn get_disabled<D: DomTypes>
541(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
542 let mut result = false;
543 wrap_panic(&mut || result = (|| {
544 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
545 let this = &*(this as *const D::HTMLInputElement);
546 <D as DomHelpers<D>>::push_new_element_queue();
547
548 let result: bool = this.Disabled();
549 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
550
551
552 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
553 return true;
554 })());
555 result
556}
557
558unsafe extern "C" fn set_disabled<D: DomTypes>
559(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
560 let mut result = false;
561 wrap_panic(&mut || result = (|| {
562 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
563 let this = &*(this as *const D::HTMLInputElement);
564 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
565 Ok(ConversionResult::Success(value)) => value,
566 Ok(ConversionResult::Failure(error)) => {
567 throw_type_error(cx.raw_cx(), &error);
568 return false;
569
570 }
571 _ => {
572 return false;
573
574 },
575 }
576 ;
577 <D as DomHelpers<D>>::push_new_element_queue();
578
579 let result: () = this.SetDisabled(arg0);
580 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
581
582
583 true
584 })());
585 result
586}
587
588
589static disabled_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
590
591pub(crate) fn init_disabled_getterinfo<D: DomTypes>() {
592 disabled_getterinfo.set(JSJitInfo {
593 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
594 getter: Some(get_disabled::<D>)
595 },
596 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
597 protoID: PrototypeList::ID::HTMLInputElement as u16,
598 },
599 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
600 _bitfield_align_1: [],
601 _bitfield_1: __BindgenBitfieldUnit::new(
602 new_jsjitinfo_bitfield_1!(
603 JSJitInfo_OpType::Getter as u8,
604 JSJitInfo_AliasSet::AliasEverything as u8,
605 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
606 true,
607 false,
608 false,
609 false,
610 false,
611 false,
612 0,
613 ).to_ne_bytes()
614 ),
615});
616}
617static disabled_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
618
619pub(crate) fn init_disabled_setterinfo<D: DomTypes>() {
620 disabled_setterinfo.set(JSJitInfo {
621 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
622 setter: Some(set_disabled::<D>)
623 },
624 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
625 protoID: PrototypeList::ID::HTMLInputElement as u16,
626 },
627 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
628 _bitfield_align_1: [],
629 _bitfield_1: __BindgenBitfieldUnit::new(
630 new_jsjitinfo_bitfield_1!(
631 JSJitInfo_OpType::Setter as u8,
632 JSJitInfo_AliasSet::AliasEverything as u8,
633 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
634 false,
635 false,
636 false,
637 false,
638 false,
639 false,
640 0,
641 ).to_ne_bytes()
642 ),
643});
644}
645unsafe extern "C" fn get_form<D: DomTypes>
646(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
647 let mut result = false;
648 wrap_panic(&mut || result = (|| {
649 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
650 let this = &*(this as *const D::HTMLInputElement);
651 let result: Option<DomRoot<D::HTMLFormElement>> = this.GetForm();
652
653 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
654 return true;
655 })());
656 result
657}
658
659
660static form_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
661
662pub(crate) fn init_form_getterinfo<D: DomTypes>() {
663 form_getterinfo.set(JSJitInfo {
664 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
665 getter: Some(get_form::<D>)
666 },
667 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
668 protoID: PrototypeList::ID::HTMLInputElement as u16,
669 },
670 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
671 _bitfield_align_1: [],
672 _bitfield_1: __BindgenBitfieldUnit::new(
673 new_jsjitinfo_bitfield_1!(
674 JSJitInfo_OpType::Getter as u8,
675 JSJitInfo_AliasSet::AliasEverything as u8,
676 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
677 true,
678 false,
679 false,
680 false,
681 false,
682 false,
683 0,
684 ).to_ne_bytes()
685 ),
686});
687}
688unsafe extern "C" fn get_files<D: DomTypes>
689(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
690 let mut result = false;
691 wrap_panic(&mut || result = (|| {
692 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
693 let this = &*(this as *const D::HTMLInputElement);
694 let result: Option<DomRoot<D::FileList>> = this.GetFiles();
695
696 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
697 return true;
698 })());
699 result
700}
701
702unsafe extern "C" fn set_files<D: DomTypes>
703(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
704 let mut result = false;
705 wrap_panic(&mut || result = (|| {
706 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
707 let this = &*(this as *const D::HTMLInputElement);
708 let arg0: Option<DomRoot<D::FileList>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
709 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
710 Ok(val) => val,
711 Err(()) => {
712 throw_type_error(cx.raw_cx(), "value does not implement interface FileList.");
713 return false;
714
715 }
716 }
717 )
718 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
719 None
720 } else {
721 throw_type_error(cx.raw_cx(), "Value is not an object.");
722 return false;
723
724 };
725 let result: () = this.SetFiles(arg0.as_deref());
726
727 true
728 })());
729 result
730}
731
732
733static files_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
734
735pub(crate) fn init_files_getterinfo<D: DomTypes>() {
736 files_getterinfo.set(JSJitInfo {
737 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
738 getter: Some(get_files::<D>)
739 },
740 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
741 protoID: PrototypeList::ID::HTMLInputElement as u16,
742 },
743 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
744 _bitfield_align_1: [],
745 _bitfield_1: __BindgenBitfieldUnit::new(
746 new_jsjitinfo_bitfield_1!(
747 JSJitInfo_OpType::Getter as u8,
748 JSJitInfo_AliasSet::AliasEverything as u8,
749 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
750 true,
751 false,
752 false,
753 false,
754 false,
755 false,
756 0,
757 ).to_ne_bytes()
758 ),
759});
760}
761static files_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
762
763pub(crate) fn init_files_setterinfo<D: DomTypes>() {
764 files_setterinfo.set(JSJitInfo {
765 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
766 setter: Some(set_files::<D>)
767 },
768 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
769 protoID: PrototypeList::ID::HTMLInputElement as u16,
770 },
771 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
772 _bitfield_align_1: [],
773 _bitfield_1: __BindgenBitfieldUnit::new(
774 new_jsjitinfo_bitfield_1!(
775 JSJitInfo_OpType::Setter as u8,
776 JSJitInfo_AliasSet::AliasEverything as u8,
777 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
778 false,
779 false,
780 false,
781 false,
782 false,
783 false,
784 0,
785 ).to_ne_bytes()
786 ),
787});
788}
789unsafe extern "C" fn get_formAction<D: DomTypes>
790(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
791 let mut result = false;
792 wrap_panic(&mut || result = (|| {
793 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
794 let this = &*(this as *const D::HTMLInputElement);
795 <D as DomHelpers<D>>::push_new_element_queue();
796
797 let result: DOMString = this.FormAction();
798 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
799
800
801 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
802 return true;
803 })());
804 result
805}
806
807unsafe extern "C" fn set_formAction<D: DomTypes>
808(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
809 let mut result = false;
810 wrap_panic(&mut || result = (|| {
811 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
812 let this = &*(this as *const D::HTMLInputElement);
813 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
814 Ok(ConversionResult::Success(value)) => value,
815 Ok(ConversionResult::Failure(error)) => {
816 throw_type_error(cx.raw_cx(), &error);
817 return false;
818
819 }
820 _ => {
821 return false;
822
823 },
824 }
825 ;
826 <D as DomHelpers<D>>::push_new_element_queue();
827
828 let result: () = this.SetFormAction(arg0);
829 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
830
831
832 true
833 })());
834 result
835}
836
837
838static formAction_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
839
840pub(crate) fn init_formAction_getterinfo<D: DomTypes>() {
841 formAction_getterinfo.set(JSJitInfo {
842 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
843 getter: Some(get_formAction::<D>)
844 },
845 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
846 protoID: PrototypeList::ID::HTMLInputElement as u16,
847 },
848 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
849 _bitfield_align_1: [],
850 _bitfield_1: __BindgenBitfieldUnit::new(
851 new_jsjitinfo_bitfield_1!(
852 JSJitInfo_OpType::Getter as u8,
853 JSJitInfo_AliasSet::AliasEverything as u8,
854 JSValueType::JSVAL_TYPE_STRING as u8,
855 true,
856 false,
857 false,
858 false,
859 false,
860 false,
861 0,
862 ).to_ne_bytes()
863 ),
864});
865}
866static formAction_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
867
868pub(crate) fn init_formAction_setterinfo<D: DomTypes>() {
869 formAction_setterinfo.set(JSJitInfo {
870 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
871 setter: Some(set_formAction::<D>)
872 },
873 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
874 protoID: PrototypeList::ID::HTMLInputElement as u16,
875 },
876 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
877 _bitfield_align_1: [],
878 _bitfield_1: __BindgenBitfieldUnit::new(
879 new_jsjitinfo_bitfield_1!(
880 JSJitInfo_OpType::Setter as u8,
881 JSJitInfo_AliasSet::AliasEverything as u8,
882 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
883 false,
884 false,
885 false,
886 false,
887 false,
888 false,
889 0,
890 ).to_ne_bytes()
891 ),
892});
893}
894unsafe extern "C" fn get_formEnctype<D: DomTypes>
895(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
896 let mut result = false;
897 wrap_panic(&mut || result = (|| {
898 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
899 let this = &*(this as *const D::HTMLInputElement);
900 <D as DomHelpers<D>>::push_new_element_queue();
901
902 let result: DOMString = this.FormEnctype();
903 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
904
905
906 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
907 return true;
908 })());
909 result
910}
911
912unsafe extern "C" fn set_formEnctype<D: DomTypes>
913(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
914 let mut result = false;
915 wrap_panic(&mut || result = (|| {
916 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
917 let this = &*(this as *const D::HTMLInputElement);
918 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
919 Ok(ConversionResult::Success(value)) => value,
920 Ok(ConversionResult::Failure(error)) => {
921 throw_type_error(cx.raw_cx(), &error);
922 return false;
923
924 }
925 _ => {
926 return false;
927
928 },
929 }
930 ;
931 <D as DomHelpers<D>>::push_new_element_queue();
932
933 let result: () = this.SetFormEnctype(arg0);
934 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
935
936
937 true
938 })());
939 result
940}
941
942
943static formEnctype_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
944
945pub(crate) fn init_formEnctype_getterinfo<D: DomTypes>() {
946 formEnctype_getterinfo.set(JSJitInfo {
947 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
948 getter: Some(get_formEnctype::<D>)
949 },
950 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
951 protoID: PrototypeList::ID::HTMLInputElement as u16,
952 },
953 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
954 _bitfield_align_1: [],
955 _bitfield_1: __BindgenBitfieldUnit::new(
956 new_jsjitinfo_bitfield_1!(
957 JSJitInfo_OpType::Getter as u8,
958 JSJitInfo_AliasSet::AliasEverything as u8,
959 JSValueType::JSVAL_TYPE_STRING as u8,
960 true,
961 false,
962 false,
963 false,
964 false,
965 false,
966 0,
967 ).to_ne_bytes()
968 ),
969});
970}
971static formEnctype_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
972
973pub(crate) fn init_formEnctype_setterinfo<D: DomTypes>() {
974 formEnctype_setterinfo.set(JSJitInfo {
975 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
976 setter: Some(set_formEnctype::<D>)
977 },
978 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
979 protoID: PrototypeList::ID::HTMLInputElement as u16,
980 },
981 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
982 _bitfield_align_1: [],
983 _bitfield_1: __BindgenBitfieldUnit::new(
984 new_jsjitinfo_bitfield_1!(
985 JSJitInfo_OpType::Setter as u8,
986 JSJitInfo_AliasSet::AliasEverything as u8,
987 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
988 false,
989 false,
990 false,
991 false,
992 false,
993 false,
994 0,
995 ).to_ne_bytes()
996 ),
997});
998}
999unsafe extern "C" fn get_formMethod<D: DomTypes>
1000(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1001 let mut result = false;
1002 wrap_panic(&mut || result = (|| {
1003 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1004 let this = &*(this as *const D::HTMLInputElement);
1005 <D as DomHelpers<D>>::push_new_element_queue();
1006
1007 let result: DOMString = this.FormMethod();
1008 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1009
1010
1011 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1012 return true;
1013 })());
1014 result
1015}
1016
1017unsafe extern "C" fn set_formMethod<D: DomTypes>
1018(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1019 let mut result = false;
1020 wrap_panic(&mut || result = (|| {
1021 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1022 let this = &*(this as *const D::HTMLInputElement);
1023 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1024 Ok(ConversionResult::Success(value)) => value,
1025 Ok(ConversionResult::Failure(error)) => {
1026 throw_type_error(cx.raw_cx(), &error);
1027 return false;
1028
1029 }
1030 _ => {
1031 return false;
1032
1033 },
1034 }
1035 ;
1036 <D as DomHelpers<D>>::push_new_element_queue();
1037
1038 let result: () = this.SetFormMethod(arg0);
1039 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1040
1041
1042 true
1043 })());
1044 result
1045}
1046
1047
1048static formMethod_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1049
1050pub(crate) fn init_formMethod_getterinfo<D: DomTypes>() {
1051 formMethod_getterinfo.set(JSJitInfo {
1052 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1053 getter: Some(get_formMethod::<D>)
1054 },
1055 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1056 protoID: PrototypeList::ID::HTMLInputElement as u16,
1057 },
1058 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1059 _bitfield_align_1: [],
1060 _bitfield_1: __BindgenBitfieldUnit::new(
1061 new_jsjitinfo_bitfield_1!(
1062 JSJitInfo_OpType::Getter as u8,
1063 JSJitInfo_AliasSet::AliasEverything as u8,
1064 JSValueType::JSVAL_TYPE_STRING as u8,
1065 true,
1066 false,
1067 false,
1068 false,
1069 false,
1070 false,
1071 0,
1072 ).to_ne_bytes()
1073 ),
1074});
1075}
1076static formMethod_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1077
1078pub(crate) fn init_formMethod_setterinfo<D: DomTypes>() {
1079 formMethod_setterinfo.set(JSJitInfo {
1080 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1081 setter: Some(set_formMethod::<D>)
1082 },
1083 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1084 protoID: PrototypeList::ID::HTMLInputElement as u16,
1085 },
1086 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1087 _bitfield_align_1: [],
1088 _bitfield_1: __BindgenBitfieldUnit::new(
1089 new_jsjitinfo_bitfield_1!(
1090 JSJitInfo_OpType::Setter as u8,
1091 JSJitInfo_AliasSet::AliasEverything as u8,
1092 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1093 false,
1094 false,
1095 false,
1096 false,
1097 false,
1098 false,
1099 0,
1100 ).to_ne_bytes()
1101 ),
1102});
1103}
1104unsafe extern "C" fn get_formNoValidate<D: DomTypes>
1105(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1106 let mut result = false;
1107 wrap_panic(&mut || result = (|| {
1108 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1109 let this = &*(this as *const D::HTMLInputElement);
1110 <D as DomHelpers<D>>::push_new_element_queue();
1111
1112 let result: bool = this.FormNoValidate();
1113 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1114
1115
1116 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1117 return true;
1118 })());
1119 result
1120}
1121
1122unsafe extern "C" fn set_formNoValidate<D: DomTypes>
1123(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1124 let mut result = false;
1125 wrap_panic(&mut || result = (|| {
1126 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1127 let this = &*(this as *const D::HTMLInputElement);
1128 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1129 Ok(ConversionResult::Success(value)) => value,
1130 Ok(ConversionResult::Failure(error)) => {
1131 throw_type_error(cx.raw_cx(), &error);
1132 return false;
1133
1134 }
1135 _ => {
1136 return false;
1137
1138 },
1139 }
1140 ;
1141 <D as DomHelpers<D>>::push_new_element_queue();
1142
1143 let result: () = this.SetFormNoValidate(arg0);
1144 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1145
1146
1147 true
1148 })());
1149 result
1150}
1151
1152
1153static formNoValidate_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1154
1155pub(crate) fn init_formNoValidate_getterinfo<D: DomTypes>() {
1156 formNoValidate_getterinfo.set(JSJitInfo {
1157 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1158 getter: Some(get_formNoValidate::<D>)
1159 },
1160 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1161 protoID: PrototypeList::ID::HTMLInputElement as u16,
1162 },
1163 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1164 _bitfield_align_1: [],
1165 _bitfield_1: __BindgenBitfieldUnit::new(
1166 new_jsjitinfo_bitfield_1!(
1167 JSJitInfo_OpType::Getter as u8,
1168 JSJitInfo_AliasSet::AliasEverything as u8,
1169 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
1170 true,
1171 false,
1172 false,
1173 false,
1174 false,
1175 false,
1176 0,
1177 ).to_ne_bytes()
1178 ),
1179});
1180}
1181static formNoValidate_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1182
1183pub(crate) fn init_formNoValidate_setterinfo<D: DomTypes>() {
1184 formNoValidate_setterinfo.set(JSJitInfo {
1185 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1186 setter: Some(set_formNoValidate::<D>)
1187 },
1188 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1189 protoID: PrototypeList::ID::HTMLInputElement as u16,
1190 },
1191 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1192 _bitfield_align_1: [],
1193 _bitfield_1: __BindgenBitfieldUnit::new(
1194 new_jsjitinfo_bitfield_1!(
1195 JSJitInfo_OpType::Setter as u8,
1196 JSJitInfo_AliasSet::AliasEverything as u8,
1197 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1198 false,
1199 false,
1200 false,
1201 false,
1202 false,
1203 false,
1204 0,
1205 ).to_ne_bytes()
1206 ),
1207});
1208}
1209unsafe extern "C" fn get_formTarget<D: DomTypes>
1210(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1211 let mut result = false;
1212 wrap_panic(&mut || result = (|| {
1213 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1214 let this = &*(this as *const D::HTMLInputElement);
1215 <D as DomHelpers<D>>::push_new_element_queue();
1216
1217 let result: DOMString = this.FormTarget();
1218 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1219
1220
1221 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1222 return true;
1223 })());
1224 result
1225}
1226
1227unsafe extern "C" fn set_formTarget<D: DomTypes>
1228(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1229 let mut result = false;
1230 wrap_panic(&mut || result = (|| {
1231 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1232 let this = &*(this as *const D::HTMLInputElement);
1233 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1234 Ok(ConversionResult::Success(value)) => value,
1235 Ok(ConversionResult::Failure(error)) => {
1236 throw_type_error(cx.raw_cx(), &error);
1237 return false;
1238
1239 }
1240 _ => {
1241 return false;
1242
1243 },
1244 }
1245 ;
1246 <D as DomHelpers<D>>::push_new_element_queue();
1247
1248 let result: () = this.SetFormTarget(arg0);
1249 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1250
1251
1252 true
1253 })());
1254 result
1255}
1256
1257
1258static formTarget_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1259
1260pub(crate) fn init_formTarget_getterinfo<D: DomTypes>() {
1261 formTarget_getterinfo.set(JSJitInfo {
1262 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1263 getter: Some(get_formTarget::<D>)
1264 },
1265 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1266 protoID: PrototypeList::ID::HTMLInputElement as u16,
1267 },
1268 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1269 _bitfield_align_1: [],
1270 _bitfield_1: __BindgenBitfieldUnit::new(
1271 new_jsjitinfo_bitfield_1!(
1272 JSJitInfo_OpType::Getter as u8,
1273 JSJitInfo_AliasSet::AliasEverything as u8,
1274 JSValueType::JSVAL_TYPE_STRING as u8,
1275 true,
1276 false,
1277 false,
1278 false,
1279 false,
1280 false,
1281 0,
1282 ).to_ne_bytes()
1283 ),
1284});
1285}
1286static formTarget_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1287
1288pub(crate) fn init_formTarget_setterinfo<D: DomTypes>() {
1289 formTarget_setterinfo.set(JSJitInfo {
1290 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1291 setter: Some(set_formTarget::<D>)
1292 },
1293 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1294 protoID: PrototypeList::ID::HTMLInputElement as u16,
1295 },
1296 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1297 _bitfield_align_1: [],
1298 _bitfield_1: __BindgenBitfieldUnit::new(
1299 new_jsjitinfo_bitfield_1!(
1300 JSJitInfo_OpType::Setter as u8,
1301 JSJitInfo_AliasSet::AliasEverything as u8,
1302 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1303 false,
1304 false,
1305 false,
1306 false,
1307 false,
1308 false,
1309 0,
1310 ).to_ne_bytes()
1311 ),
1312});
1313}
1314unsafe extern "C" fn get_indeterminate<D: DomTypes>
1315(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1316 let mut result = false;
1317 wrap_panic(&mut || result = (|| {
1318 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1319 let this = &*(this as *const D::HTMLInputElement);
1320 let result: bool = this.Indeterminate();
1321
1322 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1323 return true;
1324 })());
1325 result
1326}
1327
1328unsafe extern "C" fn set_indeterminate<D: DomTypes>
1329(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1330 let mut result = false;
1331 wrap_panic(&mut || result = (|| {
1332 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1333 let this = &*(this as *const D::HTMLInputElement);
1334 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1335 Ok(ConversionResult::Success(value)) => value,
1336 Ok(ConversionResult::Failure(error)) => {
1337 throw_type_error(cx.raw_cx(), &error);
1338 return false;
1339
1340 }
1341 _ => {
1342 return false;
1343
1344 },
1345 }
1346 ;
1347 let result: () = this.SetIndeterminate(arg0);
1348
1349 true
1350 })());
1351 result
1352}
1353
1354
1355static indeterminate_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1356
1357pub(crate) fn init_indeterminate_getterinfo<D: DomTypes>() {
1358 indeterminate_getterinfo.set(JSJitInfo {
1359 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1360 getter: Some(get_indeterminate::<D>)
1361 },
1362 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1363 protoID: PrototypeList::ID::HTMLInputElement as u16,
1364 },
1365 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1366 _bitfield_align_1: [],
1367 _bitfield_1: __BindgenBitfieldUnit::new(
1368 new_jsjitinfo_bitfield_1!(
1369 JSJitInfo_OpType::Getter as u8,
1370 JSJitInfo_AliasSet::AliasEverything as u8,
1371 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
1372 true,
1373 false,
1374 false,
1375 false,
1376 false,
1377 false,
1378 0,
1379 ).to_ne_bytes()
1380 ),
1381});
1382}
1383static indeterminate_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1384
1385pub(crate) fn init_indeterminate_setterinfo<D: DomTypes>() {
1386 indeterminate_setterinfo.set(JSJitInfo {
1387 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1388 setter: Some(set_indeterminate::<D>)
1389 },
1390 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1391 protoID: PrototypeList::ID::HTMLInputElement as u16,
1392 },
1393 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1394 _bitfield_align_1: [],
1395 _bitfield_1: __BindgenBitfieldUnit::new(
1396 new_jsjitinfo_bitfield_1!(
1397 JSJitInfo_OpType::Setter as u8,
1398 JSJitInfo_AliasSet::AliasEverything as u8,
1399 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1400 false,
1401 false,
1402 false,
1403 false,
1404 false,
1405 false,
1406 0,
1407 ).to_ne_bytes()
1408 ),
1409});
1410}
1411unsafe extern "C" fn get_list<D: DomTypes>
1412(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1413 let mut result = false;
1414 wrap_panic(&mut || result = (|| {
1415 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1416 let this = &*(this as *const D::HTMLInputElement);
1417 let result: Option<DomRoot<D::HTMLDataListElement>> = this.GetList();
1418
1419 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1420 return true;
1421 })());
1422 result
1423}
1424
1425
1426static list_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1427
1428pub(crate) fn init_list_getterinfo<D: DomTypes>() {
1429 list_getterinfo.set(JSJitInfo {
1430 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1431 getter: Some(get_list::<D>)
1432 },
1433 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1434 protoID: PrototypeList::ID::HTMLInputElement as u16,
1435 },
1436 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1437 _bitfield_align_1: [],
1438 _bitfield_1: __BindgenBitfieldUnit::new(
1439 new_jsjitinfo_bitfield_1!(
1440 JSJitInfo_OpType::Getter as u8,
1441 JSJitInfo_AliasSet::AliasEverything as u8,
1442 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
1443 true,
1444 false,
1445 false,
1446 false,
1447 false,
1448 false,
1449 0,
1450 ).to_ne_bytes()
1451 ),
1452});
1453}
1454unsafe extern "C" fn get_max<D: DomTypes>
1455(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1456 let mut result = false;
1457 wrap_panic(&mut || result = (|| {
1458 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1459 let this = &*(this as *const D::HTMLInputElement);
1460 <D as DomHelpers<D>>::push_new_element_queue();
1461
1462 let result: DOMString = this.Max();
1463 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1464
1465
1466 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1467 return true;
1468 })());
1469 result
1470}
1471
1472unsafe extern "C" fn set_max<D: DomTypes>
1473(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1474 let mut result = false;
1475 wrap_panic(&mut || result = (|| {
1476 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1477 let this = &*(this as *const D::HTMLInputElement);
1478 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1479 Ok(ConversionResult::Success(value)) => value,
1480 Ok(ConversionResult::Failure(error)) => {
1481 throw_type_error(cx.raw_cx(), &error);
1482 return false;
1483
1484 }
1485 _ => {
1486 return false;
1487
1488 },
1489 }
1490 ;
1491 <D as DomHelpers<D>>::push_new_element_queue();
1492
1493 let result: () = this.SetMax(arg0);
1494 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1495
1496
1497 true
1498 })());
1499 result
1500}
1501
1502
1503static max_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1504
1505pub(crate) fn init_max_getterinfo<D: DomTypes>() {
1506 max_getterinfo.set(JSJitInfo {
1507 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1508 getter: Some(get_max::<D>)
1509 },
1510 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1511 protoID: PrototypeList::ID::HTMLInputElement as u16,
1512 },
1513 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1514 _bitfield_align_1: [],
1515 _bitfield_1: __BindgenBitfieldUnit::new(
1516 new_jsjitinfo_bitfield_1!(
1517 JSJitInfo_OpType::Getter as u8,
1518 JSJitInfo_AliasSet::AliasEverything as u8,
1519 JSValueType::JSVAL_TYPE_STRING as u8,
1520 true,
1521 false,
1522 false,
1523 false,
1524 false,
1525 false,
1526 0,
1527 ).to_ne_bytes()
1528 ),
1529});
1530}
1531static max_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1532
1533pub(crate) fn init_max_setterinfo<D: DomTypes>() {
1534 max_setterinfo.set(JSJitInfo {
1535 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1536 setter: Some(set_max::<D>)
1537 },
1538 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1539 protoID: PrototypeList::ID::HTMLInputElement as u16,
1540 },
1541 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1542 _bitfield_align_1: [],
1543 _bitfield_1: __BindgenBitfieldUnit::new(
1544 new_jsjitinfo_bitfield_1!(
1545 JSJitInfo_OpType::Setter as u8,
1546 JSJitInfo_AliasSet::AliasEverything as u8,
1547 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1548 false,
1549 false,
1550 false,
1551 false,
1552 false,
1553 false,
1554 0,
1555 ).to_ne_bytes()
1556 ),
1557});
1558}
1559unsafe extern "C" fn get_maxLength<D: DomTypes>
1560(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1561 let mut result = false;
1562 wrap_panic(&mut || result = (|| {
1563 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1564 let this = &*(this as *const D::HTMLInputElement);
1565 <D as DomHelpers<D>>::push_new_element_queue();
1566
1567 let result: i32 = this.MaxLength();
1568 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1569
1570
1571 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1572 return true;
1573 })());
1574 result
1575}
1576
1577unsafe extern "C" fn set_maxLength<D: DomTypes>
1578(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1579 let mut result = false;
1580 wrap_panic(&mut || result = (|| {
1581 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1582 let this = &*(this as *const D::HTMLInputElement);
1583 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1584 Ok(ConversionResult::Success(value)) => value,
1585 Ok(ConversionResult::Failure(error)) => {
1586 throw_type_error(cx.raw_cx(), &error);
1587 return false;
1588
1589 }
1590 _ => {
1591 return false;
1592
1593 },
1594 }
1595 ;
1596 <D as DomHelpers<D>>::push_new_element_queue();
1597
1598 let result: Result<(), Error> = this.SetMaxLength(arg0);
1599 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1600
1601 let result = match result {
1602 Ok(result) => result,
1603 Err(e) => {
1604 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1605 return false;
1606 },
1607 };
1608
1609 true
1610 })());
1611 result
1612}
1613
1614
1615static maxLength_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1616
1617pub(crate) fn init_maxLength_getterinfo<D: DomTypes>() {
1618 maxLength_getterinfo.set(JSJitInfo {
1619 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1620 getter: Some(get_maxLength::<D>)
1621 },
1622 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1623 protoID: PrototypeList::ID::HTMLInputElement as u16,
1624 },
1625 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1626 _bitfield_align_1: [],
1627 _bitfield_1: __BindgenBitfieldUnit::new(
1628 new_jsjitinfo_bitfield_1!(
1629 JSJitInfo_OpType::Getter as u8,
1630 JSJitInfo_AliasSet::AliasEverything as u8,
1631 JSValueType::JSVAL_TYPE_INT32 as u8,
1632 true,
1633 false,
1634 false,
1635 false,
1636 false,
1637 false,
1638 0,
1639 ).to_ne_bytes()
1640 ),
1641});
1642}
1643static maxLength_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1644
1645pub(crate) fn init_maxLength_setterinfo<D: DomTypes>() {
1646 maxLength_setterinfo.set(JSJitInfo {
1647 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1648 setter: Some(set_maxLength::<D>)
1649 },
1650 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1651 protoID: PrototypeList::ID::HTMLInputElement as u16,
1652 },
1653 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1654 _bitfield_align_1: [],
1655 _bitfield_1: __BindgenBitfieldUnit::new(
1656 new_jsjitinfo_bitfield_1!(
1657 JSJitInfo_OpType::Setter as u8,
1658 JSJitInfo_AliasSet::AliasEverything as u8,
1659 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1660 false,
1661 false,
1662 false,
1663 false,
1664 false,
1665 false,
1666 0,
1667 ).to_ne_bytes()
1668 ),
1669});
1670}
1671unsafe extern "C" fn get_min<D: DomTypes>
1672(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1673 let mut result = false;
1674 wrap_panic(&mut || result = (|| {
1675 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1676 let this = &*(this as *const D::HTMLInputElement);
1677 <D as DomHelpers<D>>::push_new_element_queue();
1678
1679 let result: DOMString = this.Min();
1680 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1681
1682
1683 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1684 return true;
1685 })());
1686 result
1687}
1688
1689unsafe extern "C" fn set_min<D: DomTypes>
1690(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1691 let mut result = false;
1692 wrap_panic(&mut || result = (|| {
1693 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1694 let this = &*(this as *const D::HTMLInputElement);
1695 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
1696 Ok(ConversionResult::Success(value)) => value,
1697 Ok(ConversionResult::Failure(error)) => {
1698 throw_type_error(cx.raw_cx(), &error);
1699 return false;
1700
1701 }
1702 _ => {
1703 return false;
1704
1705 },
1706 }
1707 ;
1708 <D as DomHelpers<D>>::push_new_element_queue();
1709
1710 let result: () = this.SetMin(arg0);
1711 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1712
1713
1714 true
1715 })());
1716 result
1717}
1718
1719
1720static min_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1721
1722pub(crate) fn init_min_getterinfo<D: DomTypes>() {
1723 min_getterinfo.set(JSJitInfo {
1724 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1725 getter: Some(get_min::<D>)
1726 },
1727 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1728 protoID: PrototypeList::ID::HTMLInputElement as u16,
1729 },
1730 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1731 _bitfield_align_1: [],
1732 _bitfield_1: __BindgenBitfieldUnit::new(
1733 new_jsjitinfo_bitfield_1!(
1734 JSJitInfo_OpType::Getter as u8,
1735 JSJitInfo_AliasSet::AliasEverything as u8,
1736 JSValueType::JSVAL_TYPE_STRING as u8,
1737 true,
1738 false,
1739 false,
1740 false,
1741 false,
1742 false,
1743 0,
1744 ).to_ne_bytes()
1745 ),
1746});
1747}
1748static min_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1749
1750pub(crate) fn init_min_setterinfo<D: DomTypes>() {
1751 min_setterinfo.set(JSJitInfo {
1752 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1753 setter: Some(set_min::<D>)
1754 },
1755 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1756 protoID: PrototypeList::ID::HTMLInputElement as u16,
1757 },
1758 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1759 _bitfield_align_1: [],
1760 _bitfield_1: __BindgenBitfieldUnit::new(
1761 new_jsjitinfo_bitfield_1!(
1762 JSJitInfo_OpType::Setter as u8,
1763 JSJitInfo_AliasSet::AliasEverything as u8,
1764 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1765 false,
1766 false,
1767 false,
1768 false,
1769 false,
1770 false,
1771 0,
1772 ).to_ne_bytes()
1773 ),
1774});
1775}
1776unsafe extern "C" fn get_minLength<D: DomTypes>
1777(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1778 let mut result = false;
1779 wrap_panic(&mut || result = (|| {
1780 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1781 let this = &*(this as *const D::HTMLInputElement);
1782 <D as DomHelpers<D>>::push_new_element_queue();
1783
1784 let result: i32 = this.MinLength();
1785 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1786
1787
1788 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1789 return true;
1790 })());
1791 result
1792}
1793
1794unsafe extern "C" fn set_minLength<D: DomTypes>
1795(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1796 let mut result = false;
1797 wrap_panic(&mut || result = (|| {
1798 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1799 let this = &*(this as *const D::HTMLInputElement);
1800 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
1801 Ok(ConversionResult::Success(value)) => value,
1802 Ok(ConversionResult::Failure(error)) => {
1803 throw_type_error(cx.raw_cx(), &error);
1804 return false;
1805
1806 }
1807 _ => {
1808 return false;
1809
1810 },
1811 }
1812 ;
1813 <D as DomHelpers<D>>::push_new_element_queue();
1814
1815 let result: Result<(), Error> = this.SetMinLength(arg0);
1816 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1817
1818 let result = match result {
1819 Ok(result) => result,
1820 Err(e) => {
1821 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
1822 return false;
1823 },
1824 };
1825
1826 true
1827 })());
1828 result
1829}
1830
1831
1832static minLength_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1833
1834pub(crate) fn init_minLength_getterinfo<D: DomTypes>() {
1835 minLength_getterinfo.set(JSJitInfo {
1836 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1837 getter: Some(get_minLength::<D>)
1838 },
1839 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1840 protoID: PrototypeList::ID::HTMLInputElement as u16,
1841 },
1842 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1843 _bitfield_align_1: [],
1844 _bitfield_1: __BindgenBitfieldUnit::new(
1845 new_jsjitinfo_bitfield_1!(
1846 JSJitInfo_OpType::Getter as u8,
1847 JSJitInfo_AliasSet::AliasEverything as u8,
1848 JSValueType::JSVAL_TYPE_INT32 as u8,
1849 true,
1850 false,
1851 false,
1852 false,
1853 false,
1854 false,
1855 0,
1856 ).to_ne_bytes()
1857 ),
1858});
1859}
1860static minLength_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1861
1862pub(crate) fn init_minLength_setterinfo<D: DomTypes>() {
1863 minLength_setterinfo.set(JSJitInfo {
1864 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1865 setter: Some(set_minLength::<D>)
1866 },
1867 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1868 protoID: PrototypeList::ID::HTMLInputElement as u16,
1869 },
1870 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1871 _bitfield_align_1: [],
1872 _bitfield_1: __BindgenBitfieldUnit::new(
1873 new_jsjitinfo_bitfield_1!(
1874 JSJitInfo_OpType::Setter as u8,
1875 JSJitInfo_AliasSet::AliasEverything as u8,
1876 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1877 false,
1878 false,
1879 false,
1880 false,
1881 false,
1882 false,
1883 0,
1884 ).to_ne_bytes()
1885 ),
1886});
1887}
1888unsafe extern "C" fn get_multiple<D: DomTypes>
1889(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1890 let mut result = false;
1891 wrap_panic(&mut || result = (|| {
1892 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1893 let this = &*(this as *const D::HTMLInputElement);
1894 <D as DomHelpers<D>>::push_new_element_queue();
1895
1896 let result: bool = this.Multiple();
1897 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1898
1899
1900 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
1901 return true;
1902 })());
1903 result
1904}
1905
1906unsafe extern "C" fn set_multiple<D: DomTypes>
1907(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
1908 let mut result = false;
1909 wrap_panic(&mut || result = (|| {
1910 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1911 let this = &*(this as *const D::HTMLInputElement);
1912 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
1913 Ok(ConversionResult::Success(value)) => value,
1914 Ok(ConversionResult::Failure(error)) => {
1915 throw_type_error(cx.raw_cx(), &error);
1916 return false;
1917
1918 }
1919 _ => {
1920 return false;
1921
1922 },
1923 }
1924 ;
1925 <D as DomHelpers<D>>::push_new_element_queue();
1926
1927 let result: () = this.SetMultiple(arg0);
1928 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
1929
1930
1931 true
1932 })());
1933 result
1934}
1935
1936
1937static multiple_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1938
1939pub(crate) fn init_multiple_getterinfo<D: DomTypes>() {
1940 multiple_getterinfo.set(JSJitInfo {
1941 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1942 getter: Some(get_multiple::<D>)
1943 },
1944 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1945 protoID: PrototypeList::ID::HTMLInputElement as u16,
1946 },
1947 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1948 _bitfield_align_1: [],
1949 _bitfield_1: __BindgenBitfieldUnit::new(
1950 new_jsjitinfo_bitfield_1!(
1951 JSJitInfo_OpType::Getter as u8,
1952 JSJitInfo_AliasSet::AliasEverything as u8,
1953 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
1954 true,
1955 false,
1956 false,
1957 false,
1958 false,
1959 false,
1960 0,
1961 ).to_ne_bytes()
1962 ),
1963});
1964}
1965static multiple_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
1966
1967pub(crate) fn init_multiple_setterinfo<D: DomTypes>() {
1968 multiple_setterinfo.set(JSJitInfo {
1969 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
1970 setter: Some(set_multiple::<D>)
1971 },
1972 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
1973 protoID: PrototypeList::ID::HTMLInputElement as u16,
1974 },
1975 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
1976 _bitfield_align_1: [],
1977 _bitfield_1: __BindgenBitfieldUnit::new(
1978 new_jsjitinfo_bitfield_1!(
1979 JSJitInfo_OpType::Setter as u8,
1980 JSJitInfo_AliasSet::AliasEverything as u8,
1981 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
1982 false,
1983 false,
1984 false,
1985 false,
1986 false,
1987 false,
1988 0,
1989 ).to_ne_bytes()
1990 ),
1991});
1992}
1993unsafe extern "C" fn get_name<D: DomTypes>
1994(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
1995 let mut result = false;
1996 wrap_panic(&mut || result = (|| {
1997 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
1998 let this = &*(this as *const D::HTMLInputElement);
1999 <D as DomHelpers<D>>::push_new_element_queue();
2000
2001 let result: DOMString = this.Name();
2002 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2003
2004
2005 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2006 return true;
2007 })());
2008 result
2009}
2010
2011unsafe extern "C" fn set_name<D: DomTypes>
2012(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2013 let mut result = false;
2014 wrap_panic(&mut || result = (|| {
2015 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2016 let this = &*(this as *const D::HTMLInputElement);
2017 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2018 Ok(ConversionResult::Success(value)) => value,
2019 Ok(ConversionResult::Failure(error)) => {
2020 throw_type_error(cx.raw_cx(), &error);
2021 return false;
2022
2023 }
2024 _ => {
2025 return false;
2026
2027 },
2028 }
2029 ;
2030 <D as DomHelpers<D>>::push_new_element_queue();
2031
2032 let result: () = this.SetName(arg0);
2033 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2034
2035
2036 true
2037 })());
2038 result
2039}
2040
2041
2042static name_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2043
2044pub(crate) fn init_name_getterinfo<D: DomTypes>() {
2045 name_getterinfo.set(JSJitInfo {
2046 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2047 getter: Some(get_name::<D>)
2048 },
2049 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2050 protoID: PrototypeList::ID::HTMLInputElement as u16,
2051 },
2052 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2053 _bitfield_align_1: [],
2054 _bitfield_1: __BindgenBitfieldUnit::new(
2055 new_jsjitinfo_bitfield_1!(
2056 JSJitInfo_OpType::Getter as u8,
2057 JSJitInfo_AliasSet::AliasEverything as u8,
2058 JSValueType::JSVAL_TYPE_STRING as u8,
2059 true,
2060 false,
2061 false,
2062 false,
2063 false,
2064 false,
2065 0,
2066 ).to_ne_bytes()
2067 ),
2068});
2069}
2070static name_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2071
2072pub(crate) fn init_name_setterinfo<D: DomTypes>() {
2073 name_setterinfo.set(JSJitInfo {
2074 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2075 setter: Some(set_name::<D>)
2076 },
2077 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2078 protoID: PrototypeList::ID::HTMLInputElement as u16,
2079 },
2080 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2081 _bitfield_align_1: [],
2082 _bitfield_1: __BindgenBitfieldUnit::new(
2083 new_jsjitinfo_bitfield_1!(
2084 JSJitInfo_OpType::Setter as u8,
2085 JSJitInfo_AliasSet::AliasEverything as u8,
2086 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2087 false,
2088 false,
2089 false,
2090 false,
2091 false,
2092 false,
2093 0,
2094 ).to_ne_bytes()
2095 ),
2096});
2097}
2098unsafe extern "C" fn get_pattern<D: DomTypes>
2099(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2100 let mut result = false;
2101 wrap_panic(&mut || result = (|| {
2102 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2103 let this = &*(this as *const D::HTMLInputElement);
2104 <D as DomHelpers<D>>::push_new_element_queue();
2105
2106 let result: DOMString = this.Pattern();
2107 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2108
2109
2110 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2111 return true;
2112 })());
2113 result
2114}
2115
2116unsafe extern "C" fn set_pattern<D: DomTypes>
2117(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2118 let mut result = false;
2119 wrap_panic(&mut || result = (|| {
2120 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2121 let this = &*(this as *const D::HTMLInputElement);
2122 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2123 Ok(ConversionResult::Success(value)) => value,
2124 Ok(ConversionResult::Failure(error)) => {
2125 throw_type_error(cx.raw_cx(), &error);
2126 return false;
2127
2128 }
2129 _ => {
2130 return false;
2131
2132 },
2133 }
2134 ;
2135 <D as DomHelpers<D>>::push_new_element_queue();
2136
2137 let result: () = this.SetPattern(arg0);
2138 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2139
2140
2141 true
2142 })());
2143 result
2144}
2145
2146
2147static pattern_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2148
2149pub(crate) fn init_pattern_getterinfo<D: DomTypes>() {
2150 pattern_getterinfo.set(JSJitInfo {
2151 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2152 getter: Some(get_pattern::<D>)
2153 },
2154 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2155 protoID: PrototypeList::ID::HTMLInputElement as u16,
2156 },
2157 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2158 _bitfield_align_1: [],
2159 _bitfield_1: __BindgenBitfieldUnit::new(
2160 new_jsjitinfo_bitfield_1!(
2161 JSJitInfo_OpType::Getter as u8,
2162 JSJitInfo_AliasSet::AliasEverything as u8,
2163 JSValueType::JSVAL_TYPE_STRING as u8,
2164 true,
2165 false,
2166 false,
2167 false,
2168 false,
2169 false,
2170 0,
2171 ).to_ne_bytes()
2172 ),
2173});
2174}
2175static pattern_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2176
2177pub(crate) fn init_pattern_setterinfo<D: DomTypes>() {
2178 pattern_setterinfo.set(JSJitInfo {
2179 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2180 setter: Some(set_pattern::<D>)
2181 },
2182 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2183 protoID: PrototypeList::ID::HTMLInputElement as u16,
2184 },
2185 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2186 _bitfield_align_1: [],
2187 _bitfield_1: __BindgenBitfieldUnit::new(
2188 new_jsjitinfo_bitfield_1!(
2189 JSJitInfo_OpType::Setter as u8,
2190 JSJitInfo_AliasSet::AliasEverything as u8,
2191 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2192 false,
2193 false,
2194 false,
2195 false,
2196 false,
2197 false,
2198 0,
2199 ).to_ne_bytes()
2200 ),
2201});
2202}
2203unsafe extern "C" fn get_placeholder<D: DomTypes>
2204(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2205 let mut result = false;
2206 wrap_panic(&mut || result = (|| {
2207 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2208 let this = &*(this as *const D::HTMLInputElement);
2209 <D as DomHelpers<D>>::push_new_element_queue();
2210
2211 let result: DOMString = this.Placeholder();
2212 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2213
2214
2215 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2216 return true;
2217 })());
2218 result
2219}
2220
2221unsafe extern "C" fn set_placeholder<D: DomTypes>
2222(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2223 let mut result = false;
2224 wrap_panic(&mut || result = (|| {
2225 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2226 let this = &*(this as *const D::HTMLInputElement);
2227 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2228 Ok(ConversionResult::Success(value)) => value,
2229 Ok(ConversionResult::Failure(error)) => {
2230 throw_type_error(cx.raw_cx(), &error);
2231 return false;
2232
2233 }
2234 _ => {
2235 return false;
2236
2237 },
2238 }
2239 ;
2240 <D as DomHelpers<D>>::push_new_element_queue();
2241
2242 let result: () = this.SetPlaceholder(arg0);
2243 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2244
2245
2246 true
2247 })());
2248 result
2249}
2250
2251
2252static placeholder_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2253
2254pub(crate) fn init_placeholder_getterinfo<D: DomTypes>() {
2255 placeholder_getterinfo.set(JSJitInfo {
2256 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2257 getter: Some(get_placeholder::<D>)
2258 },
2259 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2260 protoID: PrototypeList::ID::HTMLInputElement as u16,
2261 },
2262 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2263 _bitfield_align_1: [],
2264 _bitfield_1: __BindgenBitfieldUnit::new(
2265 new_jsjitinfo_bitfield_1!(
2266 JSJitInfo_OpType::Getter as u8,
2267 JSJitInfo_AliasSet::AliasEverything as u8,
2268 JSValueType::JSVAL_TYPE_STRING as u8,
2269 true,
2270 false,
2271 false,
2272 false,
2273 false,
2274 false,
2275 0,
2276 ).to_ne_bytes()
2277 ),
2278});
2279}
2280static placeholder_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2281
2282pub(crate) fn init_placeholder_setterinfo<D: DomTypes>() {
2283 placeholder_setterinfo.set(JSJitInfo {
2284 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2285 setter: Some(set_placeholder::<D>)
2286 },
2287 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2288 protoID: PrototypeList::ID::HTMLInputElement as u16,
2289 },
2290 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2291 _bitfield_align_1: [],
2292 _bitfield_1: __BindgenBitfieldUnit::new(
2293 new_jsjitinfo_bitfield_1!(
2294 JSJitInfo_OpType::Setter as u8,
2295 JSJitInfo_AliasSet::AliasEverything as u8,
2296 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2297 false,
2298 false,
2299 false,
2300 false,
2301 false,
2302 false,
2303 0,
2304 ).to_ne_bytes()
2305 ),
2306});
2307}
2308unsafe extern "C" fn get_readOnly<D: DomTypes>
2309(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2310 let mut result = false;
2311 wrap_panic(&mut || result = (|| {
2312 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2313 let this = &*(this as *const D::HTMLInputElement);
2314 <D as DomHelpers<D>>::push_new_element_queue();
2315
2316 let result: bool = this.ReadOnly();
2317 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2318
2319
2320 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2321 return true;
2322 })());
2323 result
2324}
2325
2326unsafe extern "C" fn set_readOnly<D: DomTypes>
2327(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2328 let mut result = false;
2329 wrap_panic(&mut || result = (|| {
2330 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2331 let this = &*(this as *const D::HTMLInputElement);
2332 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
2333 Ok(ConversionResult::Success(value)) => value,
2334 Ok(ConversionResult::Failure(error)) => {
2335 throw_type_error(cx.raw_cx(), &error);
2336 return false;
2337
2338 }
2339 _ => {
2340 return false;
2341
2342 },
2343 }
2344 ;
2345 <D as DomHelpers<D>>::push_new_element_queue();
2346
2347 let result: () = this.SetReadOnly(arg0);
2348 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2349
2350
2351 true
2352 })());
2353 result
2354}
2355
2356
2357static readOnly_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2358
2359pub(crate) fn init_readOnly_getterinfo<D: DomTypes>() {
2360 readOnly_getterinfo.set(JSJitInfo {
2361 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2362 getter: Some(get_readOnly::<D>)
2363 },
2364 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2365 protoID: PrototypeList::ID::HTMLInputElement as u16,
2366 },
2367 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2368 _bitfield_align_1: [],
2369 _bitfield_1: __BindgenBitfieldUnit::new(
2370 new_jsjitinfo_bitfield_1!(
2371 JSJitInfo_OpType::Getter as u8,
2372 JSJitInfo_AliasSet::AliasEverything as u8,
2373 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
2374 true,
2375 false,
2376 false,
2377 false,
2378 false,
2379 false,
2380 0,
2381 ).to_ne_bytes()
2382 ),
2383});
2384}
2385static readOnly_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2386
2387pub(crate) fn init_readOnly_setterinfo<D: DomTypes>() {
2388 readOnly_setterinfo.set(JSJitInfo {
2389 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2390 setter: Some(set_readOnly::<D>)
2391 },
2392 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2393 protoID: PrototypeList::ID::HTMLInputElement as u16,
2394 },
2395 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2396 _bitfield_align_1: [],
2397 _bitfield_1: __BindgenBitfieldUnit::new(
2398 new_jsjitinfo_bitfield_1!(
2399 JSJitInfo_OpType::Setter as u8,
2400 JSJitInfo_AliasSet::AliasEverything as u8,
2401 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2402 false,
2403 false,
2404 false,
2405 false,
2406 false,
2407 false,
2408 0,
2409 ).to_ne_bytes()
2410 ),
2411});
2412}
2413unsafe extern "C" fn get_required<D: DomTypes>
2414(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2415 let mut result = false;
2416 wrap_panic(&mut || result = (|| {
2417 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2418 let this = &*(this as *const D::HTMLInputElement);
2419 <D as DomHelpers<D>>::push_new_element_queue();
2420
2421 let result: bool = this.Required();
2422 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2423
2424
2425 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2426 return true;
2427 })());
2428 result
2429}
2430
2431unsafe extern "C" fn set_required<D: DomTypes>
2432(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2433 let mut result = false;
2434 wrap_panic(&mut || result = (|| {
2435 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2436 let this = &*(this as *const D::HTMLInputElement);
2437 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
2438 Ok(ConversionResult::Success(value)) => value,
2439 Ok(ConversionResult::Failure(error)) => {
2440 throw_type_error(cx.raw_cx(), &error);
2441 return false;
2442
2443 }
2444 _ => {
2445 return false;
2446
2447 },
2448 }
2449 ;
2450 <D as DomHelpers<D>>::push_new_element_queue();
2451
2452 let result: () = this.SetRequired(arg0);
2453 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2454
2455
2456 true
2457 })());
2458 result
2459}
2460
2461
2462static required_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2463
2464pub(crate) fn init_required_getterinfo<D: DomTypes>() {
2465 required_getterinfo.set(JSJitInfo {
2466 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2467 getter: Some(get_required::<D>)
2468 },
2469 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2470 protoID: PrototypeList::ID::HTMLInputElement as u16,
2471 },
2472 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2473 _bitfield_align_1: [],
2474 _bitfield_1: __BindgenBitfieldUnit::new(
2475 new_jsjitinfo_bitfield_1!(
2476 JSJitInfo_OpType::Getter as u8,
2477 JSJitInfo_AliasSet::AliasEverything as u8,
2478 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
2479 true,
2480 false,
2481 false,
2482 false,
2483 false,
2484 false,
2485 0,
2486 ).to_ne_bytes()
2487 ),
2488});
2489}
2490static required_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2491
2492pub(crate) fn init_required_setterinfo<D: DomTypes>() {
2493 required_setterinfo.set(JSJitInfo {
2494 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2495 setter: Some(set_required::<D>)
2496 },
2497 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2498 protoID: PrototypeList::ID::HTMLInputElement as u16,
2499 },
2500 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2501 _bitfield_align_1: [],
2502 _bitfield_1: __BindgenBitfieldUnit::new(
2503 new_jsjitinfo_bitfield_1!(
2504 JSJitInfo_OpType::Setter as u8,
2505 JSJitInfo_AliasSet::AliasEverything as u8,
2506 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2507 false,
2508 false,
2509 false,
2510 false,
2511 false,
2512 false,
2513 0,
2514 ).to_ne_bytes()
2515 ),
2516});
2517}
2518unsafe extern "C" fn get_size<D: DomTypes>
2519(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2520 let mut result = false;
2521 wrap_panic(&mut || result = (|| {
2522 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2523 let this = &*(this as *const D::HTMLInputElement);
2524 <D as DomHelpers<D>>::push_new_element_queue();
2525
2526 let result: u32 = this.Size();
2527 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2528
2529
2530 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2531 return true;
2532 })());
2533 result
2534}
2535
2536unsafe extern "C" fn set_size<D: DomTypes>
2537(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2538 let mut result = false;
2539 wrap_panic(&mut || result = (|| {
2540 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2541 let this = &*(this as *const D::HTMLInputElement);
2542 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2543 Ok(ConversionResult::Success(value)) => value,
2544 Ok(ConversionResult::Failure(error)) => {
2545 throw_type_error(cx.raw_cx(), &error);
2546 return false;
2547
2548 }
2549 _ => {
2550 return false;
2551
2552 },
2553 }
2554 ;
2555 <D as DomHelpers<D>>::push_new_element_queue();
2556
2557 let result: Result<(), Error> = this.SetSize(arg0);
2558 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2559
2560 let result = match result {
2561 Ok(result) => result,
2562 Err(e) => {
2563 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
2564 return false;
2565 },
2566 };
2567
2568 true
2569 })());
2570 result
2571}
2572
2573
2574static size_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2575
2576pub(crate) fn init_size_getterinfo<D: DomTypes>() {
2577 size_getterinfo.set(JSJitInfo {
2578 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2579 getter: Some(get_size::<D>)
2580 },
2581 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2582 protoID: PrototypeList::ID::HTMLInputElement as u16,
2583 },
2584 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2585 _bitfield_align_1: [],
2586 _bitfield_1: __BindgenBitfieldUnit::new(
2587 new_jsjitinfo_bitfield_1!(
2588 JSJitInfo_OpType::Getter as u8,
2589 JSJitInfo_AliasSet::AliasEverything as u8,
2590 JSValueType::JSVAL_TYPE_DOUBLE as u8,
2591 true,
2592 false,
2593 false,
2594 false,
2595 false,
2596 false,
2597 0,
2598 ).to_ne_bytes()
2599 ),
2600});
2601}
2602static size_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2603
2604pub(crate) fn init_size_setterinfo<D: DomTypes>() {
2605 size_setterinfo.set(JSJitInfo {
2606 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2607 setter: Some(set_size::<D>)
2608 },
2609 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2610 protoID: PrototypeList::ID::HTMLInputElement as u16,
2611 },
2612 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2613 _bitfield_align_1: [],
2614 _bitfield_1: __BindgenBitfieldUnit::new(
2615 new_jsjitinfo_bitfield_1!(
2616 JSJitInfo_OpType::Setter as u8,
2617 JSJitInfo_AliasSet::AliasEverything as u8,
2618 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2619 false,
2620 false,
2621 false,
2622 false,
2623 false,
2624 false,
2625 0,
2626 ).to_ne_bytes()
2627 ),
2628});
2629}
2630unsafe extern "C" fn get_src<D: DomTypes>
2631(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2632 let mut result = false;
2633 wrap_panic(&mut || result = (|| {
2634 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2635 let this = &*(this as *const D::HTMLInputElement);
2636 <D as DomHelpers<D>>::push_new_element_queue();
2637
2638 let result: USVString = this.Src();
2639 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2640
2641
2642 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2643 return true;
2644 })());
2645 result
2646}
2647
2648unsafe extern "C" fn set_src<D: DomTypes>
2649(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2650 let mut result = false;
2651 wrap_panic(&mut || result = (|| {
2652 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2653 let this = &*(this as *const D::HTMLInputElement);
2654 let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
2655 Ok(ConversionResult::Success(value)) => value,
2656 Ok(ConversionResult::Failure(error)) => {
2657 throw_type_error(cx.raw_cx(), &error);
2658 return false;
2659
2660 }
2661 _ => {
2662 return false;
2663
2664 },
2665 }
2666 ;
2667 <D as DomHelpers<D>>::push_new_element_queue();
2668
2669 let result: () = this.SetSrc(arg0);
2670 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2671
2672
2673 true
2674 })());
2675 result
2676}
2677
2678
2679static src_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2680
2681pub(crate) fn init_src_getterinfo<D: DomTypes>() {
2682 src_getterinfo.set(JSJitInfo {
2683 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2684 getter: Some(get_src::<D>)
2685 },
2686 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2687 protoID: PrototypeList::ID::HTMLInputElement as u16,
2688 },
2689 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2690 _bitfield_align_1: [],
2691 _bitfield_1: __BindgenBitfieldUnit::new(
2692 new_jsjitinfo_bitfield_1!(
2693 JSJitInfo_OpType::Getter as u8,
2694 JSJitInfo_AliasSet::AliasEverything as u8,
2695 JSValueType::JSVAL_TYPE_STRING as u8,
2696 true,
2697 false,
2698 false,
2699 false,
2700 false,
2701 false,
2702 0,
2703 ).to_ne_bytes()
2704 ),
2705});
2706}
2707static src_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2708
2709pub(crate) fn init_src_setterinfo<D: DomTypes>() {
2710 src_setterinfo.set(JSJitInfo {
2711 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2712 setter: Some(set_src::<D>)
2713 },
2714 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2715 protoID: PrototypeList::ID::HTMLInputElement as u16,
2716 },
2717 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2718 _bitfield_align_1: [],
2719 _bitfield_1: __BindgenBitfieldUnit::new(
2720 new_jsjitinfo_bitfield_1!(
2721 JSJitInfo_OpType::Setter as u8,
2722 JSJitInfo_AliasSet::AliasEverything as u8,
2723 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2724 false,
2725 false,
2726 false,
2727 false,
2728 false,
2729 false,
2730 0,
2731 ).to_ne_bytes()
2732 ),
2733});
2734}
2735unsafe extern "C" fn get_step<D: DomTypes>
2736(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2737 let mut result = false;
2738 wrap_panic(&mut || result = (|| {
2739 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2740 let this = &*(this as *const D::HTMLInputElement);
2741 <D as DomHelpers<D>>::push_new_element_queue();
2742
2743 let result: DOMString = this.Step();
2744 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2745
2746
2747 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2748 return true;
2749 })());
2750 result
2751}
2752
2753unsafe extern "C" fn set_step<D: DomTypes>
2754(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2755 let mut result = false;
2756 wrap_panic(&mut || result = (|| {
2757 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2758 let this = &*(this as *const D::HTMLInputElement);
2759 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2760 Ok(ConversionResult::Success(value)) => value,
2761 Ok(ConversionResult::Failure(error)) => {
2762 throw_type_error(cx.raw_cx(), &error);
2763 return false;
2764
2765 }
2766 _ => {
2767 return false;
2768
2769 },
2770 }
2771 ;
2772 <D as DomHelpers<D>>::push_new_element_queue();
2773
2774 let result: () = this.SetStep(arg0);
2775 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2776
2777
2778 true
2779 })());
2780 result
2781}
2782
2783
2784static step_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2785
2786pub(crate) fn init_step_getterinfo<D: DomTypes>() {
2787 step_getterinfo.set(JSJitInfo {
2788 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2789 getter: Some(get_step::<D>)
2790 },
2791 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2792 protoID: PrototypeList::ID::HTMLInputElement as u16,
2793 },
2794 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2795 _bitfield_align_1: [],
2796 _bitfield_1: __BindgenBitfieldUnit::new(
2797 new_jsjitinfo_bitfield_1!(
2798 JSJitInfo_OpType::Getter as u8,
2799 JSJitInfo_AliasSet::AliasEverything as u8,
2800 JSValueType::JSVAL_TYPE_STRING as u8,
2801 true,
2802 false,
2803 false,
2804 false,
2805 false,
2806 false,
2807 0,
2808 ).to_ne_bytes()
2809 ),
2810});
2811}
2812static step_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2813
2814pub(crate) fn init_step_setterinfo<D: DomTypes>() {
2815 step_setterinfo.set(JSJitInfo {
2816 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2817 setter: Some(set_step::<D>)
2818 },
2819 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2820 protoID: PrototypeList::ID::HTMLInputElement as u16,
2821 },
2822 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2823 _bitfield_align_1: [],
2824 _bitfield_1: __BindgenBitfieldUnit::new(
2825 new_jsjitinfo_bitfield_1!(
2826 JSJitInfo_OpType::Setter as u8,
2827 JSJitInfo_AliasSet::AliasEverything as u8,
2828 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2829 false,
2830 false,
2831 false,
2832 false,
2833 false,
2834 false,
2835 0,
2836 ).to_ne_bytes()
2837 ),
2838});
2839}
2840unsafe extern "C" fn get_type<D: DomTypes>
2841(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2842 let mut result = false;
2843 wrap_panic(&mut || result = (|| {
2844 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2845 let this = &*(this as *const D::HTMLInputElement);
2846 <D as DomHelpers<D>>::push_new_element_queue();
2847
2848 let result: DOMString = this.Type();
2849 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2850
2851
2852 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2853 return true;
2854 })());
2855 result
2856}
2857
2858unsafe extern "C" fn set_type<D: DomTypes>
2859(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2860 let mut result = false;
2861 wrap_panic(&mut || result = (|| {
2862 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2863 let this = &*(this as *const D::HTMLInputElement);
2864 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2865 Ok(ConversionResult::Success(value)) => value,
2866 Ok(ConversionResult::Failure(error)) => {
2867 throw_type_error(cx.raw_cx(), &error);
2868 return false;
2869
2870 }
2871 _ => {
2872 return false;
2873
2874 },
2875 }
2876 ;
2877 <D as DomHelpers<D>>::push_new_element_queue();
2878
2879 let result: () = this.SetType(arg0);
2880 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2881
2882
2883 true
2884 })());
2885 result
2886}
2887
2888
2889static type_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2890
2891pub(crate) fn init_type_getterinfo<D: DomTypes>() {
2892 type_getterinfo.set(JSJitInfo {
2893 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2894 getter: Some(get_type::<D>)
2895 },
2896 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2897 protoID: PrototypeList::ID::HTMLInputElement as u16,
2898 },
2899 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2900 _bitfield_align_1: [],
2901 _bitfield_1: __BindgenBitfieldUnit::new(
2902 new_jsjitinfo_bitfield_1!(
2903 JSJitInfo_OpType::Getter as u8,
2904 JSJitInfo_AliasSet::AliasEverything as u8,
2905 JSValueType::JSVAL_TYPE_STRING as u8,
2906 true,
2907 false,
2908 false,
2909 false,
2910 false,
2911 false,
2912 0,
2913 ).to_ne_bytes()
2914 ),
2915});
2916}
2917static type_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2918
2919pub(crate) fn init_type_setterinfo<D: DomTypes>() {
2920 type_setterinfo.set(JSJitInfo {
2921 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2922 setter: Some(set_type::<D>)
2923 },
2924 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2925 protoID: PrototypeList::ID::HTMLInputElement as u16,
2926 },
2927 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
2928 _bitfield_align_1: [],
2929 _bitfield_1: __BindgenBitfieldUnit::new(
2930 new_jsjitinfo_bitfield_1!(
2931 JSJitInfo_OpType::Setter as u8,
2932 JSJitInfo_AliasSet::AliasEverything as u8,
2933 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2934 false,
2935 false,
2936 false,
2937 false,
2938 false,
2939 false,
2940 0,
2941 ).to_ne_bytes()
2942 ),
2943});
2944}
2945unsafe extern "C" fn get_defaultValue<D: DomTypes>
2946(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2947 let mut result = false;
2948 wrap_panic(&mut || result = (|| {
2949 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2950 let this = &*(this as *const D::HTMLInputElement);
2951 <D as DomHelpers<D>>::push_new_element_queue();
2952
2953 let result: DOMString = this.DefaultValue();
2954 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2955
2956
2957 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2958 return true;
2959 })());
2960 result
2961}
2962
2963unsafe extern "C" fn set_defaultValue<D: DomTypes>
2964(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2965 let mut result = false;
2966 wrap_panic(&mut || result = (|| {
2967 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2968 let this = &*(this as *const D::HTMLInputElement);
2969 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
2970 Ok(ConversionResult::Success(value)) => value,
2971 Ok(ConversionResult::Failure(error)) => {
2972 throw_type_error(cx.raw_cx(), &error);
2973 return false;
2974
2975 }
2976 _ => {
2977 return false;
2978
2979 },
2980 }
2981 ;
2982 <D as DomHelpers<D>>::push_new_element_queue();
2983
2984 let result: () = this.SetDefaultValue(arg0);
2985 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
2986
2987
2988 true
2989 })());
2990 result
2991}
2992
2993
2994static defaultValue_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2995
2996pub(crate) fn init_defaultValue_getterinfo<D: DomTypes>() {
2997 defaultValue_getterinfo.set(JSJitInfo {
2998 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2999 getter: Some(get_defaultValue::<D>)
3000 },
3001 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3002 protoID: PrototypeList::ID::HTMLInputElement as u16,
3003 },
3004 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3005 _bitfield_align_1: [],
3006 _bitfield_1: __BindgenBitfieldUnit::new(
3007 new_jsjitinfo_bitfield_1!(
3008 JSJitInfo_OpType::Getter as u8,
3009 JSJitInfo_AliasSet::AliasEverything as u8,
3010 JSValueType::JSVAL_TYPE_STRING as u8,
3011 true,
3012 false,
3013 false,
3014 false,
3015 false,
3016 false,
3017 0,
3018 ).to_ne_bytes()
3019 ),
3020});
3021}
3022static defaultValue_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3023
3024pub(crate) fn init_defaultValue_setterinfo<D: DomTypes>() {
3025 defaultValue_setterinfo.set(JSJitInfo {
3026 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3027 setter: Some(set_defaultValue::<D>)
3028 },
3029 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3030 protoID: PrototypeList::ID::HTMLInputElement as u16,
3031 },
3032 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3033 _bitfield_align_1: [],
3034 _bitfield_1: __BindgenBitfieldUnit::new(
3035 new_jsjitinfo_bitfield_1!(
3036 JSJitInfo_OpType::Setter as u8,
3037 JSJitInfo_AliasSet::AliasEverything as u8,
3038 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3039 false,
3040 false,
3041 false,
3042 false,
3043 false,
3044 false,
3045 0,
3046 ).to_ne_bytes()
3047 ),
3048});
3049}
3050unsafe extern "C" fn get_value<D: DomTypes>
3051(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3052 let mut result = false;
3053 wrap_panic(&mut || result = (|| {
3054 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3055 let this = &*(this as *const D::HTMLInputElement);
3056 <D as DomHelpers<D>>::push_new_element_queue();
3057
3058 let result: DOMString = this.Value();
3059 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
3060
3061
3062 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3063 return true;
3064 })());
3065 result
3066}
3067
3068unsafe extern "C" fn set_value<D: DomTypes>
3069(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3070 let mut result = false;
3071 wrap_panic(&mut || result = (|| {
3072 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3073 let this = &*(this as *const D::HTMLInputElement);
3074 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Empty) {
3075 Ok(ConversionResult::Success(value)) => value,
3076 Ok(ConversionResult::Failure(error)) => {
3077 throw_type_error(cx.raw_cx(), &error);
3078 return false;
3079
3080 }
3081 _ => {
3082 return false;
3083
3084 },
3085 }
3086 ;
3087 <D as DomHelpers<D>>::push_new_element_queue();
3088
3089 let result: Result<(), Error> = this.SetValue(arg0, CanGc::note());
3090 <D as DomHelpers<D>>::pop_current_element_queue(CanGc::note());
3091
3092 let result = match result {
3093 Ok(result) => result,
3094 Err(e) => {
3095 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3096 return false;
3097 },
3098 };
3099
3100 true
3101 })());
3102 result
3103}
3104
3105
3106static value_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3107
3108pub(crate) fn init_value_getterinfo<D: DomTypes>() {
3109 value_getterinfo.set(JSJitInfo {
3110 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3111 getter: Some(get_value::<D>)
3112 },
3113 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3114 protoID: PrototypeList::ID::HTMLInputElement as u16,
3115 },
3116 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3117 _bitfield_align_1: [],
3118 _bitfield_1: __BindgenBitfieldUnit::new(
3119 new_jsjitinfo_bitfield_1!(
3120 JSJitInfo_OpType::Getter as u8,
3121 JSJitInfo_AliasSet::AliasEverything as u8,
3122 JSValueType::JSVAL_TYPE_STRING as u8,
3123 true,
3124 false,
3125 false,
3126 false,
3127 false,
3128 false,
3129 0,
3130 ).to_ne_bytes()
3131 ),
3132});
3133}
3134static value_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3135
3136pub(crate) fn init_value_setterinfo<D: DomTypes>() {
3137 value_setterinfo.set(JSJitInfo {
3138 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3139 setter: Some(set_value::<D>)
3140 },
3141 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3142 protoID: PrototypeList::ID::HTMLInputElement as u16,
3143 },
3144 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3145 _bitfield_align_1: [],
3146 _bitfield_1: __BindgenBitfieldUnit::new(
3147 new_jsjitinfo_bitfield_1!(
3148 JSJitInfo_OpType::Setter as u8,
3149 JSJitInfo_AliasSet::AliasEverything as u8,
3150 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3151 false,
3152 false,
3153 false,
3154 false,
3155 false,
3156 false,
3157 0,
3158 ).to_ne_bytes()
3159 ),
3160});
3161}
3162unsafe extern "C" fn get_valueAsDate<D: DomTypes>
3163(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3164 let mut result = false;
3165 wrap_panic(&mut || result = (|| {
3166 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3167 let this = &*(this as *const D::HTMLInputElement);
3168 let result: Option<NonNull<JSObject>> = this.GetValueAsDate(SafeJSContext::from_ptr(cx.raw_cx()));
3169
3170 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3171 return true;
3172 })());
3173 result
3174}
3175
3176unsafe extern "C" fn set_valueAsDate<D: DomTypes>
3177(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3178 let mut result = false;
3179 wrap_panic(&mut || result = (|| {
3180 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3181 let this = &*(this as *const D::HTMLInputElement);
3182 let arg0: *mut JSObject = if HandleValue::from_raw(args.get(0)).get().is_object() {
3183 HandleValue::from_raw(args.get(0)).get().to_object()
3184 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
3185 ptr::null_mut()
3186 } else {
3187 throw_type_error(cx.raw_cx(), "Value is not an object.");
3188 return false;
3189
3190 };
3191 let result: Result<(), Error> = this.SetValueAsDate(SafeJSContext::from_ptr(cx.raw_cx()), arg0, CanGc::note());
3192 let result = match result {
3193 Ok(result) => result,
3194 Err(e) => {
3195 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3196 return false;
3197 },
3198 };
3199
3200 true
3201 })());
3202 result
3203}
3204
3205
3206static valueAsDate_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3207
3208pub(crate) fn init_valueAsDate_getterinfo<D: DomTypes>() {
3209 valueAsDate_getterinfo.set(JSJitInfo {
3210 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3211 getter: Some(get_valueAsDate::<D>)
3212 },
3213 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3214 protoID: PrototypeList::ID::HTMLInputElement as u16,
3215 },
3216 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3217 _bitfield_align_1: [],
3218 _bitfield_1: __BindgenBitfieldUnit::new(
3219 new_jsjitinfo_bitfield_1!(
3220 JSJitInfo_OpType::Getter as u8,
3221 JSJitInfo_AliasSet::AliasEverything as u8,
3222 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
3223 true,
3224 false,
3225 false,
3226 false,
3227 false,
3228 false,
3229 0,
3230 ).to_ne_bytes()
3231 ),
3232});
3233}
3234static valueAsDate_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3235
3236pub(crate) fn init_valueAsDate_setterinfo<D: DomTypes>() {
3237 valueAsDate_setterinfo.set(JSJitInfo {
3238 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3239 setter: Some(set_valueAsDate::<D>)
3240 },
3241 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3242 protoID: PrototypeList::ID::HTMLInputElement as u16,
3243 },
3244 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3245 _bitfield_align_1: [],
3246 _bitfield_1: __BindgenBitfieldUnit::new(
3247 new_jsjitinfo_bitfield_1!(
3248 JSJitInfo_OpType::Setter as u8,
3249 JSJitInfo_AliasSet::AliasEverything as u8,
3250 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3251 false,
3252 false,
3253 false,
3254 false,
3255 false,
3256 false,
3257 0,
3258 ).to_ne_bytes()
3259 ),
3260});
3261}
3262unsafe extern "C" fn get_valueAsNumber<D: DomTypes>
3263(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3264 let mut result = false;
3265 wrap_panic(&mut || result = (|| {
3266 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3267 let this = &*(this as *const D::HTMLInputElement);
3268 let result: f64 = this.ValueAsNumber();
3269
3270 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3271 return true;
3272 })());
3273 result
3274}
3275
3276unsafe extern "C" fn set_valueAsNumber<D: DomTypes>
3277(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3278 let mut result = false;
3279 wrap_panic(&mut || result = (|| {
3280 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3281 let this = &*(this as *const D::HTMLInputElement);
3282 let arg0: f64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3283 Ok(ConversionResult::Success(value)) => value,
3284 Ok(ConversionResult::Failure(error)) => {
3285 throw_type_error(cx.raw_cx(), &error);
3286 return false;
3287
3288 }
3289 _ => {
3290 return false;
3291
3292 },
3293 }
3294 ;
3295 let result: Result<(), Error> = this.SetValueAsNumber(arg0, CanGc::note());
3296 let result = match result {
3297 Ok(result) => result,
3298 Err(e) => {
3299 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3300 return false;
3301 },
3302 };
3303
3304 true
3305 })());
3306 result
3307}
3308
3309
3310static valueAsNumber_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3311
3312pub(crate) fn init_valueAsNumber_getterinfo<D: DomTypes>() {
3313 valueAsNumber_getterinfo.set(JSJitInfo {
3314 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3315 getter: Some(get_valueAsNumber::<D>)
3316 },
3317 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3318 protoID: PrototypeList::ID::HTMLInputElement as u16,
3319 },
3320 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3321 _bitfield_align_1: [],
3322 _bitfield_1: __BindgenBitfieldUnit::new(
3323 new_jsjitinfo_bitfield_1!(
3324 JSJitInfo_OpType::Getter as u8,
3325 JSJitInfo_AliasSet::AliasEverything as u8,
3326 JSValueType::JSVAL_TYPE_DOUBLE as u8,
3327 true,
3328 false,
3329 false,
3330 false,
3331 false,
3332 false,
3333 0,
3334 ).to_ne_bytes()
3335 ),
3336});
3337}
3338static valueAsNumber_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3339
3340pub(crate) fn init_valueAsNumber_setterinfo<D: DomTypes>() {
3341 valueAsNumber_setterinfo.set(JSJitInfo {
3342 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3343 setter: Some(set_valueAsNumber::<D>)
3344 },
3345 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3346 protoID: PrototypeList::ID::HTMLInputElement as u16,
3347 },
3348 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3349 _bitfield_align_1: [],
3350 _bitfield_1: __BindgenBitfieldUnit::new(
3351 new_jsjitinfo_bitfield_1!(
3352 JSJitInfo_OpType::Setter as u8,
3353 JSJitInfo_AliasSet::AliasEverything as u8,
3354 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3355 false,
3356 false,
3357 false,
3358 false,
3359 false,
3360 false,
3361 0,
3362 ).to_ne_bytes()
3363 ),
3364});
3365}
3366unsafe extern "C" fn stepUp<D: DomTypes>
3367(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3368 let mut result = false;
3369 wrap_panic(&mut || result = (|| {
3370 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3371 let this = &*(this as *const D::HTMLInputElement);
3372 let args = &*args;
3373 let argc = args.argc_;
3374 let arg0: i32 = if args.get(0).is_undefined() {
3375 1
3376 } else {
3377 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3378 Ok(ConversionResult::Success(value)) => value,
3379 Ok(ConversionResult::Failure(error)) => {
3380 throw_type_error(cx.raw_cx(), &error);
3381 return false;
3382
3383 }
3384 _ => {
3385 return false;
3386
3387 },
3388 }
3389
3390 };
3391 let result: Result<(), Error> = this.StepUp(arg0, CanGc::note());
3392 let result = match result {
3393 Ok(result) => result,
3394 Err(e) => {
3395 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3396 return false;
3397 },
3398 };
3399
3400 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3401 return true;
3402 })());
3403 result
3404}
3405
3406
3407static stepUp_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3408
3409pub(crate) fn init_stepUp_methodinfo<D: DomTypes>() {
3410 stepUp_methodinfo.set(JSJitInfo {
3411 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3412 method: Some(stepUp::<D>)
3413 },
3414 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3415 protoID: PrototypeList::ID::HTMLInputElement as u16,
3416 },
3417 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3418 _bitfield_align_1: [],
3419 _bitfield_1: __BindgenBitfieldUnit::new(
3420 new_jsjitinfo_bitfield_1!(
3421 JSJitInfo_OpType::Method as u8,
3422 JSJitInfo_AliasSet::AliasEverything as u8,
3423 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3424 false,
3425 false,
3426 false,
3427 false,
3428 false,
3429 false,
3430 0,
3431 ).to_ne_bytes()
3432 ),
3433});
3434}
3435unsafe extern "C" fn stepDown<D: DomTypes>
3436(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3437 let mut result = false;
3438 wrap_panic(&mut || result = (|| {
3439 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3440 let this = &*(this as *const D::HTMLInputElement);
3441 let args = &*args;
3442 let argc = args.argc_;
3443 let arg0: i32 = if args.get(0).is_undefined() {
3444 1
3445 } else {
3446 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3447 Ok(ConversionResult::Success(value)) => value,
3448 Ok(ConversionResult::Failure(error)) => {
3449 throw_type_error(cx.raw_cx(), &error);
3450 return false;
3451
3452 }
3453 _ => {
3454 return false;
3455
3456 },
3457 }
3458
3459 };
3460 let result: Result<(), Error> = this.StepDown(arg0, CanGc::note());
3461 let result = match result {
3462 Ok(result) => result,
3463 Err(e) => {
3464 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3465 return false;
3466 },
3467 };
3468
3469 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3470 return true;
3471 })());
3472 result
3473}
3474
3475
3476static stepDown_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3477
3478pub(crate) fn init_stepDown_methodinfo<D: DomTypes>() {
3479 stepDown_methodinfo.set(JSJitInfo {
3480 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3481 method: Some(stepDown::<D>)
3482 },
3483 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3484 protoID: PrototypeList::ID::HTMLInputElement as u16,
3485 },
3486 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3487 _bitfield_align_1: [],
3488 _bitfield_1: __BindgenBitfieldUnit::new(
3489 new_jsjitinfo_bitfield_1!(
3490 JSJitInfo_OpType::Method as u8,
3491 JSJitInfo_AliasSet::AliasEverything as u8,
3492 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3493 false,
3494 false,
3495 false,
3496 false,
3497 false,
3498 false,
3499 0,
3500 ).to_ne_bytes()
3501 ),
3502});
3503}
3504unsafe extern "C" fn get_willValidate<D: DomTypes>
3505(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3506 let mut result = false;
3507 wrap_panic(&mut || result = (|| {
3508 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3509 let this = &*(this as *const D::HTMLInputElement);
3510 let result: bool = this.WillValidate();
3511
3512 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3513 return true;
3514 })());
3515 result
3516}
3517
3518
3519static willValidate_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3520
3521pub(crate) fn init_willValidate_getterinfo<D: DomTypes>() {
3522 willValidate_getterinfo.set(JSJitInfo {
3523 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3524 getter: Some(get_willValidate::<D>)
3525 },
3526 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3527 protoID: PrototypeList::ID::HTMLInputElement as u16,
3528 },
3529 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3530 _bitfield_align_1: [],
3531 _bitfield_1: __BindgenBitfieldUnit::new(
3532 new_jsjitinfo_bitfield_1!(
3533 JSJitInfo_OpType::Getter as u8,
3534 JSJitInfo_AliasSet::AliasEverything as u8,
3535 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
3536 true,
3537 false,
3538 false,
3539 false,
3540 false,
3541 false,
3542 0,
3543 ).to_ne_bytes()
3544 ),
3545});
3546}
3547unsafe extern "C" fn get_validity<D: DomTypes>
3548(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3549 let mut result = false;
3550 wrap_panic(&mut || result = (|| {
3551 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3552 let this = &*(this as *const D::HTMLInputElement);
3553 let result: DomRoot<D::ValidityState> = this.Validity(CanGc::note());
3554
3555 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3556 return true;
3557 })());
3558 result
3559}
3560
3561
3562static validity_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3563
3564pub(crate) fn init_validity_getterinfo<D: DomTypes>() {
3565 validity_getterinfo.set(JSJitInfo {
3566 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3567 getter: Some(get_validity::<D>)
3568 },
3569 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3570 protoID: PrototypeList::ID::HTMLInputElement as u16,
3571 },
3572 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3573 _bitfield_align_1: [],
3574 _bitfield_1: __BindgenBitfieldUnit::new(
3575 new_jsjitinfo_bitfield_1!(
3576 JSJitInfo_OpType::Getter as u8,
3577 JSJitInfo_AliasSet::AliasEverything as u8,
3578 JSValueType::JSVAL_TYPE_OBJECT as u8,
3579 true,
3580 false,
3581 false,
3582 false,
3583 false,
3584 false,
3585 0,
3586 ).to_ne_bytes()
3587 ),
3588});
3589}
3590unsafe extern "C" fn get_validationMessage<D: DomTypes>
3591(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3592 let mut result = false;
3593 wrap_panic(&mut || result = (|| {
3594 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3595 let this = &*(this as *const D::HTMLInputElement);
3596 let result: DOMString = this.ValidationMessage();
3597
3598 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3599 return true;
3600 })());
3601 result
3602}
3603
3604
3605static validationMessage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3606
3607pub(crate) fn init_validationMessage_getterinfo<D: DomTypes>() {
3608 validationMessage_getterinfo.set(JSJitInfo {
3609 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3610 getter: Some(get_validationMessage::<D>)
3611 },
3612 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3613 protoID: PrototypeList::ID::HTMLInputElement as u16,
3614 },
3615 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3616 _bitfield_align_1: [],
3617 _bitfield_1: __BindgenBitfieldUnit::new(
3618 new_jsjitinfo_bitfield_1!(
3619 JSJitInfo_OpType::Getter as u8,
3620 JSJitInfo_AliasSet::AliasEverything as u8,
3621 JSValueType::JSVAL_TYPE_STRING as u8,
3622 true,
3623 false,
3624 false,
3625 false,
3626 false,
3627 false,
3628 0,
3629 ).to_ne_bytes()
3630 ),
3631});
3632}
3633unsafe extern "C" fn checkValidity<D: DomTypes>
3634(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3635 let mut result = false;
3636 wrap_panic(&mut || result = (|| {
3637 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3638 let this = &*(this as *const D::HTMLInputElement);
3639 let args = &*args;
3640 let argc = args.argc_;
3641 let result: bool = this.CheckValidity(CanGc::note());
3642
3643 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3644 return true;
3645 })());
3646 result
3647}
3648
3649
3650static checkValidity_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3651
3652pub(crate) fn init_checkValidity_methodinfo<D: DomTypes>() {
3653 checkValidity_methodinfo.set(JSJitInfo {
3654 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3655 method: Some(checkValidity::<D>)
3656 },
3657 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3658 protoID: PrototypeList::ID::HTMLInputElement as u16,
3659 },
3660 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3661 _bitfield_align_1: [],
3662 _bitfield_1: __BindgenBitfieldUnit::new(
3663 new_jsjitinfo_bitfield_1!(
3664 JSJitInfo_OpType::Method as u8,
3665 JSJitInfo_AliasSet::AliasEverything as u8,
3666 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
3667 true,
3668 false,
3669 false,
3670 false,
3671 false,
3672 false,
3673 0,
3674 ).to_ne_bytes()
3675 ),
3676});
3677}
3678unsafe extern "C" fn reportValidity<D: DomTypes>
3679(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3680 let mut result = false;
3681 wrap_panic(&mut || result = (|| {
3682 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3683 let this = &*(this as *const D::HTMLInputElement);
3684 let args = &*args;
3685 let argc = args.argc_;
3686 let result: bool = this.ReportValidity(CanGc::note());
3687
3688 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3689 return true;
3690 })());
3691 result
3692}
3693
3694
3695static reportValidity_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3696
3697pub(crate) fn init_reportValidity_methodinfo<D: DomTypes>() {
3698 reportValidity_methodinfo.set(JSJitInfo {
3699 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3700 method: Some(reportValidity::<D>)
3701 },
3702 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3703 protoID: PrototypeList::ID::HTMLInputElement as u16,
3704 },
3705 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3706 _bitfield_align_1: [],
3707 _bitfield_1: __BindgenBitfieldUnit::new(
3708 new_jsjitinfo_bitfield_1!(
3709 JSJitInfo_OpType::Method as u8,
3710 JSJitInfo_AliasSet::AliasEverything as u8,
3711 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
3712 true,
3713 false,
3714 false,
3715 false,
3716 false,
3717 false,
3718 0,
3719 ).to_ne_bytes()
3720 ),
3721});
3722}
3723unsafe extern "C" fn setCustomValidity<D: DomTypes>
3724(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3725 let mut result = false;
3726 wrap_panic(&mut || result = (|| {
3727 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3728 let this = &*(this as *const D::HTMLInputElement);
3729 let args = &*args;
3730 let argc = args.argc_;
3731
3732 if argc < 1 {
3733 throw_type_error(cx.raw_cx(), "Not enough arguments to \"HTMLInputElement.setCustomValidity\".");
3734 return false;
3735 }
3736 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
3737 Ok(ConversionResult::Success(value)) => value,
3738 Ok(ConversionResult::Failure(error)) => {
3739 throw_type_error(cx.raw_cx(), &error);
3740 return false;
3741
3742 }
3743 _ => {
3744 return false;
3745
3746 },
3747 }
3748 ;
3749 let result: () = this.SetCustomValidity(arg0, CanGc::note());
3750
3751 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3752 return true;
3753 })());
3754 result
3755}
3756
3757
3758static setCustomValidity_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3759
3760pub(crate) fn init_setCustomValidity_methodinfo<D: DomTypes>() {
3761 setCustomValidity_methodinfo.set(JSJitInfo {
3762 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3763 method: Some(setCustomValidity::<D>)
3764 },
3765 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3766 protoID: PrototypeList::ID::HTMLInputElement as u16,
3767 },
3768 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3769 _bitfield_align_1: [],
3770 _bitfield_1: __BindgenBitfieldUnit::new(
3771 new_jsjitinfo_bitfield_1!(
3772 JSJitInfo_OpType::Method as u8,
3773 JSJitInfo_AliasSet::AliasEverything as u8,
3774 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3775 false,
3776 false,
3777 false,
3778 false,
3779 false,
3780 false,
3781 0,
3782 ).to_ne_bytes()
3783 ),
3784});
3785}
3786unsafe extern "C" fn get_labels<D: DomTypes>
3787(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3788 let mut result = false;
3789 wrap_panic(&mut || result = (|| {
3790 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3791 let this = &*(this as *const D::HTMLInputElement);
3792 let result: Option<DomRoot<D::NodeList>> = this.GetLabels(CanGc::note());
3793
3794 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3795 return true;
3796 })());
3797 result
3798}
3799
3800
3801static labels_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3802
3803pub(crate) fn init_labels_getterinfo<D: DomTypes>() {
3804 labels_getterinfo.set(JSJitInfo {
3805 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3806 getter: Some(get_labels::<D>)
3807 },
3808 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3809 protoID: PrototypeList::ID::HTMLInputElement as u16,
3810 },
3811 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3812 _bitfield_align_1: [],
3813 _bitfield_1: __BindgenBitfieldUnit::new(
3814 new_jsjitinfo_bitfield_1!(
3815 JSJitInfo_OpType::Getter as u8,
3816 JSJitInfo_AliasSet::AliasEverything as u8,
3817 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
3818 true,
3819 false,
3820 false,
3821 false,
3822 false,
3823 false,
3824 0,
3825 ).to_ne_bytes()
3826 ),
3827});
3828}
3829unsafe extern "C" fn select<D: DomTypes>
3830(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
3831 let mut result = false;
3832 wrap_panic(&mut || result = (|| {
3833 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3834 let this = &*(this as *const D::HTMLInputElement);
3835 let args = &*args;
3836 let argc = args.argc_;
3837 let result: () = this.Select();
3838
3839 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3840 return true;
3841 })());
3842 result
3843}
3844
3845
3846static select_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3847
3848pub(crate) fn init_select_methodinfo<D: DomTypes>() {
3849 select_methodinfo.set(JSJitInfo {
3850 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3851 method: Some(select::<D>)
3852 },
3853 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3854 protoID: PrototypeList::ID::HTMLInputElement as u16,
3855 },
3856 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3857 _bitfield_align_1: [],
3858 _bitfield_1: __BindgenBitfieldUnit::new(
3859 new_jsjitinfo_bitfield_1!(
3860 JSJitInfo_OpType::Method as u8,
3861 JSJitInfo_AliasSet::AliasEverything as u8,
3862 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3863 true,
3864 false,
3865 false,
3866 false,
3867 false,
3868 false,
3869 0,
3870 ).to_ne_bytes()
3871 ),
3872});
3873}
3874unsafe extern "C" fn get_selectionStart<D: DomTypes>
3875(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3876 let mut result = false;
3877 wrap_panic(&mut || result = (|| {
3878 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3879 let this = &*(this as *const D::HTMLInputElement);
3880 let result: Option<u32> = this.GetSelectionStart();
3881
3882 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3883 return true;
3884 })());
3885 result
3886}
3887
3888unsafe extern "C" fn set_selectionStart<D: DomTypes>
3889(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3890 let mut result = false;
3891 wrap_panic(&mut || result = (|| {
3892 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3893 let this = &*(this as *const D::HTMLInputElement);
3894 let arg0: Option<u32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3895 Ok(ConversionResult::Success(value)) => value,
3896 Ok(ConversionResult::Failure(error)) => {
3897 throw_type_error(cx.raw_cx(), &error);
3898 return false;
3899
3900 }
3901 _ => {
3902 return false;
3903
3904 },
3905 }
3906 ;
3907 let result: Result<(), Error> = this.SetSelectionStart(arg0);
3908 let result = match result {
3909 Ok(result) => result,
3910 Err(e) => {
3911 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
3912 return false;
3913 },
3914 };
3915
3916 true
3917 })());
3918 result
3919}
3920
3921
3922static selectionStart_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3923
3924pub(crate) fn init_selectionStart_getterinfo<D: DomTypes>() {
3925 selectionStart_getterinfo.set(JSJitInfo {
3926 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3927 getter: Some(get_selectionStart::<D>)
3928 },
3929 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3930 protoID: PrototypeList::ID::HTMLInputElement as u16,
3931 },
3932 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3933 _bitfield_align_1: [],
3934 _bitfield_1: __BindgenBitfieldUnit::new(
3935 new_jsjitinfo_bitfield_1!(
3936 JSJitInfo_OpType::Getter as u8,
3937 JSJitInfo_AliasSet::AliasEverything as u8,
3938 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
3939 true,
3940 false,
3941 false,
3942 false,
3943 false,
3944 false,
3945 0,
3946 ).to_ne_bytes()
3947 ),
3948});
3949}
3950static selectionStart_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3951
3952pub(crate) fn init_selectionStart_setterinfo<D: DomTypes>() {
3953 selectionStart_setterinfo.set(JSJitInfo {
3954 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3955 setter: Some(set_selectionStart::<D>)
3956 },
3957 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3958 protoID: PrototypeList::ID::HTMLInputElement as u16,
3959 },
3960 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
3961 _bitfield_align_1: [],
3962 _bitfield_1: __BindgenBitfieldUnit::new(
3963 new_jsjitinfo_bitfield_1!(
3964 JSJitInfo_OpType::Setter as u8,
3965 JSJitInfo_AliasSet::AliasEverything as u8,
3966 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3967 false,
3968 false,
3969 false,
3970 false,
3971 false,
3972 false,
3973 0,
3974 ).to_ne_bytes()
3975 ),
3976});
3977}
3978unsafe extern "C" fn get_selectionEnd<D: DomTypes>
3979(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3980 let mut result = false;
3981 wrap_panic(&mut || result = (|| {
3982 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3983 let this = &*(this as *const D::HTMLInputElement);
3984 let result: Option<u32> = this.GetSelectionEnd();
3985
3986 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3987 return true;
3988 })());
3989 result
3990}
3991
3992unsafe extern "C" fn set_selectionEnd<D: DomTypes>
3993(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3994 let mut result = false;
3995 wrap_panic(&mut || result = (|| {
3996 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3997 let this = &*(this as *const D::HTMLInputElement);
3998 let arg0: Option<u32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3999 Ok(ConversionResult::Success(value)) => value,
4000 Ok(ConversionResult::Failure(error)) => {
4001 throw_type_error(cx.raw_cx(), &error);
4002 return false;
4003
4004 }
4005 _ => {
4006 return false;
4007
4008 },
4009 }
4010 ;
4011 let result: Result<(), Error> = this.SetSelectionEnd(arg0);
4012 let result = match result {
4013 Ok(result) => result,
4014 Err(e) => {
4015 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
4016 return false;
4017 },
4018 };
4019
4020 true
4021 })());
4022 result
4023}
4024
4025
4026static selectionEnd_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4027
4028pub(crate) fn init_selectionEnd_getterinfo<D: DomTypes>() {
4029 selectionEnd_getterinfo.set(JSJitInfo {
4030 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4031 getter: Some(get_selectionEnd::<D>)
4032 },
4033 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4034 protoID: PrototypeList::ID::HTMLInputElement as u16,
4035 },
4036 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
4037 _bitfield_align_1: [],
4038 _bitfield_1: __BindgenBitfieldUnit::new(
4039 new_jsjitinfo_bitfield_1!(
4040 JSJitInfo_OpType::Getter as u8,
4041 JSJitInfo_AliasSet::AliasEverything as u8,
4042 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4043 true,
4044 false,
4045 false,
4046 false,
4047 false,
4048 false,
4049 0,
4050 ).to_ne_bytes()
4051 ),
4052});
4053}
4054static selectionEnd_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4055
4056pub(crate) fn init_selectionEnd_setterinfo<D: DomTypes>() {
4057 selectionEnd_setterinfo.set(JSJitInfo {
4058 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4059 setter: Some(set_selectionEnd::<D>)
4060 },
4061 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4062 protoID: PrototypeList::ID::HTMLInputElement as u16,
4063 },
4064 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
4065 _bitfield_align_1: [],
4066 _bitfield_1: __BindgenBitfieldUnit::new(
4067 new_jsjitinfo_bitfield_1!(
4068 JSJitInfo_OpType::Setter as u8,
4069 JSJitInfo_AliasSet::AliasEverything as u8,
4070 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4071 false,
4072 false,
4073 false,
4074 false,
4075 false,
4076 false,
4077 0,
4078 ).to_ne_bytes()
4079 ),
4080});
4081}
4082unsafe extern "C" fn get_selectionDirection<D: DomTypes>
4083(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4084 let mut result = false;
4085 wrap_panic(&mut || result = (|| {
4086 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4087 let this = &*(this as *const D::HTMLInputElement);
4088 let result: Option<DOMString> = this.GetSelectionDirection();
4089
4090 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4091 return true;
4092 })());
4093 result
4094}
4095
4096unsafe extern "C" fn set_selectionDirection<D: DomTypes>
4097(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4098 let mut result = false;
4099 wrap_panic(&mut || result = (|| {
4100 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4101 let this = &*(this as *const D::HTMLInputElement);
4102 let arg0: Option<DOMString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
4103 Ok(ConversionResult::Success(value)) => value,
4104 Ok(ConversionResult::Failure(error)) => {
4105 throw_type_error(cx.raw_cx(), &error);
4106 return false;
4107
4108 }
4109 _ => {
4110 return false;
4111
4112 },
4113 }
4114 ;
4115 let result: Result<(), Error> = this.SetSelectionDirection(arg0);
4116 let result = match result {
4117 Ok(result) => result,
4118 Err(e) => {
4119 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
4120 return false;
4121 },
4122 };
4123
4124 true
4125 })());
4126 result
4127}
4128
4129
4130static selectionDirection_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4131
4132pub(crate) fn init_selectionDirection_getterinfo<D: DomTypes>() {
4133 selectionDirection_getterinfo.set(JSJitInfo {
4134 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4135 getter: Some(get_selectionDirection::<D>)
4136 },
4137 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4138 protoID: PrototypeList::ID::HTMLInputElement as u16,
4139 },
4140 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
4141 _bitfield_align_1: [],
4142 _bitfield_1: __BindgenBitfieldUnit::new(
4143 new_jsjitinfo_bitfield_1!(
4144 JSJitInfo_OpType::Getter as u8,
4145 JSJitInfo_AliasSet::AliasEverything as u8,
4146 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4147 true,
4148 false,
4149 false,
4150 false,
4151 false,
4152 false,
4153 0,
4154 ).to_ne_bytes()
4155 ),
4156});
4157}
4158static selectionDirection_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4159
4160pub(crate) fn init_selectionDirection_setterinfo<D: DomTypes>() {
4161 selectionDirection_setterinfo.set(JSJitInfo {
4162 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4163 setter: Some(set_selectionDirection::<D>)
4164 },
4165 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4166 protoID: PrototypeList::ID::HTMLInputElement as u16,
4167 },
4168 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
4169 _bitfield_align_1: [],
4170 _bitfield_1: __BindgenBitfieldUnit::new(
4171 new_jsjitinfo_bitfield_1!(
4172 JSJitInfo_OpType::Setter as u8,
4173 JSJitInfo_AliasSet::AliasEverything as u8,
4174 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4175 false,
4176 false,
4177 false,
4178 false,
4179 false,
4180 false,
4181 0,
4182 ).to_ne_bytes()
4183 ),
4184});
4185}
4186unsafe extern "C" fn setRangeText<D: DomTypes>
4187(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4188 let mut result = false;
4189 wrap_panic(&mut || result = (|| {
4190 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4191 let this = &*(this as *const D::HTMLInputElement);
4192 let args = &*args;
4193 let argc = args.argc_;
4194
4195 let argcount = cmp::min(argc, 4);
4196 match argcount {
4197 1 => {
4198 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
4199 Ok(ConversionResult::Success(value)) => value,
4200 Ok(ConversionResult::Failure(error)) => {
4201 throw_type_error(cx.raw_cx(), &error);
4202 return false;
4203
4204 }
4205 _ => {
4206 return false;
4207
4208 },
4209 }
4210 ;
4211 let result: Result<(), Error> = this.SetRangeText(arg0);
4212 let result = match result {
4213 Ok(result) => result,
4214 Err(e) => {
4215 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
4216 return false;
4217 },
4218 };
4219
4220 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4221 return true;
4222 }
4223 3 => {
4224 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
4225 Ok(ConversionResult::Success(value)) => value,
4226 Ok(ConversionResult::Failure(error)) => {
4227 throw_type_error(cx.raw_cx(), &error);
4228 return false;
4229
4230 }
4231 _ => {
4232 return false;
4233
4234 },
4235 }
4236 ;
4237 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4238 Ok(ConversionResult::Success(value)) => value,
4239 Ok(ConversionResult::Failure(error)) => {
4240 throw_type_error(cx.raw_cx(), &error);
4241 return false;
4242
4243 }
4244 _ => {
4245 return false;
4246
4247 },
4248 }
4249 ;
4250 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
4251 Ok(ConversionResult::Success(value)) => value,
4252 Ok(ConversionResult::Failure(error)) => {
4253 throw_type_error(cx.raw_cx(), &error);
4254 return false;
4255
4256 }
4257 _ => {
4258 return false;
4259
4260 },
4261 }
4262 ;
4263 let arg3: SelectionMode = if args.get(3).is_undefined() {
4264 SelectionMode::Preserve
4265 } else {
4266 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
4267 Ok(ConversionResult::Success(value)) => value,
4268 Ok(ConversionResult::Failure(error)) => {
4269 throw_type_error(cx.raw_cx(), &error); return false;
4270
4271 }
4272 _ => {
4273 return false;
4274
4275 },
4276 }
4277
4278 };
4279 let result: Result<(), Error> = this.SetRangeText_(arg0, arg1, arg2, arg3);
4280 let result = match result {
4281 Ok(result) => result,
4282 Err(e) => {
4283 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
4284 return false;
4285 },
4286 };
4287
4288 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4289 return true;
4290 }
4291 4 => {
4292 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
4293 Ok(ConversionResult::Success(value)) => value,
4294 Ok(ConversionResult::Failure(error)) => {
4295 throw_type_error(cx.raw_cx(), &error);
4296 return false;
4297
4298 }
4299 _ => {
4300 return false;
4301
4302 },
4303 }
4304 ;
4305 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4306 Ok(ConversionResult::Success(value)) => value,
4307 Ok(ConversionResult::Failure(error)) => {
4308 throw_type_error(cx.raw_cx(), &error);
4309 return false;
4310
4311 }
4312 _ => {
4313 return false;
4314
4315 },
4316 }
4317 ;
4318 let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
4319 Ok(ConversionResult::Success(value)) => value,
4320 Ok(ConversionResult::Failure(error)) => {
4321 throw_type_error(cx.raw_cx(), &error);
4322 return false;
4323
4324 }
4325 _ => {
4326 return false;
4327
4328 },
4329 }
4330 ;
4331 let arg3: SelectionMode = if args.get(3).is_undefined() {
4332 SelectionMode::Preserve
4333 } else {
4334 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
4335 Ok(ConversionResult::Success(value)) => value,
4336 Ok(ConversionResult::Failure(error)) => {
4337 throw_type_error(cx.raw_cx(), &error); return false;
4338
4339 }
4340 _ => {
4341 return false;
4342
4343 },
4344 }
4345
4346 };
4347 let result: Result<(), Error> = this.SetRangeText_(arg0, arg1, arg2, arg3);
4348 let result = match result {
4349 Ok(result) => result,
4350 Err(e) => {
4351 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
4352 return false;
4353 },
4354 };
4355
4356 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4357 return true;
4358 }
4359 _ => {
4360 throw_type_error(cx.raw_cx(), "Not enough arguments to \"HTMLInputElement.setRangeText\".");
4361 return false;
4362 }
4363 }
4364 })());
4365 result
4366}
4367
4368
4369static setRangeText_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4370
4371pub(crate) fn init_setRangeText_methodinfo<D: DomTypes>() {
4372 setRangeText_methodinfo.set(JSJitInfo {
4373 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4374 method: Some(setRangeText::<D>)
4375 },
4376 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4377 protoID: PrototypeList::ID::HTMLInputElement as u16,
4378 },
4379 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
4380 _bitfield_align_1: [],
4381 _bitfield_1: __BindgenBitfieldUnit::new(
4382 new_jsjitinfo_bitfield_1!(
4383 JSJitInfo_OpType::Method as u8,
4384 JSJitInfo_AliasSet::AliasEverything as u8,
4385 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4386 false,
4387 false,
4388 false,
4389 false,
4390 false,
4391 false,
4392 0,
4393 ).to_ne_bytes()
4394 ),
4395});
4396}
4397unsafe extern "C" fn setSelectionRange<D: DomTypes>
4398(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4399 let mut result = false;
4400 wrap_panic(&mut || result = (|| {
4401 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4402 let this = &*(this as *const D::HTMLInputElement);
4403 let args = &*args;
4404 let argc = args.argc_;
4405
4406 if argc < 2 {
4407 throw_type_error(cx.raw_cx(), "Not enough arguments to \"HTMLInputElement.setSelectionRange\".");
4408 return false;
4409 }
4410 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
4411 Ok(ConversionResult::Success(value)) => value,
4412 Ok(ConversionResult::Failure(error)) => {
4413 throw_type_error(cx.raw_cx(), &error);
4414 return false;
4415
4416 }
4417 _ => {
4418 return false;
4419
4420 },
4421 }
4422 ;
4423 let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
4424 Ok(ConversionResult::Success(value)) => value,
4425 Ok(ConversionResult::Failure(error)) => {
4426 throw_type_error(cx.raw_cx(), &error);
4427 return false;
4428
4429 }
4430 _ => {
4431 return false;
4432
4433 },
4434 }
4435 ;
4436 let arg2: Option<DOMString> = if args.get(2).is_undefined() {
4437 None
4438 } else {
4439 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), StringificationBehavior::Default) {
4440 Ok(ConversionResult::Success(value)) => value,
4441 Ok(ConversionResult::Failure(error)) => {
4442 throw_type_error(cx.raw_cx(), &error);
4443 return false;
4444
4445 }
4446 _ => {
4447 return false;
4448
4449 },
4450 }
4451 )
4452 };
4453 let result: Result<(), Error> = this.SetSelectionRange(arg0, arg1, arg2);
4454 let result = match result {
4455 Ok(result) => result,
4456 Err(e) => {
4457 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
4458 return false;
4459 },
4460 };
4461
4462 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4463 return true;
4464 })());
4465 result
4466}
4467
4468
4469static setSelectionRange_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4470
4471pub(crate) fn init_setSelectionRange_methodinfo<D: DomTypes>() {
4472 setSelectionRange_methodinfo.set(JSJitInfo {
4473 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4474 method: Some(setSelectionRange::<D>)
4475 },
4476 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4477 protoID: PrototypeList::ID::HTMLInputElement as u16,
4478 },
4479 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
4480 _bitfield_align_1: [],
4481 _bitfield_1: __BindgenBitfieldUnit::new(
4482 new_jsjitinfo_bitfield_1!(
4483 JSJitInfo_OpType::Method as u8,
4484 JSJitInfo_AliasSet::AliasEverything as u8,
4485 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4486 false,
4487 false,
4488 false,
4489 false,
4490 false,
4491 false,
4492 0,
4493 ).to_ne_bytes()
4494 ),
4495});
4496}
4497unsafe extern "C" fn selectFiles<D: DomTypes>
4498(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
4499 let mut result = false;
4500 wrap_panic(&mut || result = (|| {
4501 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4502 let this = &*(this as *const D::HTMLInputElement);
4503 let args = &*args;
4504 let argc = args.argc_;
4505
4506 if argc < 1 {
4507 throw_type_error(cx.raw_cx(), "Not enough arguments to \"HTMLInputElement.selectFiles\".");
4508 return false;
4509 }
4510 let arg0: Vec<DOMString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
4511 Ok(ConversionResult::Success(value)) => value,
4512 Ok(ConversionResult::Failure(error)) => {
4513 throw_type_error(cx.raw_cx(), &error);
4514 return false;
4515
4516 }
4517 _ => {
4518 return false;
4519
4520 },
4521 }
4522 ;
4523 let result: () = this.SelectFiles(arg0);
4524
4525 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4526 return true;
4527 })());
4528 result
4529}
4530
4531
4532static selectFiles_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4533
4534pub(crate) fn init_selectFiles_methodinfo<D: DomTypes>() {
4535 selectFiles_methodinfo.set(JSJitInfo {
4536 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4537 method: Some(selectFiles::<D>)
4538 },
4539 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4540 protoID: PrototypeList::ID::HTMLInputElement as u16,
4541 },
4542 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 4 },
4543 _bitfield_align_1: [],
4544 _bitfield_1: __BindgenBitfieldUnit::new(
4545 new_jsjitinfo_bitfield_1!(
4546 JSJitInfo_OpType::Method as u8,
4547 JSJitInfo_AliasSet::AliasEverything as u8,
4548 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4549 false,
4550 false,
4551 false,
4552 false,
4553 false,
4554 false,
4555 0,
4556 ).to_ne_bytes()
4557 ),
4558});
4559}
4560unsafe extern "C" fn _finalize<D: DomTypes>
4561(_cx: *mut GCContext, obj: *mut JSObject){
4562 wrap_panic(&mut || {
4563
4564 let this = native_from_object_static::<D::HTMLInputElement>(obj).unwrap();
4565 finalize_common(this);
4566 })
4567}
4568
4569unsafe extern "C" fn _trace<D: DomTypes>
4570(trc: *mut JSTracer, obj: *mut JSObject){
4571 wrap_panic(&mut || {
4572
4573 let this = native_from_object_static::<D::HTMLInputElement>(obj).unwrap();
4574 if this.is_null() { return; } (*this).trace(trc);
4576 })
4577}
4578
4579
4580static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();
4581
4582pub(crate) fn init_class_ops<D: DomTypes>() {
4583 CLASS_OPS.set(JSClassOps {
4584 addProperty: None,
4585 delProperty: None,
4586 enumerate: None,
4587 newEnumerate: None,
4588 resolve: None,
4589 mayResolve: None,
4590 finalize: Some(_finalize::<D>),
4591 call: None,
4592 construct: None,
4593 trace: Some(_trace::<D>),
4594 });
4595}
4596
4597pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();
4598
4599pub(crate) fn init_domjs_class<D: DomTypes>() {
4600 init_class_ops::<D>();
4601 Class.set(DOMJSClass {
4602 base: JSClass {
4603 name: c"HTMLInputElement".as_ptr(),
4604 flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
4605 (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
4606 ,
4607 cOps: unsafe { CLASS_OPS.get() },
4608 spec: ptr::null(),
4609 ext: ptr::null(),
4610 oOps: ptr::null(),
4611 },
4612 dom_class:
4613DOMClass {
4614 interface_chain: [ PrototypeList::ID::EventTarget, PrototypeList::ID::Node, PrototypeList::ID::Element, PrototypeList::ID::HTMLElement, PrototypeList::ID::HTMLInputElement, PrototypeList::ID::Last ],
4615 depth: 4,
4616 type_id: crate::codegen::InheritTypes::TopTypeId { eventtarget: (crate::codegen::InheritTypes::EventTargetTypeId::Node(crate::codegen::InheritTypes::NodeTypeId::Element(crate::codegen::InheritTypes::ElementTypeId::HTMLElement(crate::codegen::InheritTypes::HTMLElementTypeId::HTMLInputElement)))) },
4617 malloc_size_of: malloc_size_of_including_raw_self::<D::HTMLInputElement> as unsafe fn(&mut _, _) -> _,
4618 global: Globals::EMPTY,
4619},
4620 });
4621}
4622
4623#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
4624(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::HTMLInputElement>, _can_gc: CanGc) -> DomRoot<D::HTMLInputElement>{
4625
4626 let raw = Root::new(MaybeUnreflectedDom::from_box(object));
4627
4628 let scope = scope.reflector().get_jsobject();
4629 assert!(!scope.get().is_null());
4630 assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
4631 let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());
4632
4633 rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
4634 GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
4635 assert!(!canonical_proto.is_null());
4636
4637
4638 rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
4639 if let Some(given) = given_proto {
4640 proto.set(*given);
4641 if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
4642 assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
4643 }
4644 } else {
4645 proto.set(*canonical_proto);
4646 }
4647 rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
4648 cx.raw_cx(),
4649 &Class.get().base,
4650 proto.handle(),
4651 ));
4652 assert!(!obj.is_null());
4653 JS_SetReservedSlot(
4654 obj.get(),
4655 DOM_OBJECT_SLOT,
4656 &PrivateValue(raw.as_ptr() as *const libc::c_void),
4657 );
4658
4659 let root = raw.reflect_with(obj.get());
4660
4661
4662
4663 DomRoot::from_ref(&*root)
4664}
4665
4666pub trait HTMLInputElementMethods<D: DomTypes> {
4667 fn Accept(&self, ) -> DOMString;
4668 fn SetAccept(&self, r#value: DOMString);
4669 fn Alt(&self, ) -> DOMString;
4670 fn SetAlt(&self, r#value: DOMString);
4671 fn DefaultChecked(&self, ) -> bool;
4672 fn SetDefaultChecked(&self, r#value: bool);
4673 fn Checked(&self, ) -> bool;
4674 fn SetChecked(&self, r#value: bool, r#_can_gc: CanGc);
4675 fn DirName(&self, ) -> DOMString;
4676 fn SetDirName(&self, r#value: DOMString);
4677 fn Disabled(&self, ) -> bool;
4678 fn SetDisabled(&self, r#value: bool);
4679 fn GetForm(&self, ) -> Option<DomRoot<D::HTMLFormElement>>;
4680 fn GetFiles(&self, ) -> Option<DomRoot<D::FileList>>;
4681 fn SetFiles(&self, r#value: Option<&D::FileList>);
4682 fn FormAction(&self, ) -> DOMString;
4683 fn SetFormAction(&self, r#value: DOMString);
4684 fn FormEnctype(&self, ) -> DOMString;
4685 fn SetFormEnctype(&self, r#value: DOMString);
4686 fn FormMethod(&self, ) -> DOMString;
4687 fn SetFormMethod(&self, r#value: DOMString);
4688 fn FormNoValidate(&self, ) -> bool;
4689 fn SetFormNoValidate(&self, r#value: bool);
4690 fn FormTarget(&self, ) -> DOMString;
4691 fn SetFormTarget(&self, r#value: DOMString);
4692 fn Indeterminate(&self, ) -> bool;
4693 fn SetIndeterminate(&self, r#value: bool);
4694 fn GetList(&self, ) -> Option<DomRoot<D::HTMLDataListElement>>;
4695 fn Max(&self, ) -> DOMString;
4696 fn SetMax(&self, r#value: DOMString);
4697 fn MaxLength(&self, ) -> i32;
4698 fn SetMaxLength(&self, r#value: i32) -> ErrorResult;
4699 fn Min(&self, ) -> DOMString;
4700 fn SetMin(&self, r#value: DOMString);
4701 fn MinLength(&self, ) -> i32;
4702 fn SetMinLength(&self, r#value: i32) -> ErrorResult;
4703 fn Multiple(&self, ) -> bool;
4704 fn SetMultiple(&self, r#value: bool);
4705 fn Name(&self, ) -> DOMString;
4706 fn SetName(&self, r#value: DOMString);
4707 fn Pattern(&self, ) -> DOMString;
4708 fn SetPattern(&self, r#value: DOMString);
4709 fn Placeholder(&self, ) -> DOMString;
4710 fn SetPlaceholder(&self, r#value: DOMString);
4711 fn ReadOnly(&self, ) -> bool;
4712 fn SetReadOnly(&self, r#value: bool);
4713 fn Required(&self, ) -> bool;
4714 fn SetRequired(&self, r#value: bool);
4715 fn Size(&self, ) -> u32;
4716 fn SetSize(&self, r#value: u32) -> ErrorResult;
4717 fn Src(&self, ) -> USVString;
4718 fn SetSrc(&self, r#value: USVString);
4719 fn Step(&self, ) -> DOMString;
4720 fn SetStep(&self, r#value: DOMString);
4721 fn Type(&self, ) -> DOMString;
4722 fn SetType(&self, r#value: DOMString);
4723 fn DefaultValue(&self, ) -> DOMString;
4724 fn SetDefaultValue(&self, r#value: DOMString);
4725 fn Value(&self, ) -> DOMString;
4726 fn SetValue(&self, r#value: DOMString, r#_can_gc: CanGc) -> ErrorResult;
4727 fn GetValueAsDate(&self, r#cx: SafeJSContext) -> Option<NonNull<JSObject>>;
4728 fn SetValueAsDate(&self, r#cx: SafeJSContext, r#value: *mut JSObject, r#_can_gc: CanGc) -> ErrorResult;
4729 fn ValueAsNumber(&self, ) -> f64;
4730 fn SetValueAsNumber(&self, r#value: f64, r#_can_gc: CanGc) -> ErrorResult;
4731 fn StepUp(&self, r#n: i32, r#_can_gc: CanGc) -> Fallible<()>;
4732 fn StepDown(&self, r#n: i32, r#_can_gc: CanGc) -> Fallible<()>;
4733 fn WillValidate(&self, ) -> bool;
4734 fn Validity(&self, r#_can_gc: CanGc) -> DomRoot<D::ValidityState>;
4735 fn ValidationMessage(&self, ) -> DOMString;
4736 fn CheckValidity(&self, r#_can_gc: CanGc) -> bool;
4737 fn ReportValidity(&self, r#_can_gc: CanGc) -> bool;
4738 fn SetCustomValidity(&self, r#error: DOMString, r#_can_gc: CanGc);
4739 fn GetLabels(&self, r#_can_gc: CanGc) -> Option<DomRoot<D::NodeList>>;
4740 fn Select(&self, );
4741 fn GetSelectionStart(&self, ) -> Option<u32>;
4742 fn SetSelectionStart(&self, r#value: Option<u32>) -> ErrorResult;
4743 fn GetSelectionEnd(&self, ) -> Option<u32>;
4744 fn SetSelectionEnd(&self, r#value: Option<u32>) -> ErrorResult;
4745 fn GetSelectionDirection(&self, ) -> Option<DOMString>;
4746 fn SetSelectionDirection(&self, r#value: Option<DOMString>) -> ErrorResult;
4747 fn SetRangeText(&self, r#replacement: DOMString) -> Fallible<()>;
4748 fn SetRangeText_(&self, r#replacement: DOMString, r#start: u32, r#end: u32, r#selectionMode: SelectionMode) -> Fallible<()>;
4749 fn SetSelectionRange(&self, r#start: u32, r#end: u32, r#direction: Option<DOMString>) -> Fallible<()>;
4750 fn SelectFiles(&self, r#path: Vec<DOMString>);
4751}
4752static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();
4753
4754pub(crate) fn init_sMethods_specs<D: DomTypes>() {
4755 sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
4756 JSFunctionSpec {
4757 name: JSPropertySpec_Name { string_: c"stepUp".as_ptr() },
4758 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stepUp_methodinfo.get() } as *const _ as *const JSJitInfo },
4759 nargs: 0,
4760 flags: (JSPROP_ENUMERATE) as u16,
4761 selfHostedName: ptr::null()
4762 },
4763 JSFunctionSpec {
4764 name: JSPropertySpec_Name { string_: c"stepDown".as_ptr() },
4765 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { stepDown_methodinfo.get() } as *const _ as *const JSJitInfo },
4766 nargs: 0,
4767 flags: (JSPROP_ENUMERATE) as u16,
4768 selfHostedName: ptr::null()
4769 },
4770 JSFunctionSpec {
4771 name: JSPropertySpec_Name { string_: c"checkValidity".as_ptr() },
4772 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { checkValidity_methodinfo.get() } as *const _ as *const JSJitInfo },
4773 nargs: 0,
4774 flags: (JSPROP_ENUMERATE) as u16,
4775 selfHostedName: ptr::null()
4776 },
4777 JSFunctionSpec {
4778 name: JSPropertySpec_Name { string_: c"reportValidity".as_ptr() },
4779 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { reportValidity_methodinfo.get() } as *const _ as *const JSJitInfo },
4780 nargs: 0,
4781 flags: (JSPROP_ENUMERATE) as u16,
4782 selfHostedName: ptr::null()
4783 },
4784 JSFunctionSpec {
4785 name: JSPropertySpec_Name { string_: c"setCustomValidity".as_ptr() },
4786 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setCustomValidity_methodinfo.get() } as *const _ as *const JSJitInfo },
4787 nargs: 1,
4788 flags: (JSPROP_ENUMERATE) as u16,
4789 selfHostedName: ptr::null()
4790 },
4791 JSFunctionSpec {
4792 name: JSPropertySpec_Name { string_: c"select".as_ptr() },
4793 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { select_methodinfo.get() } as *const _ as *const JSJitInfo },
4794 nargs: 0,
4795 flags: (JSPROP_ENUMERATE) as u16,
4796 selfHostedName: ptr::null()
4797 },
4798 JSFunctionSpec {
4799 name: JSPropertySpec_Name { string_: c"setRangeText".as_ptr() },
4800 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setRangeText_methodinfo.get() } as *const _ as *const JSJitInfo },
4801 nargs: 1,
4802 flags: (JSPROP_ENUMERATE) as u16,
4803 selfHostedName: ptr::null()
4804 },
4805 JSFunctionSpec {
4806 name: JSPropertySpec_Name { string_: c"setSelectionRange".as_ptr() },
4807 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setSelectionRange_methodinfo.get() } as *const _ as *const JSJitInfo },
4808 nargs: 2,
4809 flags: (JSPROP_ENUMERATE) as u16,
4810 selfHostedName: ptr::null()
4811 },
4812 JSFunctionSpec {
4813 name: JSPropertySpec_Name { string_: ptr::null() },
4814 call: JSNativeWrapper { op: None, info: ptr::null() },
4815 nargs: 0,
4816 flags: 0,
4817 selfHostedName: ptr::null()
4818 }]))[..]
4819,
4820&Box::leak(Box::new([
4821 JSFunctionSpec {
4822 name: JSPropertySpec_Name { string_: c"selectFiles".as_ptr() },
4823 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { selectFiles_methodinfo.get() } as *const _ as *const JSJitInfo },
4824 nargs: 1,
4825 flags: (JSPROP_ENUMERATE) as u16,
4826 selfHostedName: ptr::null()
4827 },
4828 JSFunctionSpec {
4829 name: JSPropertySpec_Name { string_: ptr::null() },
4830 call: JSNativeWrapper { op: None, info: ptr::null() },
4831 nargs: 0,
4832 flags: 0,
4833 selfHostedName: ptr::null()
4834 }]))[..]
4835])));
4836}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();
4837
4838pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
4839 sMethods.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sMethods_specs.get() })[0]),
4840 Guard::new(&[Condition::Pref("dom_testing_html_input_element_select_files_enabled"),Condition::Exposed(Globals::WINDOW)], (unsafe { sMethods_specs.get() })[1])])));
4841}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();
4842
4843pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
4844 sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
4845 JSPropertySpec {
4846 name: JSPropertySpec_Name { string_: c"accept".as_ptr() },
4847 attributes_: (JSPROP_ENUMERATE),
4848 kind_: (JSPropertySpec_Kind::NativeAccessor),
4849 u: JSPropertySpec_AccessorsOrValue {
4850 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
4851 getter: JSPropertySpec_Accessor {
4852 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { accept_getterinfo.get() } },
4853 },
4854 setter: JSPropertySpec_Accessor {
4855 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { accept_setterinfo.get() } },
4856 }
4857 }
4858 }
4859 }
4860,
4861 JSPropertySpec {
4862 name: JSPropertySpec_Name { string_: c"alt".as_ptr() },
4863 attributes_: (JSPROP_ENUMERATE),
4864 kind_: (JSPropertySpec_Kind::NativeAccessor),
4865 u: JSPropertySpec_AccessorsOrValue {
4866 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
4867 getter: JSPropertySpec_Accessor {
4868 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { alt_getterinfo.get() } },
4869 },
4870 setter: JSPropertySpec_Accessor {
4871 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { alt_setterinfo.get() } },
4872 }
4873 }
4874 }
4875 }
4876,
4877 JSPropertySpec {
4878 name: JSPropertySpec_Name { string_: c"defaultChecked".as_ptr() },
4879 attributes_: (JSPROP_ENUMERATE),
4880 kind_: (JSPropertySpec_Kind::NativeAccessor),
4881 u: JSPropertySpec_AccessorsOrValue {
4882 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
4883 getter: JSPropertySpec_Accessor {
4884 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { defaultChecked_getterinfo.get() } },
4885 },
4886 setter: JSPropertySpec_Accessor {
4887 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { defaultChecked_setterinfo.get() } },
4888 }
4889 }
4890 }
4891 }
4892,
4893 JSPropertySpec {
4894 name: JSPropertySpec_Name { string_: c"checked".as_ptr() },
4895 attributes_: (JSPROP_ENUMERATE),
4896 kind_: (JSPropertySpec_Kind::NativeAccessor),
4897 u: JSPropertySpec_AccessorsOrValue {
4898 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
4899 getter: JSPropertySpec_Accessor {
4900 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { checked_getterinfo.get() } },
4901 },
4902 setter: JSPropertySpec_Accessor {
4903 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { checked_setterinfo.get() } },
4904 }
4905 }
4906 }
4907 }
4908,
4909 JSPropertySpec {
4910 name: JSPropertySpec_Name { string_: c"dirName".as_ptr() },
4911 attributes_: (JSPROP_ENUMERATE),
4912 kind_: (JSPropertySpec_Kind::NativeAccessor),
4913 u: JSPropertySpec_AccessorsOrValue {
4914 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
4915 getter: JSPropertySpec_Accessor {
4916 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { dirName_getterinfo.get() } },
4917 },
4918 setter: JSPropertySpec_Accessor {
4919 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { dirName_setterinfo.get() } },
4920 }
4921 }
4922 }
4923 }
4924,
4925 JSPropertySpec {
4926 name: JSPropertySpec_Name { string_: c"disabled".as_ptr() },
4927 attributes_: (JSPROP_ENUMERATE),
4928 kind_: (JSPropertySpec_Kind::NativeAccessor),
4929 u: JSPropertySpec_AccessorsOrValue {
4930 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
4931 getter: JSPropertySpec_Accessor {
4932 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { disabled_getterinfo.get() } },
4933 },
4934 setter: JSPropertySpec_Accessor {
4935 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { disabled_setterinfo.get() } },
4936 }
4937 }
4938 }
4939 }
4940,
4941 JSPropertySpec {
4942 name: JSPropertySpec_Name { string_: c"form".as_ptr() },
4943 attributes_: (JSPROP_ENUMERATE),
4944 kind_: (JSPropertySpec_Kind::NativeAccessor),
4945 u: JSPropertySpec_AccessorsOrValue {
4946 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
4947 getter: JSPropertySpec_Accessor {
4948 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { form_getterinfo.get() } },
4949 },
4950 setter: JSPropertySpec_Accessor {
4951 native: JSNativeWrapper { op: None, info: ptr::null() },
4952 }
4953 }
4954 }
4955 }
4956,
4957 JSPropertySpec {
4958 name: JSPropertySpec_Name { string_: c"files".as_ptr() },
4959 attributes_: (JSPROP_ENUMERATE),
4960 kind_: (JSPropertySpec_Kind::NativeAccessor),
4961 u: JSPropertySpec_AccessorsOrValue {
4962 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
4963 getter: JSPropertySpec_Accessor {
4964 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { files_getterinfo.get() } },
4965 },
4966 setter: JSPropertySpec_Accessor {
4967 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { files_setterinfo.get() } },
4968 }
4969 }
4970 }
4971 }
4972,
4973 JSPropertySpec {
4974 name: JSPropertySpec_Name { string_: c"formAction".as_ptr() },
4975 attributes_: (JSPROP_ENUMERATE),
4976 kind_: (JSPropertySpec_Kind::NativeAccessor),
4977 u: JSPropertySpec_AccessorsOrValue {
4978 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
4979 getter: JSPropertySpec_Accessor {
4980 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { formAction_getterinfo.get() } },
4981 },
4982 setter: JSPropertySpec_Accessor {
4983 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { formAction_setterinfo.get() } },
4984 }
4985 }
4986 }
4987 }
4988,
4989 JSPropertySpec {
4990 name: JSPropertySpec_Name { string_: c"formEnctype".as_ptr() },
4991 attributes_: (JSPROP_ENUMERATE),
4992 kind_: (JSPropertySpec_Kind::NativeAccessor),
4993 u: JSPropertySpec_AccessorsOrValue {
4994 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
4995 getter: JSPropertySpec_Accessor {
4996 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { formEnctype_getterinfo.get() } },
4997 },
4998 setter: JSPropertySpec_Accessor {
4999 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { formEnctype_setterinfo.get() } },
5000 }
5001 }
5002 }
5003 }
5004,
5005 JSPropertySpec {
5006 name: JSPropertySpec_Name { string_: c"formMethod".as_ptr() },
5007 attributes_: (JSPROP_ENUMERATE),
5008 kind_: (JSPropertySpec_Kind::NativeAccessor),
5009 u: JSPropertySpec_AccessorsOrValue {
5010 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5011 getter: JSPropertySpec_Accessor {
5012 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { formMethod_getterinfo.get() } },
5013 },
5014 setter: JSPropertySpec_Accessor {
5015 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { formMethod_setterinfo.get() } },
5016 }
5017 }
5018 }
5019 }
5020,
5021 JSPropertySpec {
5022 name: JSPropertySpec_Name { string_: c"formNoValidate".as_ptr() },
5023 attributes_: (JSPROP_ENUMERATE),
5024 kind_: (JSPropertySpec_Kind::NativeAccessor),
5025 u: JSPropertySpec_AccessorsOrValue {
5026 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5027 getter: JSPropertySpec_Accessor {
5028 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { formNoValidate_getterinfo.get() } },
5029 },
5030 setter: JSPropertySpec_Accessor {
5031 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { formNoValidate_setterinfo.get() } },
5032 }
5033 }
5034 }
5035 }
5036,
5037 JSPropertySpec {
5038 name: JSPropertySpec_Name { string_: c"formTarget".as_ptr() },
5039 attributes_: (JSPROP_ENUMERATE),
5040 kind_: (JSPropertySpec_Kind::NativeAccessor),
5041 u: JSPropertySpec_AccessorsOrValue {
5042 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5043 getter: JSPropertySpec_Accessor {
5044 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { formTarget_getterinfo.get() } },
5045 },
5046 setter: JSPropertySpec_Accessor {
5047 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { formTarget_setterinfo.get() } },
5048 }
5049 }
5050 }
5051 }
5052,
5053 JSPropertySpec {
5054 name: JSPropertySpec_Name { string_: c"indeterminate".as_ptr() },
5055 attributes_: (JSPROP_ENUMERATE),
5056 kind_: (JSPropertySpec_Kind::NativeAccessor),
5057 u: JSPropertySpec_AccessorsOrValue {
5058 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5059 getter: JSPropertySpec_Accessor {
5060 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { indeterminate_getterinfo.get() } },
5061 },
5062 setter: JSPropertySpec_Accessor {
5063 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { indeterminate_setterinfo.get() } },
5064 }
5065 }
5066 }
5067 }
5068,
5069 JSPropertySpec {
5070 name: JSPropertySpec_Name { string_: c"list".as_ptr() },
5071 attributes_: (JSPROP_ENUMERATE),
5072 kind_: (JSPropertySpec_Kind::NativeAccessor),
5073 u: JSPropertySpec_AccessorsOrValue {
5074 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5075 getter: JSPropertySpec_Accessor {
5076 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { list_getterinfo.get() } },
5077 },
5078 setter: JSPropertySpec_Accessor {
5079 native: JSNativeWrapper { op: None, info: ptr::null() },
5080 }
5081 }
5082 }
5083 }
5084,
5085 JSPropertySpec {
5086 name: JSPropertySpec_Name { string_: c"max".as_ptr() },
5087 attributes_: (JSPROP_ENUMERATE),
5088 kind_: (JSPropertySpec_Kind::NativeAccessor),
5089 u: JSPropertySpec_AccessorsOrValue {
5090 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5091 getter: JSPropertySpec_Accessor {
5092 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { max_getterinfo.get() } },
5093 },
5094 setter: JSPropertySpec_Accessor {
5095 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { max_setterinfo.get() } },
5096 }
5097 }
5098 }
5099 }
5100,
5101 JSPropertySpec {
5102 name: JSPropertySpec_Name { string_: c"maxLength".as_ptr() },
5103 attributes_: (JSPROP_ENUMERATE),
5104 kind_: (JSPropertySpec_Kind::NativeAccessor),
5105 u: JSPropertySpec_AccessorsOrValue {
5106 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5107 getter: JSPropertySpec_Accessor {
5108 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxLength_getterinfo.get() } },
5109 },
5110 setter: JSPropertySpec_Accessor {
5111 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { maxLength_setterinfo.get() } },
5112 }
5113 }
5114 }
5115 }
5116,
5117 JSPropertySpec {
5118 name: JSPropertySpec_Name { string_: c"min".as_ptr() },
5119 attributes_: (JSPROP_ENUMERATE),
5120 kind_: (JSPropertySpec_Kind::NativeAccessor),
5121 u: JSPropertySpec_AccessorsOrValue {
5122 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5123 getter: JSPropertySpec_Accessor {
5124 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { min_getterinfo.get() } },
5125 },
5126 setter: JSPropertySpec_Accessor {
5127 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { min_setterinfo.get() } },
5128 }
5129 }
5130 }
5131 }
5132,
5133 JSPropertySpec {
5134 name: JSPropertySpec_Name { string_: c"minLength".as_ptr() },
5135 attributes_: (JSPROP_ENUMERATE),
5136 kind_: (JSPropertySpec_Kind::NativeAccessor),
5137 u: JSPropertySpec_AccessorsOrValue {
5138 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5139 getter: JSPropertySpec_Accessor {
5140 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { minLength_getterinfo.get() } },
5141 },
5142 setter: JSPropertySpec_Accessor {
5143 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { minLength_setterinfo.get() } },
5144 }
5145 }
5146 }
5147 }
5148,
5149 JSPropertySpec {
5150 name: JSPropertySpec_Name { string_: c"multiple".as_ptr() },
5151 attributes_: (JSPROP_ENUMERATE),
5152 kind_: (JSPropertySpec_Kind::NativeAccessor),
5153 u: JSPropertySpec_AccessorsOrValue {
5154 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5155 getter: JSPropertySpec_Accessor {
5156 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { multiple_getterinfo.get() } },
5157 },
5158 setter: JSPropertySpec_Accessor {
5159 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { multiple_setterinfo.get() } },
5160 }
5161 }
5162 }
5163 }
5164,
5165 JSPropertySpec {
5166 name: JSPropertySpec_Name { string_: c"name".as_ptr() },
5167 attributes_: (JSPROP_ENUMERATE),
5168 kind_: (JSPropertySpec_Kind::NativeAccessor),
5169 u: JSPropertySpec_AccessorsOrValue {
5170 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5171 getter: JSPropertySpec_Accessor {
5172 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { name_getterinfo.get() } },
5173 },
5174 setter: JSPropertySpec_Accessor {
5175 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { name_setterinfo.get() } },
5176 }
5177 }
5178 }
5179 }
5180,
5181 JSPropertySpec {
5182 name: JSPropertySpec_Name { string_: c"pattern".as_ptr() },
5183 attributes_: (JSPROP_ENUMERATE),
5184 kind_: (JSPropertySpec_Kind::NativeAccessor),
5185 u: JSPropertySpec_AccessorsOrValue {
5186 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5187 getter: JSPropertySpec_Accessor {
5188 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { pattern_getterinfo.get() } },
5189 },
5190 setter: JSPropertySpec_Accessor {
5191 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { pattern_setterinfo.get() } },
5192 }
5193 }
5194 }
5195 }
5196,
5197 JSPropertySpec {
5198 name: JSPropertySpec_Name { string_: c"placeholder".as_ptr() },
5199 attributes_: (JSPROP_ENUMERATE),
5200 kind_: (JSPropertySpec_Kind::NativeAccessor),
5201 u: JSPropertySpec_AccessorsOrValue {
5202 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5203 getter: JSPropertySpec_Accessor {
5204 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { placeholder_getterinfo.get() } },
5205 },
5206 setter: JSPropertySpec_Accessor {
5207 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { placeholder_setterinfo.get() } },
5208 }
5209 }
5210 }
5211 }
5212,
5213 JSPropertySpec {
5214 name: JSPropertySpec_Name { string_: c"readOnly".as_ptr() },
5215 attributes_: (JSPROP_ENUMERATE),
5216 kind_: (JSPropertySpec_Kind::NativeAccessor),
5217 u: JSPropertySpec_AccessorsOrValue {
5218 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5219 getter: JSPropertySpec_Accessor {
5220 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { readOnly_getterinfo.get() } },
5221 },
5222 setter: JSPropertySpec_Accessor {
5223 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { readOnly_setterinfo.get() } },
5224 }
5225 }
5226 }
5227 }
5228,
5229 JSPropertySpec {
5230 name: JSPropertySpec_Name { string_: c"required".as_ptr() },
5231 attributes_: (JSPROP_ENUMERATE),
5232 kind_: (JSPropertySpec_Kind::NativeAccessor),
5233 u: JSPropertySpec_AccessorsOrValue {
5234 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5235 getter: JSPropertySpec_Accessor {
5236 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { required_getterinfo.get() } },
5237 },
5238 setter: JSPropertySpec_Accessor {
5239 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { required_setterinfo.get() } },
5240 }
5241 }
5242 }
5243 }
5244,
5245 JSPropertySpec {
5246 name: JSPropertySpec_Name { string_: c"size".as_ptr() },
5247 attributes_: (JSPROP_ENUMERATE),
5248 kind_: (JSPropertySpec_Kind::NativeAccessor),
5249 u: JSPropertySpec_AccessorsOrValue {
5250 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5251 getter: JSPropertySpec_Accessor {
5252 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { size_getterinfo.get() } },
5253 },
5254 setter: JSPropertySpec_Accessor {
5255 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { size_setterinfo.get() } },
5256 }
5257 }
5258 }
5259 }
5260,
5261 JSPropertySpec {
5262 name: JSPropertySpec_Name { string_: c"src".as_ptr() },
5263 attributes_: (JSPROP_ENUMERATE),
5264 kind_: (JSPropertySpec_Kind::NativeAccessor),
5265 u: JSPropertySpec_AccessorsOrValue {
5266 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5267 getter: JSPropertySpec_Accessor {
5268 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { src_getterinfo.get() } },
5269 },
5270 setter: JSPropertySpec_Accessor {
5271 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { src_setterinfo.get() } },
5272 }
5273 }
5274 }
5275 }
5276,
5277 JSPropertySpec {
5278 name: JSPropertySpec_Name { string_: c"step".as_ptr() },
5279 attributes_: (JSPROP_ENUMERATE),
5280 kind_: (JSPropertySpec_Kind::NativeAccessor),
5281 u: JSPropertySpec_AccessorsOrValue {
5282 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5283 getter: JSPropertySpec_Accessor {
5284 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { step_getterinfo.get() } },
5285 },
5286 setter: JSPropertySpec_Accessor {
5287 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { step_setterinfo.get() } },
5288 }
5289 }
5290 }
5291 }
5292,
5293 JSPropertySpec {
5294 name: JSPropertySpec_Name { string_: c"type".as_ptr() },
5295 attributes_: (JSPROP_ENUMERATE),
5296 kind_: (JSPropertySpec_Kind::NativeAccessor),
5297 u: JSPropertySpec_AccessorsOrValue {
5298 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5299 getter: JSPropertySpec_Accessor {
5300 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { type_getterinfo.get() } },
5301 },
5302 setter: JSPropertySpec_Accessor {
5303 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { type_setterinfo.get() } },
5304 }
5305 }
5306 }
5307 }
5308,
5309 JSPropertySpec {
5310 name: JSPropertySpec_Name { string_: c"defaultValue".as_ptr() },
5311 attributes_: (JSPROP_ENUMERATE),
5312 kind_: (JSPropertySpec_Kind::NativeAccessor),
5313 u: JSPropertySpec_AccessorsOrValue {
5314 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5315 getter: JSPropertySpec_Accessor {
5316 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { defaultValue_getterinfo.get() } },
5317 },
5318 setter: JSPropertySpec_Accessor {
5319 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { defaultValue_setterinfo.get() } },
5320 }
5321 }
5322 }
5323 }
5324,
5325 JSPropertySpec {
5326 name: JSPropertySpec_Name { string_: c"value".as_ptr() },
5327 attributes_: (JSPROP_ENUMERATE),
5328 kind_: (JSPropertySpec_Kind::NativeAccessor),
5329 u: JSPropertySpec_AccessorsOrValue {
5330 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5331 getter: JSPropertySpec_Accessor {
5332 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { value_getterinfo.get() } },
5333 },
5334 setter: JSPropertySpec_Accessor {
5335 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { value_setterinfo.get() } },
5336 }
5337 }
5338 }
5339 }
5340,
5341 JSPropertySpec {
5342 name: JSPropertySpec_Name { string_: c"valueAsDate".as_ptr() },
5343 attributes_: (JSPROP_ENUMERATE),
5344 kind_: (JSPropertySpec_Kind::NativeAccessor),
5345 u: JSPropertySpec_AccessorsOrValue {
5346 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5347 getter: JSPropertySpec_Accessor {
5348 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { valueAsDate_getterinfo.get() } },
5349 },
5350 setter: JSPropertySpec_Accessor {
5351 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { valueAsDate_setterinfo.get() } },
5352 }
5353 }
5354 }
5355 }
5356,
5357 JSPropertySpec {
5358 name: JSPropertySpec_Name { string_: c"valueAsNumber".as_ptr() },
5359 attributes_: (JSPROP_ENUMERATE),
5360 kind_: (JSPropertySpec_Kind::NativeAccessor),
5361 u: JSPropertySpec_AccessorsOrValue {
5362 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5363 getter: JSPropertySpec_Accessor {
5364 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { valueAsNumber_getterinfo.get() } },
5365 },
5366 setter: JSPropertySpec_Accessor {
5367 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { valueAsNumber_setterinfo.get() } },
5368 }
5369 }
5370 }
5371 }
5372,
5373 JSPropertySpec {
5374 name: JSPropertySpec_Name { string_: c"willValidate".as_ptr() },
5375 attributes_: (JSPROP_ENUMERATE),
5376 kind_: (JSPropertySpec_Kind::NativeAccessor),
5377 u: JSPropertySpec_AccessorsOrValue {
5378 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5379 getter: JSPropertySpec_Accessor {
5380 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { willValidate_getterinfo.get() } },
5381 },
5382 setter: JSPropertySpec_Accessor {
5383 native: JSNativeWrapper { op: None, info: ptr::null() },
5384 }
5385 }
5386 }
5387 }
5388,
5389 JSPropertySpec {
5390 name: JSPropertySpec_Name { string_: c"validity".as_ptr() },
5391 attributes_: (JSPROP_ENUMERATE),
5392 kind_: (JSPropertySpec_Kind::NativeAccessor),
5393 u: JSPropertySpec_AccessorsOrValue {
5394 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5395 getter: JSPropertySpec_Accessor {
5396 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { validity_getterinfo.get() } },
5397 },
5398 setter: JSPropertySpec_Accessor {
5399 native: JSNativeWrapper { op: None, info: ptr::null() },
5400 }
5401 }
5402 }
5403 }
5404,
5405 JSPropertySpec {
5406 name: JSPropertySpec_Name { string_: c"validationMessage".as_ptr() },
5407 attributes_: (JSPROP_ENUMERATE),
5408 kind_: (JSPropertySpec_Kind::NativeAccessor),
5409 u: JSPropertySpec_AccessorsOrValue {
5410 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5411 getter: JSPropertySpec_Accessor {
5412 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { validationMessage_getterinfo.get() } },
5413 },
5414 setter: JSPropertySpec_Accessor {
5415 native: JSNativeWrapper { op: None, info: ptr::null() },
5416 }
5417 }
5418 }
5419 }
5420,
5421 JSPropertySpec {
5422 name: JSPropertySpec_Name { string_: c"labels".as_ptr() },
5423 attributes_: (JSPROP_ENUMERATE),
5424 kind_: (JSPropertySpec_Kind::NativeAccessor),
5425 u: JSPropertySpec_AccessorsOrValue {
5426 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5427 getter: JSPropertySpec_Accessor {
5428 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { labels_getterinfo.get() } },
5429 },
5430 setter: JSPropertySpec_Accessor {
5431 native: JSNativeWrapper { op: None, info: ptr::null() },
5432 }
5433 }
5434 }
5435 }
5436,
5437 JSPropertySpec {
5438 name: JSPropertySpec_Name { string_: c"selectionStart".as_ptr() },
5439 attributes_: (JSPROP_ENUMERATE),
5440 kind_: (JSPropertySpec_Kind::NativeAccessor),
5441 u: JSPropertySpec_AccessorsOrValue {
5442 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5443 getter: JSPropertySpec_Accessor {
5444 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { selectionStart_getterinfo.get() } },
5445 },
5446 setter: JSPropertySpec_Accessor {
5447 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { selectionStart_setterinfo.get() } },
5448 }
5449 }
5450 }
5451 }
5452,
5453 JSPropertySpec {
5454 name: JSPropertySpec_Name { string_: c"selectionEnd".as_ptr() },
5455 attributes_: (JSPROP_ENUMERATE),
5456 kind_: (JSPropertySpec_Kind::NativeAccessor),
5457 u: JSPropertySpec_AccessorsOrValue {
5458 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5459 getter: JSPropertySpec_Accessor {
5460 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { selectionEnd_getterinfo.get() } },
5461 },
5462 setter: JSPropertySpec_Accessor {
5463 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { selectionEnd_setterinfo.get() } },
5464 }
5465 }
5466 }
5467 }
5468,
5469 JSPropertySpec {
5470 name: JSPropertySpec_Name { string_: c"selectionDirection".as_ptr() },
5471 attributes_: (JSPROP_ENUMERATE),
5472 kind_: (JSPropertySpec_Kind::NativeAccessor),
5473 u: JSPropertySpec_AccessorsOrValue {
5474 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
5475 getter: JSPropertySpec_Accessor {
5476 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { selectionDirection_getterinfo.get() } },
5477 },
5478 setter: JSPropertySpec_Accessor {
5479 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { selectionDirection_setterinfo.get() } },
5480 }
5481 }
5482 }
5483 }
5484,
5485 JSPropertySpec::ZERO]))[..]
5486,
5487&Box::leak(Box::new([
5488 JSPropertySpec {
5489 name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
5490 attributes_: (JSPROP_READONLY),
5491 kind_: (JSPropertySpec_Kind::Value),
5492 u: JSPropertySpec_AccessorsOrValue {
5493 value: JSPropertySpec_ValueWrapper {
5494 type_: JSPropertySpec_ValueWrapper_Type::String,
5495 __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
5496 string: c"HTMLInputElement".as_ptr(),
5497 }
5498 }
5499 }
5500 }
5501,
5502 JSPropertySpec::ZERO]))[..]
5503])));
5504}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();
5505
5506pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
5507 sAttributes.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[0]),
5508 Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
5509}
5510pub fn GetProtoObject<D: DomTypes>
5511(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
5512 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::HTMLInputElement), CreateInterfaceObjects::<D>, rval)
5514}
5515
5516
5517static PrototypeClass: JSClass = JSClass {
5518 name: c"HTMLInputElementPrototype".as_ptr(),
5519 flags:
5520 (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
5522 cOps: ptr::null(),
5523 spec: ptr::null(),
5524 ext: ptr::null(),
5525 oOps: ptr::null(),
5526};
5527
5528unsafe extern "C" fn _constructor<D: DomTypes>
5529(cx: *mut RawJSContext, argc: u32, vp: *mut JSVal) -> bool{
5530 let mut result = false;
5531 wrap_panic(&mut || result = {
5532 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5533 let args = CallArgs::from_vp(vp, argc);
5534 let global = D::GlobalScope::from_object(JS_CALLEE(cx.raw_cx(), vp).to_object());
5535
5536 <D as DomHelpers<D>>::call_html_constructor::<D::HTMLInputElement>(
5537 SafeJSContext::from_ptr(cx.raw_cx()),
5538 &args,
5539 &global,
5540 PrototypeList::ID::HTMLInputElement,
5541 CreateInterfaceObjects::<D>,
5542 CanGc::note()
5543 )
5544
5545 });
5546 result
5547}
5548
5549
5550static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();
5551
5552pub(crate) fn init_interface_object<D: DomTypes>() {
5553 INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
5554 Box::leak(Box::new(InterfaceConstructorBehavior::call(_constructor::<D>))),
5555 b"function HTMLInputElement() {\n [native code]\n}",
5556 PrototypeList::ID::HTMLInputElement,
5557 4,
5558 ));
5559}
5560
5561pub fn GetConstructorObject<D: DomTypes>
5562(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
5563 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::HTMLInputElement), CreateInterfaceObjects::<D>, rval)
5565}
5566
5567pub fn DefineDOMInterface<D: DomTypes>
5568(cx: SafeJSContext, global: HandleObject){
5569 define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::HTMLInputElement),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
5570}
5571
5572pub fn ConstructorEnabled<D: DomTypes>
5573(aCx: SafeJSContext, aObj: HandleObject) -> bool{
5574 is_exposed_in(aObj, Globals::WINDOW)
5575}
5576
5577unsafe fn CreateInterfaceObjects<D: DomTypes>
5578(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){
5579
5580 rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
5581 HTMLElement_Binding::GetProtoObject::<D>(cx, global, prototype_proto.handle_mut());
5582 assert!(!prototype_proto.is_null());
5583
5584 rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
5585 create_interface_prototype_object::<D>(cx,
5586 global,
5587 prototype_proto.handle(),
5588 &PrototypeClass,
5589 sMethods.get(),
5590 sAttributes.get(),
5591 &[],
5592 &[],
5593 prototype.handle_mut());
5594 assert!(!prototype.is_null());
5595 assert!((*cache)[PrototypeList::ID::HTMLInputElement as usize].is_null());
5596 (*cache)[PrototypeList::ID::HTMLInputElement as usize] = prototype.get();
5597 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::HTMLInputElement as isize),
5598 ptr::null_mut(),
5599 prototype.get());
5600
5601 rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
5602
5603 HTMLElement_Binding::GetConstructorObject::<D>(cx, global, interface_proto.handle_mut());
5604
5605 assert!(!interface_proto.is_null());
5606
5607 rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
5608 create_noncallback_interface_object::<D>(cx,
5609 global,
5610 interface_proto.handle(),
5611 INTERFACE_OBJECT_CLASS.get(),
5612 &[],
5613 &[],
5614 &[],
5615 prototype.handle(),
5616 c"HTMLInputElement",
5617 0,
5618 &[],
5619 interface.handle_mut());
5620 assert!(!interface.is_null());
5621
5622 assert!((*cache)[PrototypeList::Constructor::HTMLInputElement as usize].is_null());
5623 (*cache)[PrototypeList::Constructor::HTMLInputElement as usize] = interface.get();
5624 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::HTMLInputElement as isize),
5625 ptr::null_mut(),
5626 interface.get());
5627
5628}
5629
5630
5631 pub(crate) fn init_statics<D: DomTypes>() {
5632 init_interface_object::<D>();
5633 init_domjs_class::<D>();
5634 crate::codegen::GenericBindings::HTMLInputElementBinding::HTMLInputElement_Binding::init_stepUp_methodinfo::<D>();
5635crate::codegen::GenericBindings::HTMLInputElementBinding::HTMLInputElement_Binding::init_stepDown_methodinfo::<D>();
5636crate::codegen::GenericBindings::HTMLInputElementBinding::HTMLInputElement_Binding::init_checkValidity_methodinfo::<D>();
5637crate::codegen::GenericBindings::HTMLInputElementBinding::HTMLInputElement_Binding::init_reportValidity_methodinfo::<D>();
5638crate::codegen::GenericBindings::HTMLInputElementBinding::HTMLInputElement_Binding::init_setCustomValidity_methodinfo::<D>();
5639crate::codegen::GenericBindings::HTMLInputElementBinding::HTMLInputElement_Binding::init_select_methodinfo::<D>();
5640crate::codegen::GenericBindings::HTMLInputElementBinding::HTMLInputElement_Binding::init_setRangeText_methodinfo::<D>();
5641crate::codegen::GenericBindings::HTMLInputElementBinding::HTMLInputElement_Binding::init_setSelectionRange_methodinfo::<D>();
5642crate::codegen::GenericBindings::HTMLInputElementBinding::HTMLInputElement_Binding::init_selectFiles_methodinfo::<D>();
5643 init_accept_getterinfo::<D>();
5644init_alt_getterinfo::<D>();
5645init_defaultChecked_getterinfo::<D>();
5646init_checked_getterinfo::<D>();
5647init_dirName_getterinfo::<D>();
5648init_disabled_getterinfo::<D>();
5649init_form_getterinfo::<D>();
5650init_files_getterinfo::<D>();
5651init_formAction_getterinfo::<D>();
5652init_formEnctype_getterinfo::<D>();
5653init_formMethod_getterinfo::<D>();
5654init_formNoValidate_getterinfo::<D>();
5655init_formTarget_getterinfo::<D>();
5656init_indeterminate_getterinfo::<D>();
5657init_list_getterinfo::<D>();
5658init_max_getterinfo::<D>();
5659init_maxLength_getterinfo::<D>();
5660init_min_getterinfo::<D>();
5661init_minLength_getterinfo::<D>();
5662init_multiple_getterinfo::<D>();
5663init_name_getterinfo::<D>();
5664init_pattern_getterinfo::<D>();
5665init_placeholder_getterinfo::<D>();
5666init_readOnly_getterinfo::<D>();
5667init_required_getterinfo::<D>();
5668init_size_getterinfo::<D>();
5669init_src_getterinfo::<D>();
5670init_step_getterinfo::<D>();
5671init_type_getterinfo::<D>();
5672init_defaultValue_getterinfo::<D>();
5673init_value_getterinfo::<D>();
5674init_valueAsDate_getterinfo::<D>();
5675init_valueAsNumber_getterinfo::<D>();
5676init_willValidate_getterinfo::<D>();
5677init_validity_getterinfo::<D>();
5678init_validationMessage_getterinfo::<D>();
5679init_labels_getterinfo::<D>();
5680init_selectionStart_getterinfo::<D>();
5681init_selectionEnd_getterinfo::<D>();
5682init_selectionDirection_getterinfo::<D>();
5683 init_accept_setterinfo::<D>();
5684init_alt_setterinfo::<D>();
5685init_defaultChecked_setterinfo::<D>();
5686init_checked_setterinfo::<D>();
5687init_dirName_setterinfo::<D>();
5688init_disabled_setterinfo::<D>();
5689init_files_setterinfo::<D>();
5690init_formAction_setterinfo::<D>();
5691init_formEnctype_setterinfo::<D>();
5692init_formMethod_setterinfo::<D>();
5693init_formNoValidate_setterinfo::<D>();
5694init_formTarget_setterinfo::<D>();
5695init_indeterminate_setterinfo::<D>();
5696init_max_setterinfo::<D>();
5697init_maxLength_setterinfo::<D>();
5698init_min_setterinfo::<D>();
5699init_minLength_setterinfo::<D>();
5700init_multiple_setterinfo::<D>();
5701init_name_setterinfo::<D>();
5702init_pattern_setterinfo::<D>();
5703init_placeholder_setterinfo::<D>();
5704init_readOnly_setterinfo::<D>();
5705init_required_setterinfo::<D>();
5706init_size_setterinfo::<D>();
5707init_src_setterinfo::<D>();
5708init_step_setterinfo::<D>();
5709init_type_setterinfo::<D>();
5710init_defaultValue_setterinfo::<D>();
5711init_value_setterinfo::<D>();
5712init_valueAsDate_setterinfo::<D>();
5713init_valueAsNumber_setterinfo::<D>();
5714init_selectionStart_setterinfo::<D>();
5715init_selectionEnd_setterinfo::<D>();
5716init_selectionDirection_setterinfo::<D>();
5717
5718 init_sMethods_specs::<D>();
5719init_sMethods_prefs::<D>();
5720init_sAttributes_specs::<D>();
5721init_sAttributes_prefs::<D>();
5722 }
5723 }