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 = usize;
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_LOCAL: ruby_id_types = 0;
587pub const ruby_id_types_RUBY_ID_INSTANCE: ruby_id_types = 1;
588pub const ruby_id_types_RUBY_ID_GLOBAL: ruby_id_types = 3;
589pub const ruby_id_types_RUBY_ID_ATTRSET: ruby_id_types = 4;
590pub const ruby_id_types_RUBY_ID_CONST: ruby_id_types = 5;
591pub const ruby_id_types_RUBY_ID_CLASS: ruby_id_types = 6;
592pub const ruby_id_types_RUBY_ID_JUNK: ruby_id_types = 7;
593pub const ruby_id_types_RUBY_ID_INTERNAL: ruby_id_types = 7;
594pub const ruby_id_types_RUBY_ID_SCOPE_SHIFT: ruby_id_types = 3;
595pub const ruby_id_types_RUBY_ID_SCOPE_MASK: ruby_id_types = 7;
596pub type ruby_id_types = ::std::os::raw::c_uint;
597pub const ruby_method_ids_idDot2: ruby_method_ids = 128;
598pub const ruby_method_ids_idDot3: ruby_method_ids = 129;
599pub const ruby_method_ids_idUPlus: ruby_method_ids = 130;
600pub const ruby_method_ids_idUMinus: ruby_method_ids = 131;
601pub const ruby_method_ids_idPow: ruby_method_ids = 132;
602pub const ruby_method_ids_idCmp: ruby_method_ids = 134;
603pub const ruby_method_ids_idPLUS: ruby_method_ids = 43;
604pub const ruby_method_ids_idMINUS: ruby_method_ids = 45;
605pub const ruby_method_ids_idMULT: ruby_method_ids = 42;
606pub const ruby_method_ids_idDIV: ruby_method_ids = 47;
607pub const ruby_method_ids_idMOD: ruby_method_ids = 37;
608pub const ruby_method_ids_idLT: ruby_method_ids = 60;
609pub const ruby_method_ids_idLTLT: ruby_method_ids = 135;
610pub const ruby_method_ids_idLE: ruby_method_ids = 137;
611pub const ruby_method_ids_idGT: ruby_method_ids = 62;
612pub const ruby_method_ids_idGE: ruby_method_ids = 138;
613pub const ruby_method_ids_idEq: ruby_method_ids = 139;
614pub const ruby_method_ids_idEqq: ruby_method_ids = 140;
615pub const ruby_method_ids_idNeq: ruby_method_ids = 141;
616pub const ruby_method_ids_idNot: ruby_method_ids = 33;
617pub const ruby_method_ids_idBackquote: ruby_method_ids = 96;
618pub const ruby_method_ids_idEqTilde: ruby_method_ids = 142;
619pub const ruby_method_ids_idNeqTilde: ruby_method_ids = 143;
620pub const ruby_method_ids_idAREF: ruby_method_ids = 144;
621pub const ruby_method_ids_idASET: ruby_method_ids = 145;
622pub const ruby_method_ids_tPRESERVED_ID_BEGIN: ruby_method_ids = 147;
623pub const ruby_method_ids_idNULL: ruby_method_ids = 148;
624pub const ruby_method_ids_idEmptyP: ruby_method_ids = 149;
625pub const ruby_method_ids_idEqlP: ruby_method_ids = 150;
626pub const ruby_method_ids_idRespond_to: ruby_method_ids = 151;
627pub const ruby_method_ids_idRespond_to_missing: ruby_method_ids = 152;
628pub const ruby_method_ids_idIFUNC: ruby_method_ids = 153;
629pub const ruby_method_ids_idCFUNC: ruby_method_ids = 154;
630pub const ruby_method_ids_id_core_set_method_alias: ruby_method_ids = 155;
631pub const ruby_method_ids_id_core_set_variable_alias: ruby_method_ids = 156;
632pub const ruby_method_ids_id_core_undef_method: ruby_method_ids = 157;
633pub const ruby_method_ids_id_core_define_method: ruby_method_ids = 158;
634pub const ruby_method_ids_id_core_define_singleton_method: ruby_method_ids = 159;
635pub const ruby_method_ids_id_core_set_postexe: ruby_method_ids = 160;
636pub const ruby_method_ids_id_core_hash_from_ary: ruby_method_ids = 161;
637pub const ruby_method_ids_id_core_hash_merge_ary: ruby_method_ids = 162;
638pub const ruby_method_ids_id_core_hash_merge_ptr: ruby_method_ids = 163;
639pub const ruby_method_ids_id_core_hash_merge_kwd: ruby_method_ids = 164;
640pub const ruby_method_ids_tPRESERVED_ID_END: ruby_method_ids = 165;
641pub const ruby_method_ids_tFreeze: ruby_method_ids = 166;
642pub const ruby_method_ids_tInspect: ruby_method_ids = 167;
643pub const ruby_method_ids_tIntern: ruby_method_ids = 168;
644pub const ruby_method_ids_tObject_id: ruby_method_ids = 169;
645pub const ruby_method_ids_tConst_missing: ruby_method_ids = 170;
646pub const ruby_method_ids_tMethodMissing: ruby_method_ids = 171;
647pub const ruby_method_ids_tMethod_added: ruby_method_ids = 172;
648pub const ruby_method_ids_tSingleton_method_added: ruby_method_ids = 173;
649pub const ruby_method_ids_tMethod_removed: ruby_method_ids = 174;
650pub const ruby_method_ids_tSingleton_method_removed: ruby_method_ids = 175;
651pub const ruby_method_ids_tMethod_undefined: ruby_method_ids = 176;
652pub const ruby_method_ids_tSingleton_method_undefined: ruby_method_ids = 177;
653pub const ruby_method_ids_tLength: ruby_method_ids = 178;
654pub const ruby_method_ids_tSize: ruby_method_ids = 179;
655pub const ruby_method_ids_tGets: ruby_method_ids = 180;
656pub const ruby_method_ids_tSucc: ruby_method_ids = 181;
657pub const ruby_method_ids_tEach: ruby_method_ids = 182;
658pub const ruby_method_ids_tProc: ruby_method_ids = 183;
659pub const ruby_method_ids_tLambda: ruby_method_ids = 184;
660pub const ruby_method_ids_tSend: ruby_method_ids = 185;
661pub const ruby_method_ids_t__send__: ruby_method_ids = 186;
662pub const ruby_method_ids_t__attached__: ruby_method_ids = 187;
663pub const ruby_method_ids_tInitialize: ruby_method_ids = 188;
664pub const ruby_method_ids_tInitialize_copy: ruby_method_ids = 189;
665pub const ruby_method_ids_tInitialize_clone: ruby_method_ids = 190;
666pub const ruby_method_ids_tInitialize_dup: ruby_method_ids = 191;
667pub const ruby_method_ids_tUScore: ruby_method_ids = 192;
668pub const ruby_method_ids_idFreeze: ruby_method_ids = 1328;
669pub const ruby_method_ids_idInspect: ruby_method_ids = 1336;
670pub const ruby_method_ids_idIntern: ruby_method_ids = 1344;
671pub const ruby_method_ids_idObject_id: ruby_method_ids = 1352;
672pub const ruby_method_ids_idConst_missing: ruby_method_ids = 1360;
673pub const ruby_method_ids_idMethodMissing: ruby_method_ids = 1368;
674pub const ruby_method_ids_idMethod_added: ruby_method_ids = 1376;
675pub const ruby_method_ids_idSingleton_method_added: ruby_method_ids = 1384;
676pub const ruby_method_ids_idMethod_removed: ruby_method_ids = 1392;
677pub const ruby_method_ids_idSingleton_method_removed: ruby_method_ids = 1400;
678pub const ruby_method_ids_idMethod_undefined: ruby_method_ids = 1408;
679pub const ruby_method_ids_idSingleton_method_undefined: ruby_method_ids = 1416;
680pub const ruby_method_ids_idLength: ruby_method_ids = 1424;
681pub const ruby_method_ids_idSize: ruby_method_ids = 1432;
682pub const ruby_method_ids_idGets: ruby_method_ids = 1440;
683pub const ruby_method_ids_idSucc: ruby_method_ids = 1448;
684pub const ruby_method_ids_idEach: ruby_method_ids = 1456;
685pub const ruby_method_ids_idProc: ruby_method_ids = 1464;
686pub const ruby_method_ids_idLambda: ruby_method_ids = 1472;
687pub const ruby_method_ids_idSend: ruby_method_ids = 1480;
688pub const ruby_method_ids_id__send__: ruby_method_ids = 1488;
689pub const ruby_method_ids_id__attached__: ruby_method_ids = 1496;
690pub const ruby_method_ids_idInitialize: ruby_method_ids = 1504;
691pub const ruby_method_ids_idInitialize_copy: ruby_method_ids = 1512;
692pub const ruby_method_ids_idInitialize_clone: ruby_method_ids = 1520;
693pub const ruby_method_ids_idInitialize_dup: ruby_method_ids = 1528;
694pub const ruby_method_ids_idUScore: ruby_method_ids = 1536;
695pub const ruby_method_ids_tLAST_OP_ID: ruby_method_ids = 164;
696pub const ruby_method_ids_idLAST_OP_ID: ruby_method_ids = 20;
697pub type ruby_method_ids = ::std::os::raw::c_uint;
698pub type rb_subclass_entry_t = rb_subclass_entry;
699#[repr(C)]
700#[derive(Debug, Copy, Clone)]
701pub struct rb_subclass_entry {
702 pub klass: VALUE,
703 pub next: *mut rb_subclass_entry_t,
704}
705pub type rb_serial_t = ::std::os::raw::c_ulonglong;
706#[repr(C)]
707#[derive(Debug, Copy, Clone)]
708pub struct rb_classext_struct {
709 pub iv_index_tbl: *mut st_table,
710 pub iv_tbl: *mut st_table,
711 pub const_tbl: *mut st_table,
712 pub subclasses: *mut rb_subclass_entry_t,
713 pub parent_subclasses: *mut *mut rb_subclass_entry_t,
714 pub module_subclasses: *mut *mut rb_subclass_entry_t,
715 pub class_serial: rb_serial_t,
716 pub origin: VALUE,
717 pub refined_class: VALUE,
718 pub allocator: rb_alloc_func_t,
719}
720pub const rb_method_flag_t_NOEX_PUBLIC: rb_method_flag_t = 0;
721pub const rb_method_flag_t_NOEX_NOSUPER: rb_method_flag_t = 1;
722pub const rb_method_flag_t_NOEX_PRIVATE: rb_method_flag_t = 2;
723pub const rb_method_flag_t_NOEX_PROTECTED: rb_method_flag_t = 4;
724pub const rb_method_flag_t_NOEX_MASK: rb_method_flag_t = 6;
725pub const rb_method_flag_t_NOEX_BASIC: rb_method_flag_t = 8;
726pub const rb_method_flag_t_NOEX_UNDEF: rb_method_flag_t = 1;
727pub const rb_method_flag_t_NOEX_MODFUNC: rb_method_flag_t = 18;
728pub const rb_method_flag_t_NOEX_SUPER: rb_method_flag_t = 32;
729pub const rb_method_flag_t_NOEX_VCALL: rb_method_flag_t = 64;
730pub const rb_method_flag_t_NOEX_RESPONDS: rb_method_flag_t = 128;
731pub const rb_method_flag_t_NOEX_BIT_WIDTH: rb_method_flag_t = 8;
732pub const rb_method_flag_t_NOEX_SAFE_SHIFT_OFFSET: rb_method_flag_t = 8;
733pub type rb_method_flag_t = ::std::os::raw::c_uint;
734pub const rb_method_type_t_VM_METHOD_TYPE_ISEQ: rb_method_type_t = 0;
735pub const rb_method_type_t_VM_METHOD_TYPE_CFUNC: rb_method_type_t = 1;
736pub const rb_method_type_t_VM_METHOD_TYPE_ATTRSET: rb_method_type_t = 2;
737pub const rb_method_type_t_VM_METHOD_TYPE_IVAR: rb_method_type_t = 3;
738pub const rb_method_type_t_VM_METHOD_TYPE_BMETHOD: rb_method_type_t = 4;
739pub const rb_method_type_t_VM_METHOD_TYPE_ZSUPER: rb_method_type_t = 5;
740pub const rb_method_type_t_VM_METHOD_TYPE_UNDEF: rb_method_type_t = 6;
741pub const rb_method_type_t_VM_METHOD_TYPE_NOTIMPLEMENTED: rb_method_type_t = 7;
742pub const rb_method_type_t_VM_METHOD_TYPE_OPTIMIZED: rb_method_type_t = 8;
743pub const rb_method_type_t_VM_METHOD_TYPE_MISSING: rb_method_type_t = 9;
744pub const rb_method_type_t_VM_METHOD_TYPE_REFINED: rb_method_type_t = 10;
745pub type rb_method_type_t = ::std::os::raw::c_uint;
746#[repr(C)]
747#[derive(Debug, Copy, Clone)]
748pub struct rb_method_cfunc_struct {
749 pub func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
750 pub invoker: ::std::option::Option<
751 unsafe extern "C" fn(
752 func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
753 recv: VALUE,
754 argc: ::std::os::raw::c_int,
755 argv: *const VALUE,
756 ) -> VALUE,
757 >,
758 pub argc: ::std::os::raw::c_int,
759}
760pub type rb_method_cfunc_t = rb_method_cfunc_struct;
761#[repr(C)]
762#[derive(Debug, Copy, Clone)]
763pub struct rb_method_attr_struct {
764 pub id: ID,
765 pub location: VALUE,
766}
767pub type rb_method_attr_t = rb_method_attr_struct;
768pub type rb_iseq_t = rb_iseq_struct;
769#[repr(C)]
770#[derive(Copy, Clone)]
771pub struct rb_method_definition_struct {
772 pub type_: rb_method_type_t,
773 pub original_id: ID,
774 pub body: rb_method_definition_struct__bindgen_ty_1,
775 pub alias_count: ::std::os::raw::c_int,
776}
777#[repr(C)]
778#[derive(Copy, Clone)]
779pub union rb_method_definition_struct__bindgen_ty_1 {
780 pub iseq: *mut rb_iseq_t,
781 pub cfunc: rb_method_cfunc_t,
782 pub attr: rb_method_attr_t,
783 pub proc_: VALUE,
784 pub optimize_type: rb_method_definition_struct__bindgen_ty_1_method_optimized_type,
785 pub orig_me: *mut rb_method_entry_struct,
786}
787pub 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 ;
788pub 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 ;
789pub 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 ;
790pub type rb_method_definition_struct__bindgen_ty_1_method_optimized_type = ::std::os::raw::c_uint;
791impl ::std::fmt::Debug for rb_method_definition_struct__bindgen_ty_1 {
792 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
793 write!(f, "rb_method_definition_struct__bindgen_ty_1 {{ union }}")
794 }
795}
796pub type rb_method_definition_t = rb_method_definition_struct;
797#[repr(C)]
798#[derive(Debug, Copy, Clone)]
799pub struct rb_method_entry_struct {
800 pub flag: rb_method_flag_t,
801 pub mark: ::std::os::raw::c_char,
802 pub def: *mut rb_method_definition_t,
803 pub called_id: ID,
804 pub klass: VALUE,
805}
806pub type rb_method_entry_t = rb_method_entry_struct;
807#[repr(C)]
808#[derive(Debug, Copy, Clone)]
809pub struct unlinked_method_entry_list_entry {
810 pub next: *mut unlinked_method_entry_list_entry,
811 pub me: *mut rb_method_entry_t,
812}
813pub type rb_atomic_t = ::std::os::raw::c_uint;
814pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
815pub type rb_nativethread_id_t = pthread_t;
816pub type rb_nativethread_lock_t = pthread_mutex_t;
817#[repr(C)]
818#[derive(Copy, Clone)]
819pub struct rb_thread_cond_struct {
820 pub cond: pthread_cond_t,
821 pub clockid: clockid_t,
822}
823impl ::std::fmt::Debug for rb_thread_cond_struct {
824 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
825 write!(
826 f,
827 "rb_thread_cond_struct {{ cond: {:?}, clockid: {:?} }}",
828 self.cond, self.clockid
829 )
830 }
831}
832pub type rb_nativethread_cond_t = rb_thread_cond_struct;
833#[repr(C)]
834#[derive(Copy, Clone)]
835pub struct native_thread_data_struct {
836 pub signal_thread_list: *mut ::std::os::raw::c_void,
837 pub sleep_cond: rb_nativethread_cond_t,
838}
839impl ::std::fmt::Debug for native_thread_data_struct {
840 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
841 write!(
842 f,
843 "native_thread_data_struct {{ signal_thread_list: {:?}, sleep_cond: {:?} }}",
844 self.signal_thread_list, self.sleep_cond
845 )
846 }
847}
848pub type native_thread_data_t = native_thread_data_struct;
849#[repr(C)]
850#[derive(Copy, Clone)]
851pub struct rb_global_vm_lock_struct {
852 pub acquired: ::std::os::raw::c_ulong,
853 pub lock: pthread_mutex_t,
854 pub waiting: ::std::os::raw::c_ulong,
855 pub cond: rb_nativethread_cond_t,
856 pub switch_cond: rb_nativethread_cond_t,
857 pub switch_wait_cond: rb_nativethread_cond_t,
858 pub need_yield: ::std::os::raw::c_int,
859 pub wait_yield: ::std::os::raw::c_int,
860}
861impl ::std::fmt::Debug for rb_global_vm_lock_struct {
862 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
863 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)
864 }
865}
866pub type rb_global_vm_lock_t = rb_global_vm_lock_struct;
867#[repr(C)]
868#[derive(Debug, Copy, Clone)]
869pub struct __jmp_buf_tag {
870 pub __jmpbuf: __jmp_buf,
871 pub __mask_was_saved: ::std::os::raw::c_int,
872 pub __saved_mask: __sigset_t,
873}
874pub type jmp_buf = [__jmp_buf_tag; 1usize];
875pub type rb_num_t = usize;
876#[repr(C)]
877#[derive(Debug, Copy, Clone)]
878pub struct iseq_compile_data_ensure_node_stack {
879 _unused: [u8; 0],
880}
881pub type rb_compile_option_t = rb_compile_option_struct;
882#[repr(C)]
883#[derive(Copy, Clone)]
884pub struct iseq_inline_cache_entry {
885 pub ic_serial: rb_serial_t,
886 pub ic_value: iseq_inline_cache_entry__bindgen_ty_1,
887}
888#[repr(C)]
889#[derive(Copy, Clone)]
890pub union iseq_inline_cache_entry__bindgen_ty_1 {
891 pub index: usize,
892 pub value: VALUE,
893}
894impl ::std::fmt::Debug for iseq_inline_cache_entry__bindgen_ty_1 {
895 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
896 write!(f, "iseq_inline_cache_entry__bindgen_ty_1 {{ union }}")
897 }
898}
899impl ::std::fmt::Debug for iseq_inline_cache_entry {
900 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
901 write!(
902 f,
903 "iseq_inline_cache_entry {{ ic_serial: {:?}, ic_value: {:?} }}",
904 self.ic_serial, self.ic_value
905 )
906 }
907}
908#[repr(C)]
909#[derive(Copy, Clone)]
910pub union iseq_inline_storage_entry {
911 pub once: iseq_inline_storage_entry__bindgen_ty_1,
912 pub cache: iseq_inline_cache_entry,
913}
914#[repr(C)]
915#[derive(Debug, Copy, Clone)]
916pub struct iseq_inline_storage_entry__bindgen_ty_1 {
917 pub running_thread: *mut rb_thread_struct,
918 pub value: VALUE,
919 pub done: VALUE,
920}
921impl ::std::fmt::Debug for iseq_inline_storage_entry {
922 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
923 write!(f, "iseq_inline_storage_entry {{ union }}")
924 }
925}
926#[repr(C)]
927#[derive(Copy, Clone)]
928pub struct rb_call_info_struct {
929 pub mid: ID,
930 pub flag: VALUE,
931 pub orig_argc: ::std::os::raw::c_int,
932 pub blockiseq: *mut rb_iseq_t,
933 pub method_state: rb_serial_t,
934 pub class_serial: rb_serial_t,
935 pub klass: VALUE,
936 pub me: *const rb_method_entry_t,
937 pub defined_class: VALUE,
938 pub argc: ::std::os::raw::c_int,
939 pub blockptr: *mut rb_block_struct,
940 pub recv: VALUE,
941 pub aux: rb_call_info_struct__bindgen_ty_1,
942 pub call: ::std::option::Option<
943 unsafe extern "C" fn(
944 th: *mut rb_thread_struct,
945 cfp: *mut rb_control_frame_struct,
946 ci: *mut rb_call_info_struct,
947 ) -> VALUE,
948 >,
949}
950#[repr(C)]
951#[derive(Copy, Clone)]
952pub union rb_call_info_struct__bindgen_ty_1 {
953 pub opt_pc: ::std::os::raw::c_int,
954 pub index: ::std::os::raw::c_long,
955 pub missing_reason: ::std::os::raw::c_int,
956 pub inc_sp: ::std::os::raw::c_int,
957}
958impl ::std::fmt::Debug for rb_call_info_struct__bindgen_ty_1 {
959 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
960 write!(f, "rb_call_info_struct__bindgen_ty_1 {{ union }}")
961 }
962}
963impl ::std::fmt::Debug for rb_call_info_struct {
964 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
965 write ! (f , "rb_call_info_struct {{ mid: {:?}, flag: {:?}, orig_argc: {:?}, blockiseq: {:?}, method_state: {:?}, class_serial: {:?}, klass: {:?}, me: {:?}, defined_class: {:?}, argc: {:?}, blockptr: {:?}, recv: {:?}, aux: {:?}, call: {:?} }}" , self . mid , self . flag , self . orig_argc , self . blockiseq , self . method_state , self . class_serial , self . klass , self . me , self . defined_class , self . argc , self . blockptr , self . recv , self . aux , self . call)
966 }
967}
968pub type rb_call_info_t = rb_call_info_struct;
969#[repr(C)]
970#[derive(Debug, Copy, Clone)]
971pub struct rb_iseq_location_struct {
972 pub path: VALUE,
973 pub absolute_path: VALUE,
974 pub base_label: VALUE,
975 pub label: VALUE,
976 pub first_lineno: usize,
977}
978pub type rb_iseq_location_t = rb_iseq_location_struct;
979#[repr(C)]
980#[derive(Debug, Copy, Clone)]
981pub struct rb_iseq_struct {
982 pub type_: rb_iseq_struct_iseq_type,
983 pub location: rb_iseq_location_t,
984 pub iseq: *mut VALUE,
985 pub iseq_encoded: *mut VALUE,
986 pub iseq_size: ::std::os::raw::c_ulong,
987 pub mark_ary: VALUE,
988 pub coverage: VALUE,
989 pub line_info_table: *mut iseq_line_info_entry,
990 pub line_info_size: usize,
991 pub local_table: *mut ID,
992 pub local_table_size: ::std::os::raw::c_int,
993 pub local_size: ::std::os::raw::c_int,
994 pub is_entries: *mut iseq_inline_storage_entry,
995 pub is_size: ::std::os::raw::c_int,
996 pub callinfo_entries: *mut rb_call_info_t,
997 pub callinfo_size: ::std::os::raw::c_int,
998 pub argc: ::std::os::raw::c_int,
999 pub arg_simple: ::std::os::raw::c_int,
1000 pub arg_rest: ::std::os::raw::c_int,
1001 pub arg_block: ::std::os::raw::c_int,
1002 pub arg_opts: ::std::os::raw::c_int,
1003 pub arg_post_len: ::std::os::raw::c_int,
1004 pub arg_post_start: ::std::os::raw::c_int,
1005 pub arg_size: ::std::os::raw::c_int,
1006 pub arg_opt_table: *mut VALUE,
1007 pub arg_keyword: ::std::os::raw::c_int,
1008 pub arg_keyword_check: ::std::os::raw::c_int,
1009 pub arg_keywords: ::std::os::raw::c_int,
1010 pub arg_keyword_required: ::std::os::raw::c_int,
1011 pub arg_keyword_table: *mut ID,
1012 pub stack_max: usize,
1013 pub catch_table: *mut iseq_catch_table_entry,
1014 pub catch_table_size: ::std::os::raw::c_int,
1015 pub parent_iseq: *mut rb_iseq_struct,
1016 pub local_iseq: *mut rb_iseq_struct,
1017 pub self_: VALUE,
1018 pub orig: VALUE,
1019 pub cref_stack: *mut NODE,
1020 pub klass: VALUE,
1021 pub defined_method_id: ID,
1022 pub flip_cnt: rb_num_t,
1023 pub compile_data: *mut iseq_compile_data,
1024}
1025pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_TOP: rb_iseq_struct_iseq_type = 0;
1026pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_METHOD: rb_iseq_struct_iseq_type = 1;
1027pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_BLOCK: rb_iseq_struct_iseq_type = 2;
1028pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_CLASS: rb_iseq_struct_iseq_type = 3;
1029pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_RESCUE: rb_iseq_struct_iseq_type = 4;
1030pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_ENSURE: rb_iseq_struct_iseq_type = 5;
1031pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_EVAL: rb_iseq_struct_iseq_type = 6;
1032pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_MAIN: rb_iseq_struct_iseq_type = 7;
1033pub const rb_iseq_struct_iseq_type_ISEQ_TYPE_DEFINED_GUARD: rb_iseq_struct_iseq_type = 8;
1034pub type rb_iseq_struct_iseq_type = ::std::os::raw::c_uint;
1035#[repr(C)]
1036#[derive(Debug, Copy, Clone)]
1037pub struct rb_objspace {
1038 _unused: [u8; 0],
1039}
1040#[repr(C)]
1041#[derive(Debug, Copy, Clone)]
1042pub struct rb_hook_list_struct {
1043 pub hooks: *mut rb_event_hook_struct,
1044 pub events: rb_event_flag_t,
1045 pub need_clean: ::std::os::raw::c_int,
1046}
1047pub type rb_hook_list_t = rb_hook_list_struct;
1048#[repr(C)]
1049#[derive(Copy, Clone)]
1050pub struct rb_vm_struct {
1051 pub self_: VALUE,
1052 pub gvl: rb_global_vm_lock_t,
1053 pub thread_destruct_lock: rb_nativethread_lock_t,
1054 pub main_thread: *mut rb_thread_struct,
1055 pub running_thread: *mut rb_thread_struct,
1056 pub living_threads: *mut st_table,
1057 pub thgroup_default: VALUE,
1058 pub running: ::std::os::raw::c_int,
1059 pub thread_abort_on_exception: ::std::os::raw::c_int,
1060 pub trace_running: ::std::os::raw::c_int,
1061 pub sleeper: ::std::os::raw::c_int,
1062 pub mark_object_ary: VALUE,
1063 pub special_exceptions: [VALUE; 4usize],
1064 pub top_self: VALUE,
1065 pub load_path: VALUE,
1066 pub load_path_snapshot: VALUE,
1067 pub load_path_check_cache: VALUE,
1068 pub expanded_load_path: VALUE,
1069 pub loaded_features: VALUE,
1070 pub loaded_features_snapshot: VALUE,
1071 pub loaded_features_index: *mut st_table,
1072 pub loading_table: *mut st_table,
1073 pub trap_list: [rb_vm_struct__bindgen_ty_1; 65usize],
1074 pub event_hooks: rb_hook_list_t,
1075 pub ensure_rollback_table: *mut st_table,
1076 pub postponed_job_buffer: *mut rb_postponed_job_struct,
1077 pub postponed_job_index: ::std::os::raw::c_int,
1078 pub src_encoding_index: ::std::os::raw::c_int,
1079 pub verbose: VALUE,
1080 pub debug: VALUE,
1081 pub orig_progname: VALUE,
1082 pub progname: VALUE,
1083 pub coverages: VALUE,
1084 pub unlinked_method_entry_list: *mut unlinked_method_entry_list_entry,
1085 pub defined_module_hash: VALUE,
1086 pub objspace: *mut rb_objspace,
1087 pub at_exit: RArray,
1088 pub defined_strings: *mut VALUE,
1089 pub default_params: rb_vm_struct__bindgen_ty_2,
1090}
1091#[repr(C)]
1092#[derive(Debug, Copy, Clone)]
1093pub struct rb_vm_struct__bindgen_ty_1 {
1094 pub cmd: VALUE,
1095 pub safe: ::std::os::raw::c_int,
1096}
1097#[repr(C)]
1098#[derive(Debug, Copy, Clone)]
1099pub struct rb_vm_struct__bindgen_ty_2 {
1100 pub thread_vm_stack_size: usize,
1101 pub thread_machine_stack_size: usize,
1102 pub fiber_vm_stack_size: usize,
1103 pub fiber_machine_stack_size: usize,
1104}
1105impl ::std::fmt::Debug for rb_vm_struct {
1106 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1107 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: {:?}, default_params: {:?} }}" , 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 . default_params)
1108 }
1109}
1110pub type rb_vm_t = rb_vm_struct;
1111#[repr(C)]
1112#[derive(Debug, Copy, Clone)]
1113pub struct rb_control_frame_struct {
1114 pub pc: *mut VALUE,
1115 pub sp: *mut VALUE,
1116 pub iseq: *mut rb_iseq_t,
1117 pub flag: VALUE,
1118 pub self_: VALUE,
1119 pub klass: VALUE,
1120 pub ep: *mut VALUE,
1121 pub block_iseq: *mut rb_iseq_t,
1122 pub proc_: VALUE,
1123 pub me: *const rb_method_entry_t,
1124}
1125pub type rb_control_frame_t = rb_control_frame_struct;
1126#[repr(C)]
1127#[derive(Debug, Copy, Clone)]
1128pub struct rb_block_struct {
1129 pub self_: VALUE,
1130 pub klass: VALUE,
1131 pub ep: *mut VALUE,
1132 pub iseq: *mut rb_iseq_t,
1133 pub proc_: VALUE,
1134}
1135pub type rb_block_t = rb_block_struct;
1136pub const rb_thread_status_THREAD_RUNNABLE: rb_thread_status = 0;
1137pub const rb_thread_status_THREAD_STOPPED: rb_thread_status = 1;
1138pub const rb_thread_status_THREAD_STOPPED_FOREVER: rb_thread_status = 2;
1139pub const rb_thread_status_THREAD_KILLED: rb_thread_status = 3;
1140pub type rb_thread_status = ::std::os::raw::c_uint;
1141pub type rb_jmpbuf_t = jmp_buf;
1142#[repr(C)]
1143#[derive(Debug, Copy, Clone)]
1144pub struct rb_vm_tag {
1145 pub tag: VALUE,
1146 pub retval: VALUE,
1147 pub buf: rb_jmpbuf_t,
1148 pub prev: *mut rb_vm_tag,
1149}
1150#[repr(C)]
1151#[derive(Debug, Copy, Clone)]
1152pub struct rb_vm_protect_tag {
1153 pub prev: *mut rb_vm_protect_tag,
1154}
1155#[repr(C)]
1156#[derive(Debug, Copy, Clone)]
1157pub struct rb_unblock_callback {
1158 pub func: rb_unblock_function_t,
1159 pub arg: *mut ::std::os::raw::c_void,
1160}
1161#[repr(C)]
1162#[derive(Debug, Copy, Clone)]
1163pub struct rb_mutex_struct {
1164 _unused: [u8; 0],
1165}
1166#[repr(C)]
1167#[derive(Debug, Copy, Clone)]
1168pub struct rb_thread_list_struct {
1169 pub next: *mut rb_thread_list_struct,
1170 pub th: *mut rb_thread_struct,
1171}
1172pub type rb_thread_list_t = rb_thread_list_struct;
1173#[repr(C)]
1174#[derive(Debug, Copy, Clone)]
1175pub struct rb_ensure_entry {
1176 pub marker: VALUE,
1177 pub e_proc: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
1178 pub data2: VALUE,
1179}
1180#[repr(C)]
1181#[derive(Debug, Copy, Clone)]
1182pub struct rb_ensure_list {
1183 pub next: *mut rb_ensure_list,
1184 pub entry: rb_ensure_entry,
1185}
1186pub type rb_ensure_list_t = rb_ensure_list;
1187#[repr(C)]
1188#[derive(Copy, Clone)]
1189pub struct rb_thread_struct {
1190 pub self_: VALUE,
1191 pub vm: *mut rb_vm_t,
1192 pub stack: *mut VALUE,
1193 pub stack_size: usize,
1194 pub cfp: *mut rb_control_frame_t,
1195 pub safe_level: ::std::os::raw::c_int,
1196 pub raised_flag: ::std::os::raw::c_int,
1197 pub last_status: VALUE,
1198 pub state: ::std::os::raw::c_int,
1199 pub waiting_fd: ::std::os::raw::c_int,
1200 pub passed_block: *const rb_block_t,
1201 pub passed_bmethod_me: *const rb_method_entry_t,
1202 pub passed_ci: *mut rb_call_info_t,
1203 pub top_self: VALUE,
1204 pub top_wrapper: VALUE,
1205 pub base_block: *mut rb_block_t,
1206 pub root_lep: *mut VALUE,
1207 pub root_svar: VALUE,
1208 pub thread_id: rb_nativethread_id_t,
1209 pub status: rb_thread_status,
1210 pub to_kill: ::std::os::raw::c_int,
1211 pub priority: ::std::os::raw::c_int,
1212 pub native_thread_data: native_thread_data_t,
1213 pub blocking_region_buffer: *mut ::std::os::raw::c_void,
1214 pub thgroup: VALUE,
1215 pub value: VALUE,
1216 pub errinfo: VALUE,
1217 pub pending_interrupt_queue: VALUE,
1218 pub pending_interrupt_queue_checked: ::std::os::raw::c_int,
1219 pub pending_interrupt_mask_stack: VALUE,
1220 pub interrupt_flag: rb_atomic_t,
1221 pub interrupt_mask: ::std::os::raw::c_ulong,
1222 pub interrupt_lock: rb_nativethread_lock_t,
1223 pub interrupt_cond: rb_nativethread_cond_t,
1224 pub unblock: rb_unblock_callback,
1225 pub locking_mutex: VALUE,
1226 pub keeping_mutexes: *mut rb_mutex_struct,
1227 pub tag: *mut rb_vm_tag,
1228 pub protect_tag: *mut rb_vm_protect_tag,
1229 pub parse_in_eval: ::std::os::raw::c_int,
1230 pub mild_compile_error: ::std::os::raw::c_int,
1231 pub local_storage: *mut st_table,
1232 pub join_list: *mut rb_thread_list_t,
1233 pub first_proc: VALUE,
1234 pub first_args: VALUE,
1235 pub first_func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
1236 pub machine: rb_thread_struct__bindgen_ty_1,
1237 pub mark_stack_len: ::std::os::raw::c_int,
1238 pub stat_insn_usage: VALUE,
1239 pub event_hooks: rb_hook_list_t,
1240 pub trace_arg: *mut rb_trace_arg_struct,
1241 pub fiber: VALUE,
1242 pub root_fiber: VALUE,
1243 pub root_jmpbuf: rb_jmpbuf_t,
1244 pub ensure_list: *mut rb_ensure_list_t,
1245 pub method_missing_reason: ::std::os::raw::c_int,
1246 pub abort_on_exception: ::std::os::raw::c_int,
1247 pub altstack: *mut ::std::os::raw::c_void,
1248 pub running_time_us: ::std::os::raw::c_ulong,
1249}
1250#[repr(C)]
1251#[derive(Debug, Copy, Clone)]
1252pub struct rb_thread_struct__bindgen_ty_1 {
1253 pub stack_start: *mut VALUE,
1254 pub stack_end: *mut VALUE,
1255 pub stack_maxsize: usize,
1256 pub regs: jmp_buf,
1257}
1258impl ::std::fmt::Debug for rb_thread_struct {
1259 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1260 write ! (f , "rb_thread_struct {{ 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: {:?}, native_thread_data: {:?}, blocking_region_buffer: {:?}, thgroup: {:?}, value: {:?}, errinfo: {:?}, pending_interrupt_queue: {:?}, pending_interrupt_queue_checked: {:?}, pending_interrupt_mask_stack: {:?}, interrupt_flag: {:?}, interrupt_mask: {:?}, interrupt_lock: {:?}, interrupt_cond: {:?}, unblock: {:?}, locking_mutex: {:?}, keeping_mutexes: {:?}, tag: {:?}, protect_tag: {:?}, parse_in_eval: {:?}, mild_compile_error: {:?}, local_storage: {:?}, join_list: {:?}, first_proc: {:?}, first_args: {:?}, first_func: {:?}, machine: {:?}, mark_stack_len: {:?}, 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 . 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 . native_thread_data , self . blocking_region_buffer , self . thgroup , self . value , self . errinfo , self . pending_interrupt_queue , self . pending_interrupt_queue_checked , self . pending_interrupt_mask_stack , 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 . join_list , self . first_proc , self . first_args , self . first_func , self . machine , self . mark_stack_len , 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)
1261 }
1262}
1263pub type rb_thread_t = rb_thread_struct;
1264#[repr(C)]
1265#[derive(Debug, Copy, Clone)]
1266pub struct rb_trace_arg_struct {
1267 pub event: rb_event_flag_t,
1268 pub th: *mut rb_thread_t,
1269 pub cfp: *mut rb_control_frame_t,
1270 pub self_: VALUE,
1271 pub id: ID,
1272 pub klass: VALUE,
1273 pub data: VALUE,
1274 pub klass_solved: ::std::os::raw::c_int,
1275 pub lineno: ::std::os::raw::c_int,
1276 pub path: VALUE,
1277}
1278#[repr(C)]
1279#[derive(Debug, Copy, Clone)]
1280pub struct rb_compile_option_struct {
1281 pub inline_const_cache: ::std::os::raw::c_int,
1282 pub peephole_optimization: ::std::os::raw::c_int,
1283 pub tailcall_optimization: ::std::os::raw::c_int,
1284 pub specialized_instruction: ::std::os::raw::c_int,
1285 pub operands_unification: ::std::os::raw::c_int,
1286 pub instructions_unification: ::std::os::raw::c_int,
1287 pub stack_caching: ::std::os::raw::c_int,
1288 pub trace_instruction: ::std::os::raw::c_int,
1289 pub debug_level: ::std::os::raw::c_int,
1290}
1291#[repr(C)]
1292#[derive(Debug, Copy, Clone)]
1293pub struct iseq_line_info_entry {
1294 pub position: ::std::os::raw::c_uint,
1295 pub line_no: ::std::os::raw::c_uint,
1296}
1297#[repr(C)]
1298#[derive(Debug, Copy, Clone)]
1299pub struct iseq_catch_table_entry {
1300 pub type_: iseq_catch_table_entry_catch_type,
1301 pub iseq: VALUE,
1302 pub start: ::std::os::raw::c_ulong,
1303 pub end: ::std::os::raw::c_ulong,
1304 pub cont: ::std::os::raw::c_ulong,
1305 pub sp: ::std::os::raw::c_ulong,
1306}
1307pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_RESCUE: iseq_catch_table_entry_catch_type =
1308 3;
1309pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_ENSURE: iseq_catch_table_entry_catch_type =
1310 5;
1311pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_RETRY: iseq_catch_table_entry_catch_type = 7;
1312pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_BREAK: iseq_catch_table_entry_catch_type = 9;
1313pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_REDO: iseq_catch_table_entry_catch_type = 11;
1314pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_NEXT: iseq_catch_table_entry_catch_type = 13;
1315pub type iseq_catch_table_entry_catch_type = ::std::os::raw::c_uint;
1316#[repr(C)]
1317#[derive(Debug, Copy, Clone)]
1318pub struct iseq_compile_data_storage {
1319 pub next: *mut iseq_compile_data_storage,
1320 pub pos: ::std::os::raw::c_ulong,
1321 pub size: ::std::os::raw::c_ulong,
1322 pub buff: *mut ::std::os::raw::c_char,
1323}
1324#[repr(C)]
1325#[derive(Debug, Copy, Clone)]
1326pub struct iseq_compile_data {
1327 pub err_info: VALUE,
1328 pub mark_ary: VALUE,
1329 pub catch_table_ary: VALUE,
1330 pub start_label: *mut iseq_label_data,
1331 pub end_label: *mut iseq_label_data,
1332 pub redo_label: *mut iseq_label_data,
1333 pub current_block: VALUE,
1334 pub ensure_node: VALUE,
1335 pub for_iseq: VALUE,
1336 pub ensure_node_stack: *mut iseq_compile_data_ensure_node_stack,
1337 pub loopval_popped: ::std::os::raw::c_int,
1338 pub cached_const: ::std::os::raw::c_int,
1339 pub storage_head: *mut iseq_compile_data_storage,
1340 pub storage_current: *mut iseq_compile_data_storage,
1341 pub last_line: ::std::os::raw::c_int,
1342 pub last_coverable_line: ::std::os::raw::c_int,
1343 pub label_no: ::std::os::raw::c_int,
1344 pub node_level: ::std::os::raw::c_int,
1345 pub option: *const rb_compile_option_t,
1346}
1347#[repr(C)]
1348#[derive(Debug, Copy, Clone)]
1349pub struct st_table_entry {
1350 pub _address: u8,
1351}
1352#[repr(C)]
1353#[derive(Debug, Copy, Clone)]
1354pub struct st_packed_entry {
1355 pub _address: u8,
1356}
1357#[repr(C)]
1358#[derive(Debug, Copy, Clone)]
1359pub struct rb_event_hook_struct {
1360 pub _address: u8,
1361}
1362#[repr(C)]
1363#[derive(Debug, Copy, Clone)]
1364pub struct rb_postponed_job_struct {
1365 pub _address: u8,
1366}
1367#[repr(C)]
1368#[derive(Debug, Copy, Clone)]
1369pub struct iseq_label_data {
1370 pub _address: u8,
1371}