1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 fn extract_bit(byte: u8, index: usize) -> bool {
20 let bit_index = if cfg!(target_endian = "big") {
21 7 - (index % 8)
22 } else {
23 index % 8
24 };
25 let mask = 1 << bit_index;
26 byte & mask == mask
27 }
28 #[inline]
29 pub fn get_bit(&self, index: usize) -> bool {
30 debug_assert!(index / 8 < self.storage.as_ref().len());
31 let byte_index = index / 8;
32 let byte = self.storage.as_ref()[byte_index];
33 Self::extract_bit(byte, index)
34 }
35 #[inline]
36 pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
37 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
38 let byte_index = index / 8;
39 let byte = unsafe {
40 *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
41 };
42 Self::extract_bit(byte, index)
43 }
44 #[inline]
45 fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
46 let bit_index = if cfg!(target_endian = "big") {
47 7 - (index % 8)
48 } else {
49 index % 8
50 };
51 let mask = 1 << bit_index;
52 if val {
53 byte | mask
54 } else {
55 byte & !mask
56 }
57 }
58 #[inline]
59 pub fn set_bit(&mut self, index: usize, val: bool) {
60 debug_assert!(index / 8 < self.storage.as_ref().len());
61 let byte_index = index / 8;
62 let byte = &mut self.storage.as_mut()[byte_index];
63 *byte = Self::change_bit(*byte, index, val);
64 }
65 #[inline]
66 pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
67 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
68 let byte_index = index / 8;
69 let byte = unsafe {
70 (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
71 };
72 unsafe { *byte = Self::change_bit(*byte, index, val) };
73 }
74 #[inline]
75 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
76 debug_assert!(bit_width <= 64);
77 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
78 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
79 let mut val = 0;
80 for i in 0..(bit_width as usize) {
81 if self.get_bit(i + bit_offset) {
82 let index = if cfg!(target_endian = "big") {
83 bit_width as usize - 1 - i
84 } else {
85 i
86 };
87 val |= 1 << index;
88 }
89 }
90 val
91 }
92 #[inline]
93 pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
94 debug_assert!(bit_width <= 64);
95 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
96 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
97 let mut val = 0;
98 for i in 0..(bit_width as usize) {
99 if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
100 let index = if cfg!(target_endian = "big") {
101 bit_width as usize - 1 - i
102 } else {
103 i
104 };
105 val |= 1 << index;
106 }
107 }
108 val
109 }
110 #[inline]
111 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
112 debug_assert!(bit_width <= 64);
113 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
114 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
115 for i in 0..(bit_width as usize) {
116 let mask = 1 << i;
117 let val_bit_is_set = val & mask == mask;
118 let index = if cfg!(target_endian = "big") {
119 bit_width as usize - 1 - i
120 } else {
121 i
122 };
123 self.set_bit(index + bit_offset, val_bit_is_set);
124 }
125 }
126 #[inline]
127 pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
128 debug_assert!(bit_width <= 64);
129 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
130 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
131 for i in 0..(bit_width as usize) {
132 let mask = 1 << i;
133 let val_bit_is_set = val & mask == mask;
134 let index = if cfg!(target_endian = "big") {
135 bit_width as usize - 1 - i
136 } else {
137 i
138 };
139 unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
140 }
141 }
142}
143pub type __clockid_t = ::std::os::raw::c_int;
144pub type clockid_t = __clockid_t;
145#[repr(C)]
146#[derive(Debug, Copy, Clone)]
147pub struct __sigset_t {
148 pub __val: [usize; 16usize],
149}
150#[repr(C)]
151#[derive(Debug, Copy, Clone)]
152pub struct __pthread_internal_list {
153 pub __prev: *mut __pthread_internal_list,
154 pub __next: *mut __pthread_internal_list,
155}
156pub type __pthread_list_t = __pthread_internal_list;
157#[repr(C)]
158#[derive(Debug, Copy, Clone)]
159pub struct __pthread_mutex_s {
160 pub __lock: ::std::os::raw::c_int,
161 pub __count: ::std::os::raw::c_uint,
162 pub __owner: ::std::os::raw::c_int,
163 pub __nusers: ::std::os::raw::c_uint,
164 pub __kind: ::std::os::raw::c_int,
165 pub __spins: ::std::os::raw::c_short,
166 pub __elision: ::std::os::raw::c_short,
167 pub __list: __pthread_list_t,
168}
169#[repr(C)]
170#[derive(Copy, Clone)]
171pub struct __pthread_cond_s {
172 pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1,
173 pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2,
174 pub __g_refs: [::std::os::raw::c_uint; 2usize],
175 pub __g_size: [::std::os::raw::c_uint; 2usize],
176 pub __g1_orig_size: ::std::os::raw::c_uint,
177 pub __wrefs: ::std::os::raw::c_uint,
178 pub __g_signals: [::std::os::raw::c_uint; 2usize],
179}
180#[repr(C)]
181#[derive(Copy, Clone)]
182pub union __pthread_cond_s__bindgen_ty_1 {
183 pub __wseq: ::std::os::raw::c_ulonglong,
184 pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
185}
186#[repr(C)]
187#[derive(Debug, Copy, Clone)]
188pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
189 pub __low: ::std::os::raw::c_uint,
190 pub __high: ::std::os::raw::c_uint,
191}
192impl ::std::fmt::Debug for __pthread_cond_s__bindgen_ty_1 {
193 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
194 write!(f, "__pthread_cond_s__bindgen_ty_1 {{ union }}")
195 }
196}
197#[repr(C)]
198#[derive(Copy, Clone)]
199pub union __pthread_cond_s__bindgen_ty_2 {
200 pub __g1_start: ::std::os::raw::c_ulonglong,
201 pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
202}
203#[repr(C)]
204#[derive(Debug, Copy, Clone)]
205pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
206 pub __low: ::std::os::raw::c_uint,
207 pub __high: ::std::os::raw::c_uint,
208}
209impl ::std::fmt::Debug for __pthread_cond_s__bindgen_ty_2 {
210 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
211 write!(f, "__pthread_cond_s__bindgen_ty_2 {{ union }}")
212 }
213}
214impl ::std::fmt::Debug for __pthread_cond_s {
215 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
216 write ! (f , "__pthread_cond_s {{ __bindgen_anon_1: {:?}, __bindgen_anon_2: {:?}, __g_refs: {:?}, __g_size: {:?}, __g1_orig_size: {:?}, __wrefs: {:?}, __g_signals: {:?} }}" , self . __bindgen_anon_1 , self . __bindgen_anon_2 , self . __g_refs , self . __g_size , self . __g1_orig_size , self . __wrefs , self . __g_signals)
217 }
218}
219pub type pthread_t = usize;
220#[repr(C)]
221#[derive(Copy, Clone)]
222pub union pthread_mutex_t {
223 pub __data: __pthread_mutex_s,
224 pub __size: [::std::os::raw::c_char; 40usize],
225 pub __align: ::std::os::raw::c_long,
226}
227impl ::std::fmt::Debug for pthread_mutex_t {
228 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
229 write!(f, "pthread_mutex_t {{ union }}")
230 }
231}
232#[repr(C)]
233#[derive(Copy, Clone)]
234pub union pthread_cond_t {
235 pub __data: __pthread_cond_s,
236 pub __size: [::std::os::raw::c_char; 48usize],
237 pub __align: ::std::os::raw::c_longlong,
238}
239impl ::std::fmt::Debug for pthread_cond_t {
240 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
241 write!(f, "pthread_cond_t {{ union }}")
242 }
243}
244pub type VALUE = usize;
245pub type ID = usize;
246#[repr(C)]
247#[derive(Debug, Copy, Clone)]
248pub struct RBasic {
249 pub flags: VALUE,
250 pub klass: VALUE,
251}
252pub type rb_classext_t = rb_classext_struct;
253#[repr(C)]
254#[derive(Copy, Clone)]
255pub struct RString {
256 pub basic: RBasic,
257 pub as_: RString__bindgen_ty_1,
258}
259#[repr(C)]
260#[derive(Copy, Clone)]
261pub union RString__bindgen_ty_1 {
262 pub heap: RString__bindgen_ty_1__bindgen_ty_1,
263 pub ary: [::std::os::raw::c_char; 24usize],
264}
265#[repr(C)]
266#[derive(Copy, Clone)]
267pub struct RString__bindgen_ty_1__bindgen_ty_1 {
268 pub len: ::std::os::raw::c_long,
269 pub ptr: *mut ::std::os::raw::c_char,
270 pub aux: RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
271}
272#[repr(C)]
273#[derive(Copy, Clone)]
274pub union RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
275 pub capa: ::std::os::raw::c_long,
276 pub shared: VALUE,
277}
278impl ::std::fmt::Debug for RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
279 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
280 write!(
281 f,
282 "RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {{ union }}"
283 )
284 }
285}
286impl ::std::fmt::Debug for RString__bindgen_ty_1__bindgen_ty_1 {
287 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
288 write!(
289 f,
290 "RString__bindgen_ty_1__bindgen_ty_1 {{ len: {:?}, ptr: {:?}, aux: {:?} }}",
291 self.len, self.ptr, self.aux
292 )
293 }
294}
295impl ::std::fmt::Debug for RString__bindgen_ty_1 {
296 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
297 write!(f, "RString__bindgen_ty_1 {{ union }}")
298 }
299}
300impl ::std::fmt::Debug for RString {
301 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
302 write!(
303 f,
304 "RString {{ basic: {:?}, as: {:?} }}",
305 self.basic, self.as_
306 )
307 }
308}
309#[repr(C)]
310#[derive(Copy, Clone)]
311pub struct RArray {
312 pub basic: RBasic,
313 pub as_: RArray__bindgen_ty_1,
314}
315#[repr(C)]
316#[derive(Copy, Clone)]
317pub union RArray__bindgen_ty_1 {
318 pub heap: RArray__bindgen_ty_1__bindgen_ty_1,
319 pub ary: [VALUE; 3usize],
320}
321#[repr(C)]
322#[derive(Copy, Clone)]
323pub struct RArray__bindgen_ty_1__bindgen_ty_1 {
324 pub len: ::std::os::raw::c_long,
325 pub aux: RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
326 pub ptr: *const VALUE,
327}
328#[repr(C)]
329#[derive(Copy, Clone)]
330pub union RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
331 pub capa: ::std::os::raw::c_long,
332 pub shared: VALUE,
333}
334impl ::std::fmt::Debug for RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
335 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
336 write!(
337 f,
338 "RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {{ union }}"
339 )
340 }
341}
342impl ::std::fmt::Debug for RArray__bindgen_ty_1__bindgen_ty_1 {
343 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
344 write!(
345 f,
346 "RArray__bindgen_ty_1__bindgen_ty_1 {{ len: {:?}, aux: {:?}, ptr: {:?} }}",
347 self.len, self.aux, self.ptr
348 )
349 }
350}
351impl ::std::fmt::Debug for RArray__bindgen_ty_1 {
352 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
353 write!(f, "RArray__bindgen_ty_1 {{ union }}")
354 }
355}
356impl ::std::fmt::Debug for RArray {
357 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
358 write!(
359 f,
360 "RArray {{ basic: {:?}, as: {:?} }}",
361 self.basic, self.as_
362 )
363 }
364}
365#[repr(C)]
366#[derive(Debug, Copy, Clone)]
367pub struct rb_global_variable {
368 _unused: [u8; 0],
369}
370pub type st_data_t = usize;
371pub type st_index_t = st_data_t;
372#[repr(C)]
373#[derive(Debug, Copy, Clone)]
374pub struct st_hash_type {
375 pub compare: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
376 pub hash: ::std::option::Option<unsafe extern "C" fn() -> st_index_t>,
377}
378#[repr(C)]
379#[derive(Copy, Clone)]
380pub struct st_table {
381 pub type_: *const st_hash_type,
382 pub num_bins: st_index_t,
383 pub _bitfield_align_1: [u64; 0],
384 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
385 pub as_: st_table__bindgen_ty_1,
386}
387#[repr(C)]
388#[derive(Copy, Clone)]
389pub union st_table__bindgen_ty_1 {
390 pub big: st_table__bindgen_ty_1__bindgen_ty_1,
391 pub packed: st_table__bindgen_ty_1__bindgen_ty_2,
392}
393#[repr(C)]
394#[derive(Debug, Copy, Clone)]
395pub struct st_table__bindgen_ty_1__bindgen_ty_1 {
396 pub bins: *mut *mut st_table_entry,
397 pub head: *mut st_table_entry,
398 pub tail: *mut st_table_entry,
399}
400#[repr(C)]
401#[derive(Debug, Copy, Clone)]
402pub struct st_table__bindgen_ty_1__bindgen_ty_2 {
403 pub entries: *mut st_packed_entry,
404 pub real_entries: st_index_t,
405}
406impl ::std::fmt::Debug for st_table__bindgen_ty_1 {
407 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
408 write!(f, "st_table__bindgen_ty_1 {{ union }}")
409 }
410}
411impl ::std::fmt::Debug for st_table {
412 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
413 write ! (f , "st_table {{ type: {:?}, num_bins: {:?}, entries_packed : {:?}, num_entries : {:?}, as: {:?} }}" , self . type_ , self . num_bins , self . entries_packed () , self . num_entries () , self . as_)
414 }
415}
416impl st_table {
417 #[inline]
418 pub fn entries_packed(&self) -> ::std::os::raw::c_uint {
419 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
420 }
421 #[inline]
422 pub fn set_entries_packed(&mut self, val: ::std::os::raw::c_uint) {
423 unsafe {
424 let val: u32 = ::std::mem::transmute(val);
425 self._bitfield_1.set(0usize, 1u8, val as u64)
426 }
427 }
428 #[inline]
429 pub unsafe fn entries_packed_raw(this: *const Self) -> ::std::os::raw::c_uint {
430 unsafe {
431 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
432 ::std::ptr::addr_of!((*this)._bitfield_1),
433 0usize,
434 1u8,
435 ) as u32)
436 }
437 }
438 #[inline]
439 pub unsafe fn set_entries_packed_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
440 unsafe {
441 let val: u32 = ::std::mem::transmute(val);
442 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
443 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
444 0usize,
445 1u8,
446 val as u64,
447 )
448 }
449 }
450 #[inline]
451 pub fn num_entries(&self) -> st_index_t {
452 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 63u8) as usize) }
453 }
454 #[inline]
455 pub fn set_num_entries(&mut self, val: st_index_t) {
456 unsafe {
457 let val: usize = ::std::mem::transmute(val);
458 self._bitfield_1.set(1usize, 63u8, val as u64)
459 }
460 }
461 #[inline]
462 pub unsafe fn num_entries_raw(this: *const Self) -> st_index_t {
463 unsafe {
464 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
465 ::std::ptr::addr_of!((*this)._bitfield_1),
466 1usize,
467 63u8,
468 ) as u64)
469 }
470 }
471 #[inline]
472 pub unsafe fn set_num_entries_raw(this: *mut Self, val: st_index_t) {
473 unsafe {
474 let val: usize = ::std::mem::transmute(val);
475 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
476 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
477 1usize,
478 63u8,
479 val as u64,
480 )
481 }
482 }
483 #[inline]
484 pub fn new_bitfield_1(
485 entries_packed: ::std::os::raw::c_uint,
486 num_entries: st_index_t,
487 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
488 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
489 __bindgen_bitfield_unit.set(0usize, 1u8, {
490 let entries_packed: u32 = unsafe { ::std::mem::transmute(entries_packed) };
491 entries_packed as u64
492 });
493 __bindgen_bitfield_unit.set(1usize, 63u8, {
494 let num_entries: usize = unsafe { ::std::mem::transmute(num_entries) };
495 num_entries as u64
496 });
497 __bindgen_bitfield_unit
498 }
499}
500pub type rb_alloc_func_t = ::std::option::Option<unsafe extern "C" fn(arg1: VALUE) -> VALUE>;
501pub type rb_unblock_function_t =
502 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>;
503pub type rb_event_flag_t = u32;
504#[repr(C)]
505#[derive(Copy, Clone)]
506pub struct RNode {
507 pub flags: VALUE,
508 pub nd_reserved: VALUE,
509 pub u1: RNode__bindgen_ty_1,
510 pub u2: RNode__bindgen_ty_2,
511 pub u3: RNode__bindgen_ty_3,
512}
513#[repr(C)]
514#[derive(Copy, Clone)]
515pub union RNode__bindgen_ty_1 {
516 pub node: *mut RNode,
517 pub id: ID,
518 pub value: VALUE,
519 pub cfunc: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
520 pub tbl: *mut ID,
521}
522impl ::std::fmt::Debug for RNode__bindgen_ty_1 {
523 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
524 write!(f, "RNode__bindgen_ty_1 {{ union }}")
525 }
526}
527#[repr(C)]
528#[derive(Copy, Clone)]
529pub union RNode__bindgen_ty_2 {
530 pub node: *mut RNode,
531 pub id: ID,
532 pub argc: ::std::os::raw::c_long,
533 pub value: VALUE,
534}
535impl ::std::fmt::Debug for RNode__bindgen_ty_2 {
536 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
537 write!(f, "RNode__bindgen_ty_2 {{ union }}")
538 }
539}
540#[repr(C)]
541#[derive(Copy, Clone)]
542pub union RNode__bindgen_ty_3 {
543 pub node: *mut RNode,
544 pub id: ID,
545 pub state: ::std::os::raw::c_long,
546 pub entry: *mut rb_global_entry,
547 pub args: *mut rb_args_info,
548 pub cnt: ::std::os::raw::c_long,
549 pub value: VALUE,
550}
551impl ::std::fmt::Debug for RNode__bindgen_ty_3 {
552 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
553 write!(f, "RNode__bindgen_ty_3 {{ union }}")
554 }
555}
556impl ::std::fmt::Debug for RNode {
557 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
558 write!(
559 f,
560 "RNode {{ flags: {:?}, nd_reserved: {:?}, u1: {:?}, u2: {:?}, u3: {:?} }}",
561 self.flags, self.nd_reserved, self.u1, self.u2, self.u3
562 )
563 }
564}
565pub type NODE = RNode;
566#[repr(C)]
567#[derive(Debug, Copy, Clone)]
568pub struct rb_global_entry {
569 pub var: *mut rb_global_variable,
570 pub id: ID,
571}
572#[repr(C)]
573#[derive(Debug, Copy, Clone)]
574pub struct rb_args_info {
575 pub pre_init: *mut NODE,
576 pub post_init: *mut NODE,
577 pub pre_args_num: ::std::os::raw::c_int,
578 pub post_args_num: ::std::os::raw::c_int,
579 pub first_post_arg: ID,
580 pub rest_arg: ID,
581 pub block_arg: ID,
582 pub kw_args: *mut NODE,
583 pub kw_rest_arg: *mut NODE,
584 pub opt_args: *mut NODE,
585}
586pub const ruby_id_types_RUBY_ID_STATIC_SYM: ruby_id_types = 1;
587pub const ruby_id_types_RUBY_ID_LOCAL: ruby_id_types = 0;
588pub const ruby_id_types_RUBY_ID_INSTANCE: ruby_id_types = 2;
589pub const ruby_id_types_RUBY_ID_GLOBAL: ruby_id_types = 6;
590pub const ruby_id_types_RUBY_ID_ATTRSET: ruby_id_types = 8;
591pub const ruby_id_types_RUBY_ID_CONST: ruby_id_types = 10;
592pub const ruby_id_types_RUBY_ID_CLASS: ruby_id_types = 12;
593pub const ruby_id_types_RUBY_ID_JUNK: ruby_id_types = 14;
594pub const ruby_id_types_RUBY_ID_INTERNAL: ruby_id_types = 14;
595pub const ruby_id_types_RUBY_ID_SCOPE_SHIFT: ruby_id_types = 4;
596pub const ruby_id_types_RUBY_ID_SCOPE_MASK: ruby_id_types = 14;
597pub type ruby_id_types = ::std::os::raw::c_uint;
598pub const ruby_method_ids_idDot2: ruby_method_ids = 128;
599pub const ruby_method_ids_idDot3: ruby_method_ids = 129;
600pub const ruby_method_ids_idUPlus: ruby_method_ids = 130;
601pub const ruby_method_ids_idUMinus: ruby_method_ids = 131;
602pub const ruby_method_ids_idPow: ruby_method_ids = 132;
603pub const ruby_method_ids_idCmp: ruby_method_ids = 134;
604pub const ruby_method_ids_idPLUS: ruby_method_ids = 43;
605pub const ruby_method_ids_idMINUS: ruby_method_ids = 45;
606pub const ruby_method_ids_idMULT: ruby_method_ids = 42;
607pub const ruby_method_ids_idDIV: ruby_method_ids = 47;
608pub const ruby_method_ids_idMOD: ruby_method_ids = 37;
609pub const ruby_method_ids_idLT: ruby_method_ids = 60;
610pub const ruby_method_ids_idLTLT: ruby_method_ids = 135;
611pub const ruby_method_ids_idLE: ruby_method_ids = 137;
612pub const ruby_method_ids_idGT: ruby_method_ids = 62;
613pub const ruby_method_ids_idGTGT: ruby_method_ids = 136;
614pub const ruby_method_ids_idGE: ruby_method_ids = 138;
615pub const ruby_method_ids_idEq: ruby_method_ids = 139;
616pub const ruby_method_ids_idEqq: ruby_method_ids = 140;
617pub const ruby_method_ids_idNeq: ruby_method_ids = 141;
618pub const ruby_method_ids_idNot: ruby_method_ids = 33;
619pub const ruby_method_ids_idBackquote: ruby_method_ids = 96;
620pub const ruby_method_ids_idEqTilde: ruby_method_ids = 142;
621pub const ruby_method_ids_idNeqTilde: ruby_method_ids = 143;
622pub const ruby_method_ids_idAREF: ruby_method_ids = 144;
623pub const ruby_method_ids_idASET: ruby_method_ids = 145;
624pub const ruby_method_ids_idCOLON2: ruby_method_ids = 146;
625pub const ruby_method_ids_idANDOP: ruby_method_ids = 148;
626pub const ruby_method_ids_idOROP: ruby_method_ids = 149;
627pub const ruby_method_ids_tPRESERVED_ID_BEGIN: ruby_method_ids = 149;
628pub const ruby_method_ids_idNULL: ruby_method_ids = 150;
629pub const ruby_method_ids_idEmptyP: ruby_method_ids = 151;
630pub const ruby_method_ids_idEqlP: ruby_method_ids = 152;
631pub const ruby_method_ids_idRespond_to: ruby_method_ids = 153;
632pub const ruby_method_ids_idRespond_to_missing: ruby_method_ids = 154;
633pub const ruby_method_ids_idIFUNC: ruby_method_ids = 155;
634pub const ruby_method_ids_idCFUNC: ruby_method_ids = 156;
635pub const ruby_method_ids_id_core_set_method_alias: ruby_method_ids = 157;
636pub const ruby_method_ids_id_core_set_variable_alias: ruby_method_ids = 158;
637pub const ruby_method_ids_id_core_undef_method: ruby_method_ids = 159;
638pub const ruby_method_ids_id_core_define_method: ruby_method_ids = 160;
639pub const ruby_method_ids_id_core_define_singleton_method: ruby_method_ids = 161;
640pub const ruby_method_ids_id_core_set_postexe: ruby_method_ids = 162;
641pub const ruby_method_ids_id_core_hash_from_ary: ruby_method_ids = 163;
642pub const ruby_method_ids_id_core_hash_merge_ary: ruby_method_ids = 164;
643pub const ruby_method_ids_id_core_hash_merge_ptr: ruby_method_ids = 165;
644pub const ruby_method_ids_id_core_hash_merge_kwd: ruby_method_ids = 166;
645pub const ruby_method_ids_tPRESERVED_ID_END: ruby_method_ids = 167;
646pub const ruby_method_ids_tFreeze: ruby_method_ids = 168;
647pub const ruby_method_ids_tInspect: ruby_method_ids = 169;
648pub const ruby_method_ids_tIntern: ruby_method_ids = 170;
649pub const ruby_method_ids_tObject_id: ruby_method_ids = 171;
650pub const ruby_method_ids_tConst_missing: ruby_method_ids = 172;
651pub const ruby_method_ids_tMethodMissing: ruby_method_ids = 173;
652pub const ruby_method_ids_tMethod_added: ruby_method_ids = 174;
653pub const ruby_method_ids_tSingleton_method_added: ruby_method_ids = 175;
654pub const ruby_method_ids_tMethod_removed: ruby_method_ids = 176;
655pub const ruby_method_ids_tSingleton_method_removed: ruby_method_ids = 177;
656pub const ruby_method_ids_tMethod_undefined: ruby_method_ids = 178;
657pub const ruby_method_ids_tSingleton_method_undefined: ruby_method_ids = 179;
658pub const ruby_method_ids_tLength: ruby_method_ids = 180;
659pub const ruby_method_ids_tSize: ruby_method_ids = 181;
660pub const ruby_method_ids_tGets: ruby_method_ids = 182;
661pub const ruby_method_ids_tSucc: ruby_method_ids = 183;
662pub const ruby_method_ids_tEach: ruby_method_ids = 184;
663pub const ruby_method_ids_tProc: ruby_method_ids = 185;
664pub const ruby_method_ids_tLambda: ruby_method_ids = 186;
665pub const ruby_method_ids_tSend: ruby_method_ids = 187;
666pub const ruby_method_ids_t__send__: ruby_method_ids = 188;
667pub const ruby_method_ids_t__attached__: ruby_method_ids = 189;
668pub const ruby_method_ids_tInitialize: ruby_method_ids = 190;
669pub const ruby_method_ids_tInitialize_copy: ruby_method_ids = 191;
670pub const ruby_method_ids_tInitialize_clone: ruby_method_ids = 192;
671pub const ruby_method_ids_tInitialize_dup: ruby_method_ids = 193;
672pub const ruby_method_ids_tTo_int: ruby_method_ids = 194;
673pub const ruby_method_ids_tTo_ary: ruby_method_ids = 195;
674pub const ruby_method_ids_tTo_str: ruby_method_ids = 196;
675pub const ruby_method_ids_tTo_sym: ruby_method_ids = 197;
676pub const ruby_method_ids_tTo_hash: ruby_method_ids = 198;
677pub const ruby_method_ids_tTo_proc: ruby_method_ids = 199;
678pub const ruby_method_ids_tTo_io: ruby_method_ids = 200;
679pub const ruby_method_ids_tTo_a: ruby_method_ids = 201;
680pub const ruby_method_ids_tTo_s: ruby_method_ids = 202;
681pub const ruby_method_ids_tTo_i: ruby_method_ids = 203;
682pub const ruby_method_ids_tBt: ruby_method_ids = 204;
683pub const ruby_method_ids_tBt_locations: ruby_method_ids = 205;
684pub const ruby_method_ids_tCall: ruby_method_ids = 206;
685pub const ruby_method_ids_tMesg: ruby_method_ids = 207;
686pub const ruby_method_ids_tException: ruby_method_ids = 208;
687pub const ruby_method_ids_tUScore: ruby_method_ids = 209;
688pub const ruby_method_ids_tNEXT_ID: ruby_method_ids = 210;
689pub const ruby_method_ids_idFreeze: ruby_method_ids = 2689;
690pub const ruby_method_ids_idInspect: ruby_method_ids = 2705;
691pub const ruby_method_ids_idIntern: ruby_method_ids = 2721;
692pub const ruby_method_ids_idObject_id: ruby_method_ids = 2737;
693pub const ruby_method_ids_idConst_missing: ruby_method_ids = 2753;
694pub const ruby_method_ids_idMethodMissing: ruby_method_ids = 2769;
695pub const ruby_method_ids_idMethod_added: ruby_method_ids = 2785;
696pub const ruby_method_ids_idSingleton_method_added: ruby_method_ids = 2801;
697pub const ruby_method_ids_idMethod_removed: ruby_method_ids = 2817;
698pub const ruby_method_ids_idSingleton_method_removed: ruby_method_ids = 2833;
699pub const ruby_method_ids_idMethod_undefined: ruby_method_ids = 2849;
700pub const ruby_method_ids_idSingleton_method_undefined: ruby_method_ids = 2865;
701pub const ruby_method_ids_idLength: ruby_method_ids = 2881;
702pub const ruby_method_ids_idSize: ruby_method_ids = 2897;
703pub const ruby_method_ids_idGets: ruby_method_ids = 2913;
704pub const ruby_method_ids_idSucc: ruby_method_ids = 2929;
705pub const ruby_method_ids_idEach: ruby_method_ids = 2945;
706pub const ruby_method_ids_idProc: ruby_method_ids = 2961;
707pub const ruby_method_ids_idLambda: ruby_method_ids = 2977;
708pub const ruby_method_ids_idSend: ruby_method_ids = 2993;
709pub const ruby_method_ids_id__send__: ruby_method_ids = 3009;
710pub const ruby_method_ids_id__attached__: ruby_method_ids = 3025;
711pub const ruby_method_ids_idInitialize: ruby_method_ids = 3041;
712pub const ruby_method_ids_idInitialize_copy: ruby_method_ids = 3057;
713pub const ruby_method_ids_idInitialize_clone: ruby_method_ids = 3073;
714pub const ruby_method_ids_idInitialize_dup: ruby_method_ids = 3089;
715pub const ruby_method_ids_idTo_int: ruby_method_ids = 3105;
716pub const ruby_method_ids_idTo_ary: ruby_method_ids = 3121;
717pub const ruby_method_ids_idTo_str: ruby_method_ids = 3137;
718pub const ruby_method_ids_idTo_sym: ruby_method_ids = 3153;
719pub const ruby_method_ids_idTo_hash: ruby_method_ids = 3169;
720pub const ruby_method_ids_idTo_proc: ruby_method_ids = 3185;
721pub const ruby_method_ids_idTo_io: ruby_method_ids = 3201;
722pub const ruby_method_ids_idTo_a: ruby_method_ids = 3217;
723pub const ruby_method_ids_idTo_s: ruby_method_ids = 3233;
724pub const ruby_method_ids_idTo_i: ruby_method_ids = 3249;
725pub const ruby_method_ids_idBt: ruby_method_ids = 3265;
726pub const ruby_method_ids_idBt_locations: ruby_method_ids = 3281;
727pub const ruby_method_ids_idCall: ruby_method_ids = 3297;
728pub const ruby_method_ids_idMesg: ruby_method_ids = 3313;
729pub const ruby_method_ids_idException: ruby_method_ids = 3329;
730pub const ruby_method_ids_idUScore: ruby_method_ids = 3345;
731pub const ruby_method_ids_tLAST_OP_ID: ruby_method_ids = 166;
732pub const ruby_method_ids_idLAST_OP_ID: ruby_method_ids = 10;
733pub type ruby_method_ids = ::std::os::raw::c_uint;
734pub type rb_subclass_entry_t = rb_subclass_entry;
735#[repr(C)]
736#[derive(Debug, Copy, Clone)]
737pub struct rb_subclass_entry {
738 pub klass: VALUE,
739 pub next: *mut rb_subclass_entry_t,
740}
741pub type rb_serial_t = ::std::os::raw::c_ulonglong;
742#[repr(C)]
743#[derive(Debug, Copy, Clone)]
744pub struct rb_classext_struct {
745 pub iv_index_tbl: *mut st_table,
746 pub iv_tbl: *mut st_table,
747 pub const_tbl: *mut st_table,
748 pub subclasses: *mut rb_subclass_entry_t,
749 pub parent_subclasses: *mut *mut rb_subclass_entry_t,
750 pub module_subclasses: *mut *mut rb_subclass_entry_t,
751 pub class_serial: rb_serial_t,
752 pub origin: VALUE,
753 pub refined_class: VALUE,
754 pub allocator: rb_alloc_func_t,
755}
756pub const rb_method_flag_t_NOEX_PUBLIC: rb_method_flag_t = 0;
757pub const rb_method_flag_t_NOEX_NOSUPER: rb_method_flag_t = 1;
758pub const rb_method_flag_t_NOEX_PRIVATE: rb_method_flag_t = 2;
759pub const rb_method_flag_t_NOEX_PROTECTED: rb_method_flag_t = 4;
760pub const rb_method_flag_t_NOEX_MASK: rb_method_flag_t = 6;
761pub const rb_method_flag_t_NOEX_BASIC: rb_method_flag_t = 8;
762pub const rb_method_flag_t_NOEX_UNDEF: rb_method_flag_t = 1;
763pub const rb_method_flag_t_NOEX_MODFUNC: rb_method_flag_t = 18;
764pub const rb_method_flag_t_NOEX_SUPER: rb_method_flag_t = 32;
765pub const rb_method_flag_t_NOEX_VCALL: rb_method_flag_t = 64;
766pub const rb_method_flag_t_NOEX_RESPONDS: rb_method_flag_t = 128;
767pub const rb_method_flag_t_NOEX_BIT_WIDTH: rb_method_flag_t = 8;
768pub const rb_method_flag_t_NOEX_SAFE_SHIFT_OFFSET: rb_method_flag_t = 8;
769pub type rb_method_flag_t = ::std::os::raw::c_uint;
770pub const rb_method_type_t_VM_METHOD_TYPE_ISEQ: rb_method_type_t = 0;
771pub const rb_method_type_t_VM_METHOD_TYPE_CFUNC: rb_method_type_t = 1;
772pub const rb_method_type_t_VM_METHOD_TYPE_ATTRSET: rb_method_type_t = 2;
773pub const rb_method_type_t_VM_METHOD_TYPE_IVAR: rb_method_type_t = 3;
774pub const rb_method_type_t_VM_METHOD_TYPE_BMETHOD: rb_method_type_t = 4;
775pub const rb_method_type_t_VM_METHOD_TYPE_ZSUPER: rb_method_type_t = 5;
776pub const rb_method_type_t_VM_METHOD_TYPE_UNDEF: rb_method_type_t = 6;
777pub const rb_method_type_t_VM_METHOD_TYPE_NOTIMPLEMENTED: rb_method_type_t = 7;
778pub const rb_method_type_t_VM_METHOD_TYPE_OPTIMIZED: rb_method_type_t = 8;
779pub const rb_method_type_t_VM_METHOD_TYPE_MISSING: rb_method_type_t = 9;
780pub const rb_method_type_t_VM_METHOD_TYPE_REFINED: rb_method_type_t = 10;
781pub type rb_method_type_t = ::std::os::raw::c_uint;
782#[repr(C)]
783#[derive(Debug, Copy, Clone)]
784pub struct rb_method_cfunc_struct {
785 pub func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
786 pub invoker: ::std::option::Option<
787 unsafe extern "C" fn(
788 func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
789 recv: VALUE,
790 argc: ::std::os::raw::c_int,
791 argv: *const VALUE,
792 ) -> VALUE,
793 >,
794 pub argc: ::std::os::raw::c_int,
795}
796pub type rb_method_cfunc_t = rb_method_cfunc_struct;
797#[repr(C)]
798#[derive(Debug, Copy, Clone)]
799pub struct rb_method_attr_struct {
800 pub id: ID,
801 pub location: VALUE,
802}
803pub type rb_method_attr_t = rb_method_attr_struct;
804pub type rb_iseq_t = rb_iseq_struct;
805#[repr(C)]
806#[derive(Copy, Clone)]
807pub struct rb_method_definition_struct {
808 pub type_: rb_method_type_t,
809 pub alias_count: ::std::os::raw::c_int,
810 pub original_id: ID,
811 pub body: rb_method_definition_struct__bindgen_ty_1,
812}
813#[repr(C)]
814#[derive(Copy, Clone)]
815pub union rb_method_definition_struct__bindgen_ty_1 {
816 pub iseq: *mut rb_iseq_t,
817 pub cfunc: rb_method_cfunc_t,
818 pub attr: rb_method_attr_t,
819 pub proc_: VALUE,
820 pub optimize_type: rb_method_definition_struct__bindgen_ty_1_method_optimized_type,
821 pub orig_me: *mut rb_method_entry_struct,
822}
823pub const rb_method_definition_struct__bindgen_ty_1_method_optimized_type_OPTIMIZED_METHOD_TYPE_SEND : rb_method_definition_struct__bindgen_ty_1_method_optimized_type = 0 ;
824pub const rb_method_definition_struct__bindgen_ty_1_method_optimized_type_OPTIMIZED_METHOD_TYPE_CALL : rb_method_definition_struct__bindgen_ty_1_method_optimized_type = 1 ;
825pub const rb_method_definition_struct__bindgen_ty_1_method_optimized_type_OPTIMIZED_METHOD_TYPE__MAX : rb_method_definition_struct__bindgen_ty_1_method_optimized_type = 2 ;
826pub type rb_method_definition_struct__bindgen_ty_1_method_optimized_type = ::std::os::raw::c_uint;
827impl ::std::fmt::Debug for rb_method_definition_struct__bindgen_ty_1 {
828 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
829 write!(f, "rb_method_definition_struct__bindgen_ty_1 {{ union }}")
830 }
831}
832pub type rb_method_definition_t = rb_method_definition_struct;
833#[repr(C)]
834#[derive(Debug, Copy, Clone)]
835pub struct rb_method_entry_struct {
836 pub flag: rb_method_flag_t,
837 pub mark: ::std::os::raw::c_char,
838 pub def: *mut rb_method_definition_t,
839 pub called_id: ID,
840 pub klass: VALUE,
841}
842pub type rb_method_entry_t = rb_method_entry_struct;
843#[repr(C)]
844#[derive(Debug, Copy, Clone)]
845pub struct unlinked_method_entry_list_entry {
846 pub next: *mut unlinked_method_entry_list_entry,
847 pub me: *mut rb_method_entry_t,
848}
849pub type rb_atomic_t = ::std::os::raw::c_uint;
850#[repr(C)]
851#[derive(Debug, Copy, Clone)]
852pub struct list_node {
853 pub next: *mut list_node,
854 pub prev: *mut list_node,
855}
856#[repr(C)]
857#[derive(Debug, Copy, Clone)]
858pub struct list_head {
859 pub n: list_node,
860}
861pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
862pub type rb_nativethread_id_t = pthread_t;
863pub type rb_nativethread_lock_t = pthread_mutex_t;
864#[repr(C)]
865#[derive(Copy, Clone)]
866pub struct rb_thread_cond_struct {
867 pub cond: pthread_cond_t,
868 pub clockid: clockid_t,
869}
870impl ::std::fmt::Debug for rb_thread_cond_struct {
871 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
872 write!(
873 f,
874 "rb_thread_cond_struct {{ cond: {:?}, clockid: {:?} }}",
875 self.cond, self.clockid
876 )
877 }
878}
879pub type rb_nativethread_cond_t = rb_thread_cond_struct;
880#[repr(C)]
881#[derive(Copy, Clone)]
882pub struct native_thread_data_struct {
883 pub signal_thread_list: *mut ::std::os::raw::c_void,
884 pub sleep_cond: rb_nativethread_cond_t,
885}
886impl ::std::fmt::Debug for native_thread_data_struct {
887 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
888 write!(
889 f,
890 "native_thread_data_struct {{ signal_thread_list: {:?}, sleep_cond: {:?} }}",
891 self.signal_thread_list, self.sleep_cond
892 )
893 }
894}
895pub type native_thread_data_t = native_thread_data_struct;
896#[repr(C)]
897#[derive(Copy, Clone)]
898pub struct rb_global_vm_lock_struct {
899 pub acquired: ::std::os::raw::c_ulong,
900 pub lock: rb_nativethread_lock_t,
901 pub waiting: ::std::os::raw::c_ulong,
902 pub cond: rb_nativethread_cond_t,
903 pub switch_cond: rb_nativethread_cond_t,
904 pub switch_wait_cond: rb_nativethread_cond_t,
905 pub need_yield: ::std::os::raw::c_int,
906 pub wait_yield: ::std::os::raw::c_int,
907}
908impl ::std::fmt::Debug for rb_global_vm_lock_struct {
909 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
910 write ! (f , "rb_global_vm_lock_struct {{ acquired: {:?}, lock: {:?}, waiting: {:?}, cond: {:?}, switch_cond: {:?}, switch_wait_cond: {:?}, need_yield: {:?}, wait_yield: {:?} }}" , self . acquired , self . lock , self . waiting , self . cond , self . switch_cond , self . switch_wait_cond , self . need_yield , self . wait_yield)
911 }
912}
913pub type rb_global_vm_lock_t = rb_global_vm_lock_struct;
914#[repr(C)]
915#[derive(Debug, Copy, Clone)]
916pub struct __jmp_buf_tag {
917 pub __jmpbuf: __jmp_buf,
918 pub __mask_was_saved: ::std::os::raw::c_int,
919 pub __saved_mask: __sigset_t,
920}
921pub type jmp_buf = [__jmp_buf_tag; 1usize];
922pub type rb_num_t = usize;
923#[repr(C)]
924#[derive(Debug, Copy, Clone)]
925pub struct iseq_compile_data_ensure_node_stack {
926 _unused: [u8; 0],
927}
928pub type rb_compile_option_t = rb_compile_option_struct;
929#[repr(C)]
930#[derive(Copy, Clone)]
931pub struct iseq_inline_cache_entry {
932 pub ic_serial: rb_serial_t,
933 pub ic_value: iseq_inline_cache_entry__bindgen_ty_1,
934}
935#[repr(C)]
936#[derive(Copy, Clone)]
937pub union iseq_inline_cache_entry__bindgen_ty_1 {
938 pub index: usize,
939 pub value: VALUE,
940}
941impl ::std::fmt::Debug for iseq_inline_cache_entry__bindgen_ty_1 {
942 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
943 write!(f, "iseq_inline_cache_entry__bindgen_ty_1 {{ union }}")
944 }
945}
946impl ::std::fmt::Debug for iseq_inline_cache_entry {
947 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
948 write!(
949 f,
950 "iseq_inline_cache_entry {{ ic_serial: {:?}, ic_value: {:?} }}",
951 self.ic_serial, self.ic_value
952 )
953 }
954}
955#[repr(C)]
956#[derive(Copy, Clone)]
957pub union iseq_inline_storage_entry {
958 pub once: iseq_inline_storage_entry__bindgen_ty_1,
959 pub cache: iseq_inline_cache_entry,
960}
961#[repr(C)]
962#[derive(Debug, Copy, Clone)]
963pub struct iseq_inline_storage_entry__bindgen_ty_1 {
964 pub running_thread: *mut rb_thread_struct,
965 pub value: VALUE,
966}
967impl ::std::fmt::Debug for iseq_inline_storage_entry {
968 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
969 write!(f, "iseq_inline_storage_entry {{ union }}")
970 }
971}
972#[repr(C)]
973#[derive(Debug, Copy, Clone)]
974pub struct rb_call_info_kw_arg_struct {
975 pub keyword_len: ::std::os::raw::c_int,
976 pub keywords: [VALUE; 1usize],
977}
978pub type rb_call_info_kw_arg_t = rb_call_info_kw_arg_struct;
979#[repr(C)]
980#[derive(Copy, Clone)]
981pub struct rb_call_info_struct {
982 pub mid: ID,
983 pub flag: ::std::os::raw::c_uint,
984 pub orig_argc: ::std::os::raw::c_int,
985 pub blockiseq: *mut rb_iseq_t,
986 pub kw_arg: *mut rb_call_info_kw_arg_t,
987 pub method_state: rb_serial_t,
988 pub class_serial: rb_serial_t,
989 pub klass: VALUE,
990 pub me: *const rb_method_entry_t,
991 pub defined_class: VALUE,
992 pub blockptr: *mut rb_block_struct,
993 pub recv: VALUE,
994 pub argc: ::std::os::raw::c_int,
995 pub aux: rb_call_info_struct__bindgen_ty_1,
996 pub call: ::std::option::Option<
997 unsafe extern "C" fn(
998 th: *mut rb_thread_struct,
999 cfp: *mut rb_control_frame_struct,
1000 ci: *mut rb_call_info_struct,
1001 ) -> VALUE,
1002 >,
1003}
1004#[repr(C)]
1005#[derive(Copy, Clone)]
1006pub union rb_call_info_struct__bindgen_ty_1 {
1007 pub opt_pc: ::std::os::raw::c_int,
1008 pub index: ::std::os::raw::c_int,
1009 pub missing_reason: ::std::os::raw::c_int,
1010 pub inc_sp: ::std::os::raw::c_int,
1011}
1012impl ::std::fmt::Debug for rb_call_info_struct__bindgen_ty_1 {
1013 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1014 write!(f, "rb_call_info_struct__bindgen_ty_1 {{ union }}")
1015 }
1016}
1017impl ::std::fmt::Debug for rb_call_info_struct {
1018 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1019 write ! (f , "rb_call_info_struct {{ mid: {:?}, flag: {:?}, orig_argc: {:?}, blockiseq: {:?}, kw_arg: {:?}, method_state: {:?}, class_serial: {:?}, klass: {:?}, me: {:?}, defined_class: {:?}, blockptr: {:?}, recv: {:?}, argc: {:?}, aux: {:?}, call: {:?} }}" , self . mid , self . flag , self . orig_argc , self . blockiseq , self . kw_arg , self . method_state , self . class_serial , self . klass , self . me , self . defined_class , self . blockptr , self . recv , self . argc , self . aux , self . call)
1020 }
1021}
1022pub type rb_call_info_t = rb_call_info_struct;
1023#[repr(C)]
1024#[derive(Debug, Copy, Clone)]
1025pub struct rb_iseq_location_struct {
1026 pub path: VALUE,
1027 pub absolute_path: VALUE,
1028 pub base_label: VALUE,
1029 pub label: VALUE,
1030 pub first_lineno: VALUE,
1031}
1032pub type rb_iseq_location_t = rb_iseq_location_struct;
1033#[repr(C)]
1034#[derive(Debug, Copy, Clone)]
1035pub struct rb_iseq_struct {
1036 pub type_: rb_iseq_struct_iseq_type,
1037 pub stack_max: ::std::os::raw::c_int,
1038 pub location: rb_iseq_location_t,
1039 pub iseq_encoded: *mut VALUE,
1040 pub iseq_size: ::std::os::raw::c_uint,
1041 pub line_info_size: ::std::os::raw::c_uint,
1042 pub mark_ary: VALUE,
1043 pub coverage: VALUE,
1044 pub line_info_table: *mut iseq_line_info_entry,
1045 pub local_table: *mut ID,
1046 pub local_table_size: ::std::os::raw::c_int,
1047 pub local_size: ::std::os::raw::c_int,
1048 pub is_entries: *mut iseq_inline_storage_entry,
1049 pub is_size: ::std::os::raw::c_int,
1050 pub callinfo_size: ::std::os::raw::c_int,
1051 pub callinfo_entries: *mut rb_call_info_t,
1052 pub param: rb_iseq_struct__bindgen_ty_1,
1053 pub catch_table: *mut iseq_catch_table,
1054 pub parent_iseq: *mut rb_iseq_struct,
1055 pub local_iseq: *mut rb_iseq_struct,
1056 pub self_: VALUE,
1057 pub orig: VALUE,
1058 pub cref_stack: *mut NODE,
1059 pub klass: VALUE,
1060 pub defined_method_id: ID,
1061 pub flip_cnt: rb_num_t,
1062 pub compile_data: *mut iseq_compile_data,
1063 pub iseq: *mut VALUE,
1064}
1065pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_TOP: rb_iseq_struct_iseq_type = 0;
1066pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_METHOD: rb_iseq_struct_iseq_type = 1;
1067pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_BLOCK: rb_iseq_struct_iseq_type = 2;
1068pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_CLASS: rb_iseq_struct_iseq_type = 3;
1069pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_RESCUE: rb_iseq_struct_iseq_type = 4;
1070pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_ENSURE: rb_iseq_struct_iseq_type = 5;
1071pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_EVAL: rb_iseq_struct_iseq_type = 6;
1072pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_MAIN: rb_iseq_struct_iseq_type = 7;
1073pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_DEFINED_GUARD: rb_iseq_struct_iseq_type = 8;
1074pub type rb_iseq_struct_iseq_type = ::std::os::raw::c_uint;
1075#[repr(C)]
1076#[derive(Debug, Copy, Clone)]
1077pub struct rb_iseq_struct__bindgen_ty_1 {
1078 pub flags: rb_iseq_struct__bindgen_ty_1__bindgen_ty_1,
1079 pub size: ::std::os::raw::c_int,
1080 pub lead_num: ::std::os::raw::c_int,
1081 pub opt_num: ::std::os::raw::c_int,
1082 pub rest_start: ::std::os::raw::c_int,
1083 pub post_start: ::std::os::raw::c_int,
1084 pub post_num: ::std::os::raw::c_int,
1085 pub block_start: ::std::os::raw::c_int,
1086 pub opt_table: *mut VALUE,
1087 pub keyword: *mut rb_iseq_struct__bindgen_ty_1_rb_iseq_param_keyword,
1088}
1089#[repr(C)]
1090#[repr(align(4))]
1091#[derive(Debug, Copy, Clone)]
1092pub struct rb_iseq_struct__bindgen_ty_1__bindgen_ty_1 {
1093 pub _bitfield_align_1: [u8; 0],
1094 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1095 pub __bindgen_padding_0: [u8; 3usize],
1096}
1097impl rb_iseq_struct__bindgen_ty_1__bindgen_ty_1 {
1098 #[inline]
1099 pub fn has_lead(&self) -> ::std::os::raw::c_uint {
1100 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1101 }
1102 #[inline]
1103 pub fn set_has_lead(&mut self, val: ::std::os::raw::c_uint) {
1104 unsafe {
1105 let val: u32 = ::std::mem::transmute(val);
1106 self._bitfield_1.set(0usize, 1u8, val as u64)
1107 }
1108 }
1109 #[inline]
1110 pub unsafe fn has_lead_raw(this: *const Self) -> ::std::os::raw::c_uint {
1111 unsafe {
1112 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1113 ::std::ptr::addr_of!((*this)._bitfield_1),
1114 0usize,
1115 1u8,
1116 ) as u32)
1117 }
1118 }
1119 #[inline]
1120 pub unsafe fn set_has_lead_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1121 unsafe {
1122 let val: u32 = ::std::mem::transmute(val);
1123 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1124 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1125 0usize,
1126 1u8,
1127 val as u64,
1128 )
1129 }
1130 }
1131 #[inline]
1132 pub fn has_opt(&self) -> ::std::os::raw::c_uint {
1133 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1134 }
1135 #[inline]
1136 pub fn set_has_opt(&mut self, val: ::std::os::raw::c_uint) {
1137 unsafe {
1138 let val: u32 = ::std::mem::transmute(val);
1139 self._bitfield_1.set(1usize, 1u8, val as u64)
1140 }
1141 }
1142 #[inline]
1143 pub unsafe fn has_opt_raw(this: *const Self) -> ::std::os::raw::c_uint {
1144 unsafe {
1145 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1146 ::std::ptr::addr_of!((*this)._bitfield_1),
1147 1usize,
1148 1u8,
1149 ) as u32)
1150 }
1151 }
1152 #[inline]
1153 pub unsafe fn set_has_opt_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1154 unsafe {
1155 let val: u32 = ::std::mem::transmute(val);
1156 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1157 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1158 1usize,
1159 1u8,
1160 val as u64,
1161 )
1162 }
1163 }
1164 #[inline]
1165 pub fn has_rest(&self) -> ::std::os::raw::c_uint {
1166 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1167 }
1168 #[inline]
1169 pub fn set_has_rest(&mut self, val: ::std::os::raw::c_uint) {
1170 unsafe {
1171 let val: u32 = ::std::mem::transmute(val);
1172 self._bitfield_1.set(2usize, 1u8, val as u64)
1173 }
1174 }
1175 #[inline]
1176 pub unsafe fn has_rest_raw(this: *const Self) -> ::std::os::raw::c_uint {
1177 unsafe {
1178 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1179 ::std::ptr::addr_of!((*this)._bitfield_1),
1180 2usize,
1181 1u8,
1182 ) as u32)
1183 }
1184 }
1185 #[inline]
1186 pub unsafe fn set_has_rest_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1187 unsafe {
1188 let val: u32 = ::std::mem::transmute(val);
1189 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1190 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1191 2usize,
1192 1u8,
1193 val as u64,
1194 )
1195 }
1196 }
1197 #[inline]
1198 pub fn has_post(&self) -> ::std::os::raw::c_uint {
1199 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
1200 }
1201 #[inline]
1202 pub fn set_has_post(&mut self, val: ::std::os::raw::c_uint) {
1203 unsafe {
1204 let val: u32 = ::std::mem::transmute(val);
1205 self._bitfield_1.set(3usize, 1u8, val as u64)
1206 }
1207 }
1208 #[inline]
1209 pub unsafe fn has_post_raw(this: *const Self) -> ::std::os::raw::c_uint {
1210 unsafe {
1211 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1212 ::std::ptr::addr_of!((*this)._bitfield_1),
1213 3usize,
1214 1u8,
1215 ) as u32)
1216 }
1217 }
1218 #[inline]
1219 pub unsafe fn set_has_post_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1220 unsafe {
1221 let val: u32 = ::std::mem::transmute(val);
1222 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1223 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1224 3usize,
1225 1u8,
1226 val as u64,
1227 )
1228 }
1229 }
1230 #[inline]
1231 pub fn has_kw(&self) -> ::std::os::raw::c_uint {
1232 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1233 }
1234 #[inline]
1235 pub fn set_has_kw(&mut self, val: ::std::os::raw::c_uint) {
1236 unsafe {
1237 let val: u32 = ::std::mem::transmute(val);
1238 self._bitfield_1.set(4usize, 1u8, val as u64)
1239 }
1240 }
1241 #[inline]
1242 pub unsafe fn has_kw_raw(this: *const Self) -> ::std::os::raw::c_uint {
1243 unsafe {
1244 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1245 ::std::ptr::addr_of!((*this)._bitfield_1),
1246 4usize,
1247 1u8,
1248 ) as u32)
1249 }
1250 }
1251 #[inline]
1252 pub unsafe fn set_has_kw_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1253 unsafe {
1254 let val: u32 = ::std::mem::transmute(val);
1255 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1256 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1257 4usize,
1258 1u8,
1259 val as u64,
1260 )
1261 }
1262 }
1263 #[inline]
1264 pub fn has_kwrest(&self) -> ::std::os::raw::c_uint {
1265 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1266 }
1267 #[inline]
1268 pub fn set_has_kwrest(&mut self, val: ::std::os::raw::c_uint) {
1269 unsafe {
1270 let val: u32 = ::std::mem::transmute(val);
1271 self._bitfield_1.set(5usize, 1u8, val as u64)
1272 }
1273 }
1274 #[inline]
1275 pub unsafe fn has_kwrest_raw(this: *const Self) -> ::std::os::raw::c_uint {
1276 unsafe {
1277 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1278 ::std::ptr::addr_of!((*this)._bitfield_1),
1279 5usize,
1280 1u8,
1281 ) as u32)
1282 }
1283 }
1284 #[inline]
1285 pub unsafe fn set_has_kwrest_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1286 unsafe {
1287 let val: u32 = ::std::mem::transmute(val);
1288 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1289 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1290 5usize,
1291 1u8,
1292 val as u64,
1293 )
1294 }
1295 }
1296 #[inline]
1297 pub fn has_block(&self) -> ::std::os::raw::c_uint {
1298 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1299 }
1300 #[inline]
1301 pub fn set_has_block(&mut self, val: ::std::os::raw::c_uint) {
1302 unsafe {
1303 let val: u32 = ::std::mem::transmute(val);
1304 self._bitfield_1.set(6usize, 1u8, val as u64)
1305 }
1306 }
1307 #[inline]
1308 pub unsafe fn has_block_raw(this: *const Self) -> ::std::os::raw::c_uint {
1309 unsafe {
1310 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1311 ::std::ptr::addr_of!((*this)._bitfield_1),
1312 6usize,
1313 1u8,
1314 ) as u32)
1315 }
1316 }
1317 #[inline]
1318 pub unsafe fn set_has_block_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1319 unsafe {
1320 let val: u32 = ::std::mem::transmute(val);
1321 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1322 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1323 6usize,
1324 1u8,
1325 val as u64,
1326 )
1327 }
1328 }
1329 #[inline]
1330 pub fn ambiguous_param0(&self) -> ::std::os::raw::c_uint {
1331 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
1332 }
1333 #[inline]
1334 pub fn set_ambiguous_param0(&mut self, val: ::std::os::raw::c_uint) {
1335 unsafe {
1336 let val: u32 = ::std::mem::transmute(val);
1337 self._bitfield_1.set(7usize, 1u8, val as u64)
1338 }
1339 }
1340 #[inline]
1341 pub unsafe fn ambiguous_param0_raw(this: *const Self) -> ::std::os::raw::c_uint {
1342 unsafe {
1343 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1344 ::std::ptr::addr_of!((*this)._bitfield_1),
1345 7usize,
1346 1u8,
1347 ) as u32)
1348 }
1349 }
1350 #[inline]
1351 pub unsafe fn set_ambiguous_param0_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1352 unsafe {
1353 let val: u32 = ::std::mem::transmute(val);
1354 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1355 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1356 7usize,
1357 1u8,
1358 val as u64,
1359 )
1360 }
1361 }
1362 #[inline]
1363 pub fn new_bitfield_1(
1364 has_lead: ::std::os::raw::c_uint,
1365 has_opt: ::std::os::raw::c_uint,
1366 has_rest: ::std::os::raw::c_uint,
1367 has_post: ::std::os::raw::c_uint,
1368 has_kw: ::std::os::raw::c_uint,
1369 has_kwrest: ::std::os::raw::c_uint,
1370 has_block: ::std::os::raw::c_uint,
1371 ambiguous_param0: ::std::os::raw::c_uint,
1372 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1373 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1374 __bindgen_bitfield_unit.set(0usize, 1u8, {
1375 let has_lead: u32 = unsafe { ::std::mem::transmute(has_lead) };
1376 has_lead as u64
1377 });
1378 __bindgen_bitfield_unit.set(1usize, 1u8, {
1379 let has_opt: u32 = unsafe { ::std::mem::transmute(has_opt) };
1380 has_opt as u64
1381 });
1382 __bindgen_bitfield_unit.set(2usize, 1u8, {
1383 let has_rest: u32 = unsafe { ::std::mem::transmute(has_rest) };
1384 has_rest as u64
1385 });
1386 __bindgen_bitfield_unit.set(3usize, 1u8, {
1387 let has_post: u32 = unsafe { ::std::mem::transmute(has_post) };
1388 has_post as u64
1389 });
1390 __bindgen_bitfield_unit.set(4usize, 1u8, {
1391 let has_kw: u32 = unsafe { ::std::mem::transmute(has_kw) };
1392 has_kw as u64
1393 });
1394 __bindgen_bitfield_unit.set(5usize, 1u8, {
1395 let has_kwrest: u32 = unsafe { ::std::mem::transmute(has_kwrest) };
1396 has_kwrest as u64
1397 });
1398 __bindgen_bitfield_unit.set(6usize, 1u8, {
1399 let has_block: u32 = unsafe { ::std::mem::transmute(has_block) };
1400 has_block as u64
1401 });
1402 __bindgen_bitfield_unit.set(7usize, 1u8, {
1403 let ambiguous_param0: u32 = unsafe { ::std::mem::transmute(ambiguous_param0) };
1404 ambiguous_param0 as u64
1405 });
1406 __bindgen_bitfield_unit
1407 }
1408}
1409#[repr(C)]
1410#[derive(Debug, Copy, Clone)]
1411pub struct rb_iseq_struct__bindgen_ty_1_rb_iseq_param_keyword {
1412 pub num: ::std::os::raw::c_int,
1413 pub required_num: ::std::os::raw::c_int,
1414 pub bits_start: ::std::os::raw::c_int,
1415 pub rest_start: ::std::os::raw::c_int,
1416 pub table: *mut ID,
1417 pub default_values: *mut VALUE,
1418}
1419#[repr(C)]
1420#[derive(Debug, Copy, Clone)]
1421pub struct rb_objspace {
1422 _unused: [u8; 0],
1423}
1424#[repr(C)]
1425#[derive(Debug, Copy, Clone)]
1426pub struct rb_hook_list_struct {
1427 pub hooks: *mut rb_event_hook_struct,
1428 pub events: rb_event_flag_t,
1429 pub need_clean: ::std::os::raw::c_int,
1430}
1431pub type rb_hook_list_t = rb_hook_list_struct;
1432#[repr(C)]
1433#[derive(Copy, Clone)]
1434pub struct rb_vm_struct {
1435 pub self_: VALUE,
1436 pub gvl: rb_global_vm_lock_t,
1437 pub thread_destruct_lock: rb_nativethread_lock_t,
1438 pub main_thread: *mut rb_thread_struct,
1439 pub running_thread: *mut rb_thread_struct,
1440 pub living_threads: list_head,
1441 pub living_thread_num: usize,
1442 pub thgroup_default: VALUE,
1443 pub running: ::std::os::raw::c_int,
1444 pub thread_abort_on_exception: ::std::os::raw::c_int,
1445 pub trace_running: ::std::os::raw::c_int,
1446 pub sleeper: ::std::os::raw::c_int,
1447 pub mark_object_ary: VALUE,
1448 pub special_exceptions: [VALUE; 4usize],
1449 pub top_self: VALUE,
1450 pub load_path: VALUE,
1451 pub load_path_snapshot: VALUE,
1452 pub load_path_check_cache: VALUE,
1453 pub expanded_load_path: VALUE,
1454 pub loaded_features: VALUE,
1455 pub loaded_features_snapshot: VALUE,
1456 pub loaded_features_index: *mut st_table,
1457 pub loading_table: *mut st_table,
1458 pub trap_list: [rb_vm_struct__bindgen_ty_1; 65usize],
1459 pub event_hooks: rb_hook_list_t,
1460 pub ensure_rollback_table: *mut st_table,
1461 pub postponed_job_buffer: *mut rb_postponed_job_struct,
1462 pub postponed_job_index: ::std::os::raw::c_int,
1463 pub src_encoding_index: ::std::os::raw::c_int,
1464 pub verbose: VALUE,
1465 pub debug: VALUE,
1466 pub orig_progname: VALUE,
1467 pub progname: VALUE,
1468 pub coverages: VALUE,
1469 pub unlinked_method_entry_list: *mut unlinked_method_entry_list_entry,
1470 pub defined_module_hash: VALUE,
1471 pub objspace: *mut rb_objspace,
1472 pub at_exit: RArray,
1473 pub defined_strings: *mut VALUE,
1474 pub frozen_strings: *mut st_table,
1475 pub default_params: rb_vm_struct__bindgen_ty_2,
1476 pub redefined_flag: [::std::os::raw::c_short; 22usize],
1477}
1478#[repr(C)]
1479#[derive(Debug, Copy, Clone)]
1480pub struct rb_vm_struct__bindgen_ty_1 {
1481 pub cmd: VALUE,
1482 pub safe: ::std::os::raw::c_int,
1483}
1484#[repr(C)]
1485#[derive(Debug, Copy, Clone)]
1486pub struct rb_vm_struct__bindgen_ty_2 {
1487 pub thread_vm_stack_size: usize,
1488 pub thread_machine_stack_size: usize,
1489 pub fiber_vm_stack_size: usize,
1490 pub fiber_machine_stack_size: usize,
1491}
1492impl ::std::fmt::Debug for rb_vm_struct {
1493 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1494 write ! (f , "rb_vm_struct {{ self: {:?}, gvl: {:?}, thread_destruct_lock: {:?}, main_thread: {:?}, running_thread: {:?}, living_threads: {:?}, thgroup_default: {:?}, running: {:?}, thread_abort_on_exception: {:?}, trace_running: {:?}, sleeper: {:?}, mark_object_ary: {:?}, special_exceptions: {:?}, top_self: {:?}, load_path: {:?}, load_path_snapshot: {:?}, load_path_check_cache: {:?}, expanded_load_path: {:?}, loaded_features: {:?}, loaded_features_snapshot: {:?}, loaded_features_index: {:?}, loading_table: {:?}, trap_list: {:?}, event_hooks: {:?}, ensure_rollback_table: {:?}, postponed_job_buffer: {:?}, postponed_job_index: {:?}, src_encoding_index: {:?}, verbose: {:?}, debug: {:?}, orig_progname: {:?}, progname: {:?}, coverages: {:?}, unlinked_method_entry_list: {:?}, defined_module_hash: {:?}, objspace: {:?}, at_exit: {:?}, defined_strings: {:?}, frozen_strings: {:?}, default_params: {:?}, redefined_flag: {:?} }}" , self . self_ , self . gvl , self . thread_destruct_lock , self . main_thread , self . running_thread , self . living_threads , self . thgroup_default , self . running , self . thread_abort_on_exception , self . trace_running , self . sleeper , self . mark_object_ary , self . special_exceptions , self . top_self , self . load_path , self . load_path_snapshot , self . load_path_check_cache , self . expanded_load_path , self . loaded_features , self . loaded_features_snapshot , self . loaded_features_index , self . loading_table , self . trap_list , self . event_hooks , self . ensure_rollback_table , self . postponed_job_buffer , self . postponed_job_index , self . src_encoding_index , self . verbose , self . debug , self . orig_progname , self . progname , self . coverages , self . unlinked_method_entry_list , self . defined_module_hash , self . objspace , self . at_exit , self . defined_strings , self . frozen_strings , self . default_params , self . redefined_flag)
1495 }
1496}
1497pub type rb_vm_t = rb_vm_struct;
1498#[repr(C)]
1499#[derive(Debug, Copy, Clone)]
1500pub struct rb_control_frame_struct {
1501 pub pc: *mut VALUE,
1502 pub sp: *mut VALUE,
1503 pub iseq: *mut rb_iseq_t,
1504 pub flag: VALUE,
1505 pub self_: VALUE,
1506 pub klass: VALUE,
1507 pub ep: *mut VALUE,
1508 pub block_iseq: *mut rb_iseq_t,
1509 pub proc_: VALUE,
1510 pub me: *const rb_method_entry_t,
1511}
1512pub type rb_control_frame_t = rb_control_frame_struct;
1513#[repr(C)]
1514#[derive(Debug, Copy, Clone)]
1515pub struct rb_block_struct {
1516 pub self_: VALUE,
1517 pub klass: VALUE,
1518 pub ep: *mut VALUE,
1519 pub iseq: *mut rb_iseq_t,
1520 pub proc_: VALUE,
1521}
1522pub type rb_block_t = rb_block_struct;
1523pub const rb_thread_status_THREAD_RUNNABLE: rb_thread_status = 0;
1524pub const rb_thread_status_THREAD_STOPPED: rb_thread_status = 1;
1525pub const rb_thread_status_THREAD_STOPPED_FOREVER: rb_thread_status = 2;
1526pub const rb_thread_status_THREAD_KILLED: rb_thread_status = 3;
1527pub type rb_thread_status = ::std::os::raw::c_uint;
1528pub type rb_jmpbuf_t = jmp_buf;
1529#[repr(C)]
1530#[derive(Debug, Copy, Clone)]
1531pub struct rb_vm_tag {
1532 pub tag: VALUE,
1533 pub retval: VALUE,
1534 pub buf: rb_jmpbuf_t,
1535 pub prev: *mut rb_vm_tag,
1536}
1537#[repr(C)]
1538#[derive(Debug, Copy, Clone)]
1539pub struct rb_vm_protect_tag {
1540 pub prev: *mut rb_vm_protect_tag,
1541}
1542#[repr(C)]
1543#[derive(Debug, Copy, Clone)]
1544pub struct rb_unblock_callback {
1545 pub func: rb_unblock_function_t,
1546 pub arg: *mut ::std::os::raw::c_void,
1547}
1548#[repr(C)]
1549#[derive(Debug, Copy, Clone)]
1550pub struct rb_mutex_struct {
1551 _unused: [u8; 0],
1552}
1553#[repr(C)]
1554#[derive(Debug, Copy, Clone)]
1555pub struct rb_thread_list_struct {
1556 pub next: *mut rb_thread_list_struct,
1557 pub th: *mut rb_thread_struct,
1558}
1559pub type rb_thread_list_t = rb_thread_list_struct;
1560#[repr(C)]
1561#[derive(Debug, Copy, Clone)]
1562pub struct rb_ensure_entry {
1563 pub marker: VALUE,
1564 pub e_proc: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
1565 pub data2: VALUE,
1566}
1567#[repr(C)]
1568#[derive(Debug, Copy, Clone)]
1569pub struct rb_ensure_list {
1570 pub next: *mut rb_ensure_list,
1571 pub entry: rb_ensure_entry,
1572}
1573pub type rb_ensure_list_t = rb_ensure_list;
1574#[repr(C)]
1575#[derive(Debug, Copy, Clone)]
1576pub struct rb_fiber_struct {
1577 _unused: [u8; 0],
1578}
1579pub type rb_fiber_t = rb_fiber_struct;
1580#[repr(C)]
1581#[derive(Copy, Clone)]
1582pub struct rb_thread_struct {
1583 pub vmlt_node: list_node,
1584 pub self_: VALUE,
1585 pub vm: *mut rb_vm_t,
1586 pub stack: *mut VALUE,
1587 pub stack_size: usize,
1588 pub cfp: *mut rb_control_frame_t,
1589 pub safe_level: ::std::os::raw::c_int,
1590 pub raised_flag: ::std::os::raw::c_int,
1591 pub last_status: VALUE,
1592 pub state: ::std::os::raw::c_int,
1593 pub waiting_fd: ::std::os::raw::c_int,
1594 pub passed_block: *const rb_block_t,
1595 pub passed_bmethod_me: *const rb_method_entry_t,
1596 pub passed_ci: *mut rb_call_info_t,
1597 pub top_self: VALUE,
1598 pub top_wrapper: VALUE,
1599 pub base_block: *mut rb_block_t,
1600 pub root_lep: *mut VALUE,
1601 pub root_svar: VALUE,
1602 pub thread_id: rb_nativethread_id_t,
1603 pub status: rb_thread_status,
1604 pub to_kill: ::std::os::raw::c_int,
1605 pub priority: ::std::os::raw::c_int,
1606 pub mark_stack_len: ::std::os::raw::c_int,
1607 pub native_thread_data: native_thread_data_t,
1608 pub blocking_region_buffer: *mut ::std::os::raw::c_void,
1609 pub thgroup: VALUE,
1610 pub value: VALUE,
1611 pub errinfo: VALUE,
1612 pub pending_interrupt_queue: VALUE,
1613 pub pending_interrupt_mask_stack: VALUE,
1614 pub pending_interrupt_queue_checked: ::std::os::raw::c_int,
1615 pub interrupt_flag: rb_atomic_t,
1616 pub interrupt_mask: ::std::os::raw::c_ulong,
1617 pub interrupt_lock: rb_nativethread_lock_t,
1618 pub interrupt_cond: rb_nativethread_cond_t,
1619 pub unblock: rb_unblock_callback,
1620 pub locking_mutex: VALUE,
1621 pub keeping_mutexes: *mut rb_mutex_struct,
1622 pub tag: *mut rb_vm_tag,
1623 pub protect_tag: *mut rb_vm_protect_tag,
1624 pub parse_in_eval: ::std::os::raw::c_int,
1625 pub mild_compile_error: ::std::os::raw::c_int,
1626 pub local_storage: *mut st_table,
1627 pub local_storage_recursive_hash: VALUE,
1628 pub local_storage_recursive_hash_for_trace: VALUE,
1629 pub join_list: *mut rb_thread_list_t,
1630 pub first_proc: VALUE,
1631 pub first_args: VALUE,
1632 pub first_func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
1633 pub machine: rb_thread_struct__bindgen_ty_1,
1634 pub stat_insn_usage: VALUE,
1635 pub event_hooks: rb_hook_list_t,
1636 pub trace_arg: *mut rb_trace_arg_struct,
1637 pub fiber: *mut rb_fiber_t,
1638 pub root_fiber: *mut rb_fiber_t,
1639 pub root_jmpbuf: rb_jmpbuf_t,
1640 pub ensure_list: *mut rb_ensure_list_t,
1641 pub method_missing_reason: ::std::os::raw::c_int,
1642 pub abort_on_exception: ::std::os::raw::c_int,
1643 pub altstack: *mut ::std::os::raw::c_void,
1644 pub running_time_us: ::std::os::raw::c_ulong,
1645}
1646#[repr(C)]
1647#[derive(Debug, Copy, Clone)]
1648pub struct rb_thread_struct__bindgen_ty_1 {
1649 pub stack_start: *mut VALUE,
1650 pub stack_end: *mut VALUE,
1651 pub stack_maxsize: usize,
1652 pub regs: jmp_buf,
1653}
1654impl ::std::fmt::Debug for rb_thread_struct {
1655 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1656 write ! (f , "rb_thread_struct {{ vmlt_node: {:?}, self: {:?}, vm: {:?}, stack: {:?}, cfp: {:?}, safe_level: {:?}, raised_flag: {:?}, last_status: {:?}, state: {:?}, waiting_fd: {:?}, passed_block: {:?}, passed_bmethod_me: {:?}, passed_ci: {:?}, top_self: {:?}, top_wrapper: {:?}, base_block: {:?}, root_lep: {:?}, root_svar: {:?}, thread_id: {:?}, status: {:?}, to_kill: {:?}, priority: {:?}, mark_stack_len: {:?}, native_thread_data: {:?}, blocking_region_buffer: {:?}, thgroup: {:?}, value: {:?}, errinfo: {:?}, pending_interrupt_queue: {:?}, pending_interrupt_mask_stack: {:?}, pending_interrupt_queue_checked: {:?}, interrupt_flag: {:?}, interrupt_mask: {:?}, interrupt_lock: {:?}, interrupt_cond: {:?}, unblock: {:?}, locking_mutex: {:?}, keeping_mutexes: {:?}, tag: {:?}, protect_tag: {:?}, parse_in_eval: {:?}, mild_compile_error: {:?}, local_storage: {:?}, local_storage_recursive_hash: {:?}, local_storage_recursive_hash_for_trace: {:?}, join_list: {:?}, first_proc: {:?}, first_args: {:?}, first_func: {:?}, machine: {:?}, stat_insn_usage: {:?}, event_hooks: {:?}, trace_arg: {:?}, fiber: {:?}, root_fiber: {:?}, root_jmpbuf: {:?}, ensure_list: {:?}, method_missing_reason: {:?}, abort_on_exception: {:?}, altstack: {:?}, running_time_us: {:?} }}" , self . vmlt_node , self . self_ , self . vm , self . stack , self . cfp , self . safe_level , self . raised_flag , self . last_status , self . state , self . waiting_fd , self . passed_block , self . passed_bmethod_me , self . passed_ci , self . top_self , self . top_wrapper , self . base_block , self . root_lep , self . root_svar , self . thread_id , self . status , self . to_kill , self . priority , self . mark_stack_len , self . native_thread_data , self . blocking_region_buffer , self . thgroup , self . value , self . errinfo , self . pending_interrupt_queue , self . pending_interrupt_mask_stack , self . pending_interrupt_queue_checked , self . interrupt_flag , self . interrupt_mask , self . interrupt_lock , self . interrupt_cond , self . unblock , self . locking_mutex , self . keeping_mutexes , self . tag , self . protect_tag , self . parse_in_eval , self . mild_compile_error , self . local_storage , self . local_storage_recursive_hash , self . local_storage_recursive_hash_for_trace , self . join_list , self . first_proc , self . first_args , self . first_func , self . machine , self . stat_insn_usage , self . event_hooks , self . trace_arg , self . fiber , self . root_fiber , self . root_jmpbuf , self . ensure_list , self . method_missing_reason , self . abort_on_exception , self . altstack , self . running_time_us)
1657 }
1658}
1659pub type rb_thread_t = rb_thread_struct;
1660#[repr(C)]
1661#[derive(Debug, Copy, Clone)]
1662pub struct rb_trace_arg_struct {
1663 pub event: rb_event_flag_t,
1664 pub th: *mut rb_thread_t,
1665 pub cfp: *mut rb_control_frame_t,
1666 pub self_: VALUE,
1667 pub id: ID,
1668 pub klass: VALUE,
1669 pub data: VALUE,
1670 pub klass_solved: ::std::os::raw::c_int,
1671 pub lineno: ::std::os::raw::c_int,
1672 pub path: VALUE,
1673}
1674#[repr(C)]
1675#[derive(Debug, Copy, Clone)]
1676pub struct rb_compile_option_struct {
1677 pub inline_const_cache: ::std::os::raw::c_int,
1678 pub peephole_optimization: ::std::os::raw::c_int,
1679 pub tailcall_optimization: ::std::os::raw::c_int,
1680 pub specialized_instruction: ::std::os::raw::c_int,
1681 pub operands_unification: ::std::os::raw::c_int,
1682 pub instructions_unification: ::std::os::raw::c_int,
1683 pub stack_caching: ::std::os::raw::c_int,
1684 pub trace_instruction: ::std::os::raw::c_int,
1685 pub debug_level: ::std::os::raw::c_int,
1686}
1687#[repr(C)]
1688#[derive(Debug, Copy, Clone)]
1689pub struct iseq_line_info_entry {
1690 pub position: ::std::os::raw::c_uint,
1691 pub line_no: ::std::os::raw::c_uint,
1692}
1693#[repr(C)]
1694#[derive(Debug, Copy, Clone)]
1695pub struct iseq_catch_table_entry {
1696 pub type_: iseq_catch_table_entry_catch_type,
1697 pub iseq: VALUE,
1698 pub start: ::std::os::raw::c_uint,
1699 pub end: ::std::os::raw::c_uint,
1700 pub cont: ::std::os::raw::c_uint,
1701 pub sp: ::std::os::raw::c_uint,
1702}
1703pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_RESCUE: iseq_catch_table_entry_catch_type =
1704 3;
1705pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_ENSURE: iseq_catch_table_entry_catch_type =
1706 5;
1707pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_RETRY: iseq_catch_table_entry_catch_type = 7;
1708pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_BREAK: iseq_catch_table_entry_catch_type = 9;
1709pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_REDO: iseq_catch_table_entry_catch_type = 11;
1710pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_NEXT: iseq_catch_table_entry_catch_type = 13;
1711pub type iseq_catch_table_entry_catch_type = ::std::os::raw::c_uint;
1712#[repr(C)]
1713#[derive(Copy, Clone)]
1714pub struct iseq_catch_table {
1715 pub size: ::std::os::raw::c_int,
1716 pub entries: [iseq_catch_table_entry; 1usize],
1717}
1718#[repr(C)]
1719#[derive(Debug, Copy, Clone)]
1720pub struct iseq_compile_data_storage {
1721 pub next: *mut iseq_compile_data_storage,
1722 pub pos: ::std::os::raw::c_uint,
1723 pub size: ::std::os::raw::c_uint,
1724 pub buff: [::std::os::raw::c_char; 1usize],
1725}
1726#[repr(C)]
1727#[derive(Debug, Copy, Clone)]
1728pub struct iseq_compile_data {
1729 pub err_info: VALUE,
1730 pub mark_ary: VALUE,
1731 pub catch_table_ary: VALUE,
1732 pub start_label: *mut iseq_label_data,
1733 pub end_label: *mut iseq_label_data,
1734 pub redo_label: *mut iseq_label_data,
1735 pub current_block: VALUE,
1736 pub ensure_node: VALUE,
1737 pub for_iseq: VALUE,
1738 pub ensure_node_stack: *mut iseq_compile_data_ensure_node_stack,
1739 pub loopval_popped: ::std::os::raw::c_int,
1740 pub cached_const: ::std::os::raw::c_int,
1741 pub storage_head: *mut iseq_compile_data_storage,
1742 pub storage_current: *mut iseq_compile_data_storage,
1743 pub last_line: ::std::os::raw::c_int,
1744 pub last_coverable_line: ::std::os::raw::c_int,
1745 pub label_no: ::std::os::raw::c_int,
1746 pub node_level: ::std::os::raw::c_int,
1747 pub option: *const rb_compile_option_t,
1748}
1749#[repr(C)]
1750#[derive(Debug, Copy, Clone)]
1751pub struct st_table_entry {
1752 pub _address: u8,
1753}
1754#[repr(C)]
1755#[derive(Debug, Copy, Clone)]
1756pub struct st_packed_entry {
1757 pub _address: u8,
1758}
1759#[repr(C)]
1760#[derive(Debug, Copy, Clone)]
1761pub struct rb_event_hook_struct {
1762 pub _address: u8,
1763}
1764#[repr(C)]
1765#[derive(Debug, Copy, Clone)]
1766pub struct rb_postponed_job_struct {
1767 pub _address: u8,
1768}
1769#[repr(C)]
1770#[derive(Debug, Copy, Clone)]
1771pub struct iseq_label_data {
1772 pub _address: u8,
1773}