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}
143#[repr(C)]
144#[derive(Default)]
145pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
146impl<T> __IncompleteArrayField<T> {
147 #[inline]
148 pub const fn new() -> Self {
149 __IncompleteArrayField(::std::marker::PhantomData, [])
150 }
151 #[inline]
152 pub fn as_ptr(&self) -> *const T {
153 self as *const _ as *const T
154 }
155 #[inline]
156 pub fn as_mut_ptr(&mut self) -> *mut T {
157 self as *mut _ as *mut T
158 }
159 #[inline]
160 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
161 ::std::slice::from_raw_parts(self.as_ptr(), len)
162 }
163 #[inline]
164 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
165 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
166 }
167}
168impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
169 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
170 fmt.write_str("__IncompleteArrayField")
171 }
172}
173#[repr(C)]
174#[derive(Debug, Copy, Clone)]
175pub struct __sigset_t {
176 pub __val: [usize; 16usize],
177}
178#[repr(C)]
179#[derive(Debug, Copy, Clone)]
180pub struct __pthread_internal_list {
181 pub __prev: *mut __pthread_internal_list,
182 pub __next: *mut __pthread_internal_list,
183}
184pub type __pthread_list_t = __pthread_internal_list;
185#[repr(C)]
186#[derive(Debug, Copy, Clone)]
187pub struct __pthread_mutex_s {
188 pub __lock: ::std::os::raw::c_int,
189 pub __count: ::std::os::raw::c_uint,
190 pub __owner: ::std::os::raw::c_int,
191 pub __nusers: ::std::os::raw::c_uint,
192 pub __kind: ::std::os::raw::c_int,
193 pub __spins: ::std::os::raw::c_short,
194 pub __elision: ::std::os::raw::c_short,
195 pub __list: __pthread_list_t,
196}
197#[repr(C)]
198#[derive(Copy, Clone)]
199pub struct __pthread_cond_s {
200 pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1,
201 pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2,
202 pub __g_refs: [::std::os::raw::c_uint; 2usize],
203 pub __g_size: [::std::os::raw::c_uint; 2usize],
204 pub __g1_orig_size: ::std::os::raw::c_uint,
205 pub __wrefs: ::std::os::raw::c_uint,
206 pub __g_signals: [::std::os::raw::c_uint; 2usize],
207}
208#[repr(C)]
209#[derive(Copy, Clone)]
210pub union __pthread_cond_s__bindgen_ty_1 {
211 pub __wseq: ::std::os::raw::c_ulonglong,
212 pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
213}
214#[repr(C)]
215#[derive(Debug, Copy, Clone)]
216pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
217 pub __low: ::std::os::raw::c_uint,
218 pub __high: ::std::os::raw::c_uint,
219}
220impl ::std::fmt::Debug for __pthread_cond_s__bindgen_ty_1 {
221 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
222 write!(f, "__pthread_cond_s__bindgen_ty_1 {{ union }}")
223 }
224}
225#[repr(C)]
226#[derive(Copy, Clone)]
227pub union __pthread_cond_s__bindgen_ty_2 {
228 pub __g1_start: ::std::os::raw::c_ulonglong,
229 pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
230}
231#[repr(C)]
232#[derive(Debug, Copy, Clone)]
233pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
234 pub __low: ::std::os::raw::c_uint,
235 pub __high: ::std::os::raw::c_uint,
236}
237impl ::std::fmt::Debug for __pthread_cond_s__bindgen_ty_2 {
238 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
239 write!(f, "__pthread_cond_s__bindgen_ty_2 {{ union }}")
240 }
241}
242impl ::std::fmt::Debug for __pthread_cond_s {
243 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
244 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)
245 }
246}
247pub type pthread_t = usize;
248#[repr(C)]
249#[derive(Copy, Clone)]
250pub union pthread_mutex_t {
251 pub __data: __pthread_mutex_s,
252 pub __size: [::std::os::raw::c_char; 40usize],
253 pub __align: ::std::os::raw::c_long,
254}
255impl ::std::fmt::Debug for pthread_mutex_t {
256 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
257 write!(f, "pthread_mutex_t {{ union }}")
258 }
259}
260#[repr(C)]
261#[derive(Copy, Clone)]
262pub union pthread_cond_t {
263 pub __data: __pthread_cond_s,
264 pub __size: [::std::os::raw::c_char; 48usize],
265 pub __align: ::std::os::raw::c_longlong,
266}
267impl ::std::fmt::Debug for pthread_cond_t {
268 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
269 write!(f, "pthread_cond_t {{ union }}")
270 }
271}
272pub type VALUE = usize;
273pub type ID = usize;
274pub const ruby_fl_type_RUBY_FL_WB_PROTECTED: ruby_fl_type = 32;
275pub const ruby_fl_type_RUBY_FL_PROMOTED0: ruby_fl_type = 32;
276pub const ruby_fl_type_RUBY_FL_PROMOTED1: ruby_fl_type = 64;
277pub const ruby_fl_type_RUBY_FL_PROMOTED: ruby_fl_type = 96;
278pub const ruby_fl_type_RUBY_FL_FINALIZE: ruby_fl_type = 128;
279pub const ruby_fl_type_RUBY_FL_TAINT: ruby_fl_type = 256;
280pub const ruby_fl_type_RUBY_FL_UNTRUSTED: ruby_fl_type = 256;
281pub const ruby_fl_type_RUBY_FL_SEEN_OBJ_ID: ruby_fl_type = 512;
282pub const ruby_fl_type_RUBY_FL_EXIVAR: ruby_fl_type = 1024;
283pub const ruby_fl_type_RUBY_FL_FREEZE: ruby_fl_type = 2048;
284pub const ruby_fl_type_RUBY_FL_USHIFT: ruby_fl_type = 12;
285pub const ruby_fl_type_RUBY_FL_USER0: ruby_fl_type = 4096;
286pub const ruby_fl_type_RUBY_FL_USER1: ruby_fl_type = 8192;
287pub const ruby_fl_type_RUBY_FL_USER2: ruby_fl_type = 16384;
288pub const ruby_fl_type_RUBY_FL_USER3: ruby_fl_type = 32768;
289pub const ruby_fl_type_RUBY_FL_USER4: ruby_fl_type = 65536;
290pub const ruby_fl_type_RUBY_FL_USER5: ruby_fl_type = 131072;
291pub const ruby_fl_type_RUBY_FL_USER6: ruby_fl_type = 262144;
292pub const ruby_fl_type_RUBY_FL_USER7: ruby_fl_type = 524288;
293pub const ruby_fl_type_RUBY_FL_USER8: ruby_fl_type = 1048576;
294pub const ruby_fl_type_RUBY_FL_USER9: ruby_fl_type = 2097152;
295pub const ruby_fl_type_RUBY_FL_USER10: ruby_fl_type = 4194304;
296pub const ruby_fl_type_RUBY_FL_USER11: ruby_fl_type = 8388608;
297pub const ruby_fl_type_RUBY_FL_USER12: ruby_fl_type = 16777216;
298pub const ruby_fl_type_RUBY_FL_USER13: ruby_fl_type = 33554432;
299pub const ruby_fl_type_RUBY_FL_USER14: ruby_fl_type = 67108864;
300pub const ruby_fl_type_RUBY_FL_USER15: ruby_fl_type = 134217728;
301pub const ruby_fl_type_RUBY_FL_USER16: ruby_fl_type = 268435456;
302pub const ruby_fl_type_RUBY_FL_USER17: ruby_fl_type = 536870912;
303pub const ruby_fl_type_RUBY_FL_USER18: ruby_fl_type = 1073741824;
304pub const ruby_fl_type_RUBY_FL_USER19: ruby_fl_type = -2147483648;
305pub const ruby_fl_type_RUBY_ELTS_SHARED: ruby_fl_type = 16384;
306pub const ruby_fl_type_RUBY_FL_DUPPED: ruby_fl_type = 1311;
307pub const ruby_fl_type_RUBY_FL_SINGLETON: ruby_fl_type = 4096;
308pub type ruby_fl_type = ::std::os::raw::c_int;
309#[repr(C)]
310#[derive(Debug, Copy, Clone)]
311pub struct RBasic {
312 pub flags: VALUE,
313 pub klass: VALUE,
314}
315#[repr(C)]
316#[derive(Copy, Clone)]
317pub struct RString {
318 pub basic: RBasic,
319 pub as_: RString__bindgen_ty_1,
320}
321#[repr(C)]
322#[derive(Copy, Clone)]
323pub union RString__bindgen_ty_1 {
324 pub heap: RString__bindgen_ty_1__bindgen_ty_1,
325 pub ary: [::std::os::raw::c_char; 24usize],
326}
327#[repr(C)]
328#[derive(Copy, Clone)]
329pub struct RString__bindgen_ty_1__bindgen_ty_1 {
330 pub len: ::std::os::raw::c_long,
331 pub ptr: *mut ::std::os::raw::c_char,
332 pub aux: RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
333}
334#[repr(C)]
335#[derive(Copy, Clone)]
336pub union RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
337 pub capa: ::std::os::raw::c_long,
338 pub shared: VALUE,
339}
340impl ::std::fmt::Debug for RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
341 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
342 write!(
343 f,
344 "RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {{ union }}"
345 )
346 }
347}
348impl ::std::fmt::Debug for RString__bindgen_ty_1__bindgen_ty_1 {
349 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
350 write!(
351 f,
352 "RString__bindgen_ty_1__bindgen_ty_1 {{ len: {:?}, ptr: {:?}, aux: {:?} }}",
353 self.len, self.ptr, self.aux
354 )
355 }
356}
357impl ::std::fmt::Debug for RString__bindgen_ty_1 {
358 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
359 write!(f, "RString__bindgen_ty_1 {{ union }}")
360 }
361}
362impl ::std::fmt::Debug for RString {
363 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
364 write!(
365 f,
366 "RString {{ basic: {:?}, as: {:?} }}",
367 self.basic, self.as_
368 )
369 }
370}
371#[repr(C)]
372#[derive(Copy, Clone)]
373pub struct RArray {
374 pub basic: RBasic,
375 pub as_: RArray__bindgen_ty_1,
376}
377#[repr(C)]
378#[derive(Copy, Clone)]
379pub union RArray__bindgen_ty_1 {
380 pub heap: RArray__bindgen_ty_1__bindgen_ty_1,
381 pub ary: [VALUE; 3usize],
382}
383#[repr(C)]
384#[derive(Copy, Clone)]
385pub struct RArray__bindgen_ty_1__bindgen_ty_1 {
386 pub len: ::std::os::raw::c_long,
387 pub aux: RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
388 pub ptr: *const VALUE,
389}
390#[repr(C)]
391#[derive(Copy, Clone)]
392pub union RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
393 pub capa: ::std::os::raw::c_long,
394 pub shared_root: VALUE,
395}
396impl ::std::fmt::Debug for RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
397 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
398 write!(
399 f,
400 "RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {{ union }}"
401 )
402 }
403}
404impl ::std::fmt::Debug for RArray__bindgen_ty_1__bindgen_ty_1 {
405 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
406 write!(
407 f,
408 "RArray__bindgen_ty_1__bindgen_ty_1 {{ len: {:?}, aux: {:?}, ptr: {:?} }}",
409 self.len, self.aux, self.ptr
410 )
411 }
412}
413impl ::std::fmt::Debug for RArray__bindgen_ty_1 {
414 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
415 write!(f, "RArray__bindgen_ty_1 {{ union }}")
416 }
417}
418impl ::std::fmt::Debug for RArray {
419 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
420 write!(
421 f,
422 "RArray {{ basic: {:?}, as: {:?} }}",
423 self.basic, self.as_
424 )
425 }
426}
427pub type st_data_t = usize;
428pub type st_index_t = st_data_t;
429#[repr(C)]
430#[derive(Debug, Copy, Clone)]
431pub struct st_hash_type {
432 pub compare: ::std::option::Option<
433 unsafe extern "C" fn(arg1: st_data_t, arg2: st_data_t) -> ::std::os::raw::c_int,
434 >,
435 pub hash: ::std::option::Option<unsafe extern "C" fn(arg1: st_data_t) -> st_index_t>,
436}
437#[repr(C)]
438#[derive(Debug, Copy, Clone)]
439pub struct st_table_entry {
440 _unused: [u8; 0],
441}
442#[repr(C)]
443#[derive(Debug, Copy, Clone)]
444pub struct st_table {
445 pub entry_power: ::std::os::raw::c_uchar,
446 pub bin_power: ::std::os::raw::c_uchar,
447 pub size_ind: ::std::os::raw::c_uchar,
448 pub rebuilds_num: ::std::os::raw::c_uint,
449 pub type_: *const st_hash_type,
450 pub num_entries: st_index_t,
451 pub bins: *mut st_index_t,
452 pub entries_start: st_index_t,
453 pub entries_bound: st_index_t,
454 pub entries: *mut st_table_entry,
455}
456pub type rb_alloc_func_t = ::std::option::Option<unsafe extern "C" fn(arg1: VALUE) -> VALUE>;
457pub type rb_unblock_function_t =
458 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>;
459pub type rb_event_flag_t = u32;
460#[repr(C)]
461#[derive(Debug, Copy, Clone)]
462pub struct rb_code_position_struct {
463 pub lineno: ::std::os::raw::c_int,
464 pub column: ::std::os::raw::c_int,
465}
466pub type rb_code_position_t = rb_code_position_struct;
467#[repr(C)]
468#[derive(Debug, Copy, Clone)]
469pub struct rb_code_location_struct {
470 pub beg_pos: rb_code_position_t,
471 pub end_pos: rb_code_position_t,
472}
473pub type rb_code_location_t = rb_code_location_struct;
474pub const ruby_id_types_RUBY_ID_STATIC_SYM: ruby_id_types = 1;
475pub const ruby_id_types_RUBY_ID_LOCAL: ruby_id_types = 0;
476pub const ruby_id_types_RUBY_ID_INSTANCE: ruby_id_types = 2;
477pub const ruby_id_types_RUBY_ID_GLOBAL: ruby_id_types = 6;
478pub const ruby_id_types_RUBY_ID_ATTRSET: ruby_id_types = 8;
479pub const ruby_id_types_RUBY_ID_CONST: ruby_id_types = 10;
480pub const ruby_id_types_RUBY_ID_CLASS: ruby_id_types = 12;
481pub const ruby_id_types_RUBY_ID_JUNK: ruby_id_types = 14;
482pub const ruby_id_types_RUBY_ID_INTERNAL: ruby_id_types = 14;
483pub const ruby_id_types_RUBY_ID_SCOPE_SHIFT: ruby_id_types = 4;
484pub const ruby_id_types_RUBY_ID_SCOPE_MASK: ruby_id_types = 14;
485pub type ruby_id_types = ::std::os::raw::c_uint;
486pub const ruby_method_ids_idDot2: ruby_method_ids = 128;
487pub const ruby_method_ids_idDot3: ruby_method_ids = 129;
488pub const ruby_method_ids_idUPlus: ruby_method_ids = 132;
489pub const ruby_method_ids_idUMinus: ruby_method_ids = 133;
490pub const ruby_method_ids_idPow: ruby_method_ids = 134;
491pub const ruby_method_ids_idCmp: ruby_method_ids = 135;
492pub const ruby_method_ids_idPLUS: ruby_method_ids = 43;
493pub const ruby_method_ids_idMINUS: ruby_method_ids = 45;
494pub const ruby_method_ids_idMULT: ruby_method_ids = 42;
495pub const ruby_method_ids_idDIV: ruby_method_ids = 47;
496pub const ruby_method_ids_idMOD: ruby_method_ids = 37;
497pub const ruby_method_ids_idLTLT: ruby_method_ids = 136;
498pub const ruby_method_ids_idGTGT: ruby_method_ids = 137;
499pub const ruby_method_ids_idLT: ruby_method_ids = 60;
500pub const ruby_method_ids_idLE: ruby_method_ids = 138;
501pub const ruby_method_ids_idGT: ruby_method_ids = 62;
502pub const ruby_method_ids_idGE: ruby_method_ids = 139;
503pub const ruby_method_ids_idEq: ruby_method_ids = 140;
504pub const ruby_method_ids_idEqq: ruby_method_ids = 141;
505pub const ruby_method_ids_idNeq: ruby_method_ids = 142;
506pub const ruby_method_ids_idNot: ruby_method_ids = 33;
507pub const ruby_method_ids_idAnd: ruby_method_ids = 38;
508pub const ruby_method_ids_idOr: ruby_method_ids = 124;
509pub const ruby_method_ids_idBackquote: ruby_method_ids = 96;
510pub const ruby_method_ids_idEqTilde: ruby_method_ids = 143;
511pub const ruby_method_ids_idNeqTilde: ruby_method_ids = 144;
512pub const ruby_method_ids_idAREF: ruby_method_ids = 145;
513pub const ruby_method_ids_idASET: ruby_method_ids = 146;
514pub const ruby_method_ids_idCOLON2: ruby_method_ids = 147;
515pub const ruby_method_ids_idANDOP: ruby_method_ids = 148;
516pub const ruby_method_ids_idOROP: ruby_method_ids = 149;
517pub const ruby_method_ids_idANDDOT: ruby_method_ids = 150;
518pub const ruby_method_ids_tPRESERVED_ID_BEGIN: ruby_method_ids = 150;
519pub const ruby_method_ids_idNilP: ruby_method_ids = 151;
520pub const ruby_method_ids_idNULL: ruby_method_ids = 152;
521pub const ruby_method_ids_idEmptyP: ruby_method_ids = 153;
522pub const ruby_method_ids_idEqlP: ruby_method_ids = 154;
523pub const ruby_method_ids_idRespond_to: ruby_method_ids = 155;
524pub const ruby_method_ids_idRespond_to_missing: ruby_method_ids = 156;
525pub const ruby_method_ids_idIFUNC: ruby_method_ids = 157;
526pub const ruby_method_ids_idCFUNC: ruby_method_ids = 158;
527pub const ruby_method_ids_id_core_set_method_alias: ruby_method_ids = 159;
528pub const ruby_method_ids_id_core_set_variable_alias: ruby_method_ids = 160;
529pub const ruby_method_ids_id_core_undef_method: ruby_method_ids = 161;
530pub const ruby_method_ids_id_core_define_method: ruby_method_ids = 162;
531pub const ruby_method_ids_id_core_define_singleton_method: ruby_method_ids = 163;
532pub const ruby_method_ids_id_core_set_postexe: ruby_method_ids = 164;
533pub const ruby_method_ids_id_core_hash_merge_ptr: ruby_method_ids = 165;
534pub const ruby_method_ids_id_core_hash_merge_kwd: ruby_method_ids = 166;
535pub const ruby_method_ids_id_core_raise: ruby_method_ids = 167;
536pub const ruby_method_ids_id_debug_created_info: ruby_method_ids = 168;
537pub const ruby_method_ids_tPRESERVED_ID_END: ruby_method_ids = 169;
538pub const ruby_method_ids_tTOKEN_LOCAL_BEGIN: ruby_method_ids = 168;
539pub const ruby_method_ids_tMax: ruby_method_ids = 169;
540pub const ruby_method_ids_tMin: ruby_method_ids = 170;
541pub const ruby_method_ids_tFreeze: ruby_method_ids = 171;
542pub const ruby_method_ids_tInspect: ruby_method_ids = 172;
543pub const ruby_method_ids_tIntern: ruby_method_ids = 173;
544pub const ruby_method_ids_tObject_id: ruby_method_ids = 174;
545pub const ruby_method_ids_tConst_missing: ruby_method_ids = 175;
546pub const ruby_method_ids_tMethodMissing: ruby_method_ids = 176;
547pub const ruby_method_ids_tMethod_added: ruby_method_ids = 177;
548pub const ruby_method_ids_tSingleton_method_added: ruby_method_ids = 178;
549pub const ruby_method_ids_tMethod_removed: ruby_method_ids = 179;
550pub const ruby_method_ids_tSingleton_method_removed: ruby_method_ids = 180;
551pub const ruby_method_ids_tMethod_undefined: ruby_method_ids = 181;
552pub const ruby_method_ids_tSingleton_method_undefined: ruby_method_ids = 182;
553pub const ruby_method_ids_tLength: ruby_method_ids = 183;
554pub const ruby_method_ids_tSize: ruby_method_ids = 184;
555pub const ruby_method_ids_tGets: ruby_method_ids = 185;
556pub const ruby_method_ids_tSucc: ruby_method_ids = 186;
557pub const ruby_method_ids_tEach: ruby_method_ids = 187;
558pub const ruby_method_ids_tProc: ruby_method_ids = 188;
559pub const ruby_method_ids_tLambda: ruby_method_ids = 189;
560pub const ruby_method_ids_tSend: ruby_method_ids = 190;
561pub const ruby_method_ids_t__send__: ruby_method_ids = 191;
562pub const ruby_method_ids_t__attached__: ruby_method_ids = 192;
563pub const ruby_method_ids_tInitialize: ruby_method_ids = 193;
564pub const ruby_method_ids_tInitialize_copy: ruby_method_ids = 194;
565pub const ruby_method_ids_tInitialize_clone: ruby_method_ids = 195;
566pub const ruby_method_ids_tInitialize_dup: ruby_method_ids = 196;
567pub const ruby_method_ids_tTo_int: ruby_method_ids = 197;
568pub const ruby_method_ids_tTo_ary: ruby_method_ids = 198;
569pub const ruby_method_ids_tTo_str: ruby_method_ids = 199;
570pub const ruby_method_ids_tTo_sym: ruby_method_ids = 200;
571pub const ruby_method_ids_tTo_hash: ruby_method_ids = 201;
572pub const ruby_method_ids_tTo_proc: ruby_method_ids = 202;
573pub const ruby_method_ids_tTo_io: ruby_method_ids = 203;
574pub const ruby_method_ids_tTo_a: ruby_method_ids = 204;
575pub const ruby_method_ids_tTo_s: ruby_method_ids = 205;
576pub const ruby_method_ids_tTo_i: ruby_method_ids = 206;
577pub const ruby_method_ids_tTo_f: ruby_method_ids = 207;
578pub const ruby_method_ids_tTo_r: ruby_method_ids = 208;
579pub const ruby_method_ids_tBt: ruby_method_ids = 209;
580pub const ruby_method_ids_tBt_locations: ruby_method_ids = 210;
581pub const ruby_method_ids_tCall: ruby_method_ids = 211;
582pub const ruby_method_ids_tMesg: ruby_method_ids = 212;
583pub const ruby_method_ids_tException: ruby_method_ids = 213;
584pub const ruby_method_ids_tLocals: ruby_method_ids = 214;
585pub const ruby_method_ids_tNOT: ruby_method_ids = 215;
586pub const ruby_method_ids_tAND: ruby_method_ids = 216;
587pub const ruby_method_ids_tOR: ruby_method_ids = 217;
588pub const ruby_method_ids_tDiv: ruby_method_ids = 218;
589pub const ruby_method_ids_tDivmod: ruby_method_ids = 219;
590pub const ruby_method_ids_tFdiv: ruby_method_ids = 220;
591pub const ruby_method_ids_tQuo: ruby_method_ids = 221;
592pub const ruby_method_ids_tName: ruby_method_ids = 222;
593pub const ruby_method_ids_tNil: ruby_method_ids = 223;
594pub const ruby_method_ids_tUScore: ruby_method_ids = 224;
595pub const ruby_method_ids_tNUMPARAM_1: ruby_method_ids = 225;
596pub const ruby_method_ids_tNUMPARAM_2: ruby_method_ids = 226;
597pub const ruby_method_ids_tNUMPARAM_3: ruby_method_ids = 227;
598pub const ruby_method_ids_tNUMPARAM_4: ruby_method_ids = 228;
599pub const ruby_method_ids_tNUMPARAM_5: ruby_method_ids = 229;
600pub const ruby_method_ids_tNUMPARAM_6: ruby_method_ids = 230;
601pub const ruby_method_ids_tNUMPARAM_7: ruby_method_ids = 231;
602pub const ruby_method_ids_tNUMPARAM_8: ruby_method_ids = 232;
603pub const ruby_method_ids_tNUMPARAM_9: ruby_method_ids = 233;
604pub const ruby_method_ids_tTOKEN_LOCAL_END: ruby_method_ids = 234;
605pub const ruby_method_ids_tTOKEN_INSTANCE_BEGIN: ruby_method_ids = 233;
606pub const ruby_method_ids_tTOKEN_INSTANCE_END: ruby_method_ids = 234;
607pub const ruby_method_ids_tTOKEN_GLOBAL_BEGIN: ruby_method_ids = 233;
608pub const ruby_method_ids_tLASTLINE: ruby_method_ids = 234;
609pub const ruby_method_ids_tBACKREF: ruby_method_ids = 235;
610pub const ruby_method_ids_tERROR_INFO: ruby_method_ids = 236;
611pub const ruby_method_ids_tTOKEN_GLOBAL_END: ruby_method_ids = 237;
612pub const ruby_method_ids_tTOKEN_CONST_BEGIN: ruby_method_ids = 236;
613pub const ruby_method_ids_tTOKEN_CONST_END: ruby_method_ids = 237;
614pub const ruby_method_ids_tTOKEN_CLASS_BEGIN: ruby_method_ids = 236;
615pub const ruby_method_ids_tTOKEN_CLASS_END: ruby_method_ids = 237;
616pub const ruby_method_ids_tTOKEN_ATTRSET_BEGIN: ruby_method_ids = 236;
617pub const ruby_method_ids_tTOKEN_ATTRSET_END: ruby_method_ids = 237;
618pub const ruby_method_ids_tNEXT_ID: ruby_method_ids = 237;
619pub const ruby_method_ids_idMax: ruby_method_ids = 2705;
620pub const ruby_method_ids_idMin: ruby_method_ids = 2721;
621pub const ruby_method_ids_idFreeze: ruby_method_ids = 2737;
622pub const ruby_method_ids_idInspect: ruby_method_ids = 2753;
623pub const ruby_method_ids_idIntern: ruby_method_ids = 2769;
624pub const ruby_method_ids_idObject_id: ruby_method_ids = 2785;
625pub const ruby_method_ids_idConst_missing: ruby_method_ids = 2801;
626pub const ruby_method_ids_idMethodMissing: ruby_method_ids = 2817;
627pub const ruby_method_ids_idMethod_added: ruby_method_ids = 2833;
628pub const ruby_method_ids_idSingleton_method_added: ruby_method_ids = 2849;
629pub const ruby_method_ids_idMethod_removed: ruby_method_ids = 2865;
630pub const ruby_method_ids_idSingleton_method_removed: ruby_method_ids = 2881;
631pub const ruby_method_ids_idMethod_undefined: ruby_method_ids = 2897;
632pub const ruby_method_ids_idSingleton_method_undefined: ruby_method_ids = 2913;
633pub const ruby_method_ids_idLength: ruby_method_ids = 2929;
634pub const ruby_method_ids_idSize: ruby_method_ids = 2945;
635pub const ruby_method_ids_idGets: ruby_method_ids = 2961;
636pub const ruby_method_ids_idSucc: ruby_method_ids = 2977;
637pub const ruby_method_ids_idEach: ruby_method_ids = 2993;
638pub const ruby_method_ids_idProc: ruby_method_ids = 3009;
639pub const ruby_method_ids_idLambda: ruby_method_ids = 3025;
640pub const ruby_method_ids_idSend: ruby_method_ids = 3041;
641pub const ruby_method_ids_id__send__: ruby_method_ids = 3057;
642pub const ruby_method_ids_id__attached__: ruby_method_ids = 3073;
643pub const ruby_method_ids_idInitialize: ruby_method_ids = 3089;
644pub const ruby_method_ids_idInitialize_copy: ruby_method_ids = 3105;
645pub const ruby_method_ids_idInitialize_clone: ruby_method_ids = 3121;
646pub const ruby_method_ids_idInitialize_dup: ruby_method_ids = 3137;
647pub const ruby_method_ids_idTo_int: ruby_method_ids = 3153;
648pub const ruby_method_ids_idTo_ary: ruby_method_ids = 3169;
649pub const ruby_method_ids_idTo_str: ruby_method_ids = 3185;
650pub const ruby_method_ids_idTo_sym: ruby_method_ids = 3201;
651pub const ruby_method_ids_idTo_hash: ruby_method_ids = 3217;
652pub const ruby_method_ids_idTo_proc: ruby_method_ids = 3233;
653pub const ruby_method_ids_idTo_io: ruby_method_ids = 3249;
654pub const ruby_method_ids_idTo_a: ruby_method_ids = 3265;
655pub const ruby_method_ids_idTo_s: ruby_method_ids = 3281;
656pub const ruby_method_ids_idTo_i: ruby_method_ids = 3297;
657pub const ruby_method_ids_idTo_f: ruby_method_ids = 3313;
658pub const ruby_method_ids_idTo_r: ruby_method_ids = 3329;
659pub const ruby_method_ids_idBt: ruby_method_ids = 3345;
660pub const ruby_method_ids_idBt_locations: ruby_method_ids = 3361;
661pub const ruby_method_ids_idCall: ruby_method_ids = 3377;
662pub const ruby_method_ids_idMesg: ruby_method_ids = 3393;
663pub const ruby_method_ids_idException: ruby_method_ids = 3409;
664pub const ruby_method_ids_idLocals: ruby_method_ids = 3425;
665pub const ruby_method_ids_idNOT: ruby_method_ids = 3441;
666pub const ruby_method_ids_idAND: ruby_method_ids = 3457;
667pub const ruby_method_ids_idOR: ruby_method_ids = 3473;
668pub const ruby_method_ids_idDiv: ruby_method_ids = 3489;
669pub const ruby_method_ids_idDivmod: ruby_method_ids = 3505;
670pub const ruby_method_ids_idFdiv: ruby_method_ids = 3521;
671pub const ruby_method_ids_idQuo: ruby_method_ids = 3537;
672pub const ruby_method_ids_idName: ruby_method_ids = 3553;
673pub const ruby_method_ids_idNil: ruby_method_ids = 3569;
674pub const ruby_method_ids_idUScore: ruby_method_ids = 3585;
675pub const ruby_method_ids_idNUMPARAM_1: ruby_method_ids = 3601;
676pub const ruby_method_ids_idNUMPARAM_2: ruby_method_ids = 3617;
677pub const ruby_method_ids_idNUMPARAM_3: ruby_method_ids = 3633;
678pub const ruby_method_ids_idNUMPARAM_4: ruby_method_ids = 3649;
679pub const ruby_method_ids_idNUMPARAM_5: ruby_method_ids = 3665;
680pub const ruby_method_ids_idNUMPARAM_6: ruby_method_ids = 3681;
681pub const ruby_method_ids_idNUMPARAM_7: ruby_method_ids = 3697;
682pub const ruby_method_ids_idNUMPARAM_8: ruby_method_ids = 3713;
683pub const ruby_method_ids_idNUMPARAM_9: ruby_method_ids = 3729;
684pub const ruby_method_ids_idLASTLINE: ruby_method_ids = 3751;
685pub const ruby_method_ids_idBACKREF: ruby_method_ids = 3767;
686pub const ruby_method_ids_idERROR_INFO: ruby_method_ids = 3783;
687pub const ruby_method_ids_tLAST_OP_ID: ruby_method_ids = 168;
688pub const ruby_method_ids_idLAST_OP_ID: ruby_method_ids = 10;
689pub type ruby_method_ids = ::std::os::raw::c_uint;
690pub type rb_subclass_entry_t = rb_subclass_entry;
691#[repr(C)]
692#[derive(Debug, Copy, Clone)]
693pub struct rb_subclass_entry {
694 pub klass: VALUE,
695 pub next: *mut rb_subclass_entry_t,
696}
697pub type rb_serial_t = ::std::os::raw::c_ulonglong;
698#[repr(C)]
699#[derive(Debug, Copy, Clone)]
700pub struct rb_classext_struct {
701 pub iv_index_tbl: *mut st_table,
702 pub iv_tbl: *mut st_table,
703 pub m_tbl: *mut rb_id_table,
704 pub const_tbl: *mut rb_id_table,
705 pub callable_m_tbl: *mut rb_id_table,
706 pub subclasses: *mut rb_subclass_entry_t,
707 pub parent_subclasses: *mut *mut rb_subclass_entry_t,
708 pub module_subclasses: *mut *mut rb_subclass_entry_t,
709 pub origin_: VALUE,
710 pub refined_class: VALUE,
711 pub allocator: rb_alloc_func_t,
712 pub includer: VALUE,
713}
714pub type rb_classext_t = rb_classext_struct;
715pub const imemo_type_imemo_env: imemo_type = 0;
716pub const imemo_type_imemo_cref: imemo_type = 1;
717pub const imemo_type_imemo_svar: imemo_type = 2;
718pub const imemo_type_imemo_throw_data: imemo_type = 3;
719pub const imemo_type_imemo_ifunc: imemo_type = 4;
720pub const imemo_type_imemo_memo: imemo_type = 5;
721pub const imemo_type_imemo_ment: imemo_type = 6;
722pub const imemo_type_imemo_iseq: imemo_type = 7;
723pub const imemo_type_imemo_tmpbuf: imemo_type = 8;
724pub const imemo_type_imemo_ast: imemo_type = 9;
725pub const imemo_type_imemo_parser_strterm: imemo_type = 10;
726pub type imemo_type = ::std::os::raw::c_uint;
727#[repr(C)]
728#[derive(Debug, Copy, Clone)]
729pub struct vm_svar {
730 pub flags: VALUE,
731 pub cref_or_me: VALUE,
732 pub lastline: VALUE,
733 pub backref: VALUE,
734 pub others: VALUE,
735}
736pub const method_missing_reason_MISSING_NOENTRY: method_missing_reason = 0;
737pub const method_missing_reason_MISSING_PRIVATE: method_missing_reason = 1;
738pub const method_missing_reason_MISSING_PROTECTED: method_missing_reason = 2;
739pub const method_missing_reason_MISSING_FCALL: method_missing_reason = 4;
740pub const method_missing_reason_MISSING_VCALL: method_missing_reason = 8;
741pub const method_missing_reason_MISSING_SUPER: method_missing_reason = 16;
742pub const method_missing_reason_MISSING_MISSING: method_missing_reason = 32;
743pub const method_missing_reason_MISSING_NONE: method_missing_reason = 64;
744pub type method_missing_reason = ::std::os::raw::c_uint;
745#[repr(C)]
746#[derive(Copy, Clone)]
747pub struct rb_call_cache {
748 pub method_state: rb_serial_t,
749 pub class_serial: [rb_serial_t; 3usize],
750 pub me: *const rb_callable_method_entry_struct,
751 pub method_serial: usize,
752 pub call: ::std::option::Option<
753 unsafe extern "C" fn(
754 ec: *mut rb_execution_context_struct,
755 cfp: *mut rb_control_frame_struct,
756 calling: *mut rb_calling_info,
757 cd: *mut rb_call_data,
758 ) -> VALUE,
759 >,
760 pub aux: rb_call_cache__bindgen_ty_1,
761}
762#[repr(C)]
763#[derive(Copy, Clone)]
764pub union rb_call_cache__bindgen_ty_1 {
765 pub index: ::std::os::raw::c_uint,
766 pub method_missing_reason: method_missing_reason,
767}
768impl ::std::fmt::Debug for rb_call_cache__bindgen_ty_1 {
769 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
770 write!(f, "rb_call_cache__bindgen_ty_1 {{ union }}")
771 }
772}
773impl ::std::fmt::Debug for rb_call_cache {
774 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
775 write ! (f , "rb_call_cache {{ method_state: {:?}, class_serial: {:?}, me: {:?}, call: {:?}, aux: {:?} }}" , self . method_state , self . class_serial , self . me , self . call , self . aux)
776 }
777}
778#[repr(C)]
779#[derive(Debug, Copy, Clone)]
780pub struct rb_call_info {
781 pub mid: ID,
782 pub flag: ::std::os::raw::c_uint,
783 pub orig_argc: ::std::os::raw::c_int,
784}
785#[repr(C)]
786#[derive(Copy, Clone)]
787pub struct rb_call_data {
788 pub cc: rb_call_cache,
789 pub ci: rb_call_info,
790}
791impl ::std::fmt::Debug for rb_call_data {
792 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
793 write!(f, "rb_call_data {{ cc: {:?}, ci: {:?} }}", self.cc, self.ci)
794 }
795}
796pub const rb_method_visibility_t_METHOD_VISI_UNDEF: rb_method_visibility_t = 0;
797pub const rb_method_visibility_t_METHOD_VISI_PUBLIC: rb_method_visibility_t = 1;
798pub const rb_method_visibility_t_METHOD_VISI_PRIVATE: rb_method_visibility_t = 2;
799pub const rb_method_visibility_t_METHOD_VISI_PROTECTED: rb_method_visibility_t = 3;
800pub const rb_method_visibility_t_METHOD_VISI_MASK: rb_method_visibility_t = 3;
801pub type rb_method_visibility_t = ::std::os::raw::c_uint;
802#[repr(C)]
803#[repr(align(4))]
804#[derive(Debug, Copy, Clone)]
805pub struct rb_scope_visi_struct {
806 pub _bitfield_align_1: [u8; 0],
807 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
808 pub __bindgen_padding_0: [u8; 3usize],
809}
810impl rb_scope_visi_struct {
811 #[inline]
812 pub fn method_visi(&self) -> rb_method_visibility_t {
813 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) }
814 }
815 #[inline]
816 pub fn set_method_visi(&mut self, val: rb_method_visibility_t) {
817 unsafe {
818 let val: u32 = ::std::mem::transmute(val);
819 self._bitfield_1.set(0usize, 3u8, val as u64)
820 }
821 }
822 #[inline]
823 pub unsafe fn method_visi_raw(this: *const Self) -> rb_method_visibility_t {
824 unsafe {
825 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
826 ::std::ptr::addr_of!((*this)._bitfield_1),
827 0usize,
828 3u8,
829 ) as u32)
830 }
831 }
832 #[inline]
833 pub unsafe fn set_method_visi_raw(this: *mut Self, val: rb_method_visibility_t) {
834 unsafe {
835 let val: u32 = ::std::mem::transmute(val);
836 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
837 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
838 0usize,
839 3u8,
840 val as u64,
841 )
842 }
843 }
844 #[inline]
845 pub fn module_func(&self) -> ::std::os::raw::c_uint {
846 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
847 }
848 #[inline]
849 pub fn set_module_func(&mut self, val: ::std::os::raw::c_uint) {
850 unsafe {
851 let val: u32 = ::std::mem::transmute(val);
852 self._bitfield_1.set(3usize, 1u8, val as u64)
853 }
854 }
855 #[inline]
856 pub unsafe fn module_func_raw(this: *const Self) -> ::std::os::raw::c_uint {
857 unsafe {
858 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
859 ::std::ptr::addr_of!((*this)._bitfield_1),
860 3usize,
861 1u8,
862 ) as u32)
863 }
864 }
865 #[inline]
866 pub unsafe fn set_module_func_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
867 unsafe {
868 let val: u32 = ::std::mem::transmute(val);
869 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
870 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
871 3usize,
872 1u8,
873 val as u64,
874 )
875 }
876 }
877 #[inline]
878 pub fn new_bitfield_1(
879 method_visi: rb_method_visibility_t,
880 module_func: ::std::os::raw::c_uint,
881 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
882 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
883 __bindgen_bitfield_unit.set(0usize, 3u8, {
884 let method_visi: u32 = unsafe { ::std::mem::transmute(method_visi) };
885 method_visi as u64
886 });
887 __bindgen_bitfield_unit.set(3usize, 1u8, {
888 let module_func: u32 = unsafe { ::std::mem::transmute(module_func) };
889 module_func as u64
890 });
891 __bindgen_bitfield_unit
892 }
893}
894pub type rb_scope_visibility_t = rb_scope_visi_struct;
895#[repr(C)]
896#[derive(Debug, Copy, Clone)]
897pub struct rb_cref_struct {
898 pub flags: VALUE,
899 pub refinements: VALUE,
900 pub klass: VALUE,
901 pub next: *mut rb_cref_struct,
902 pub scope_visi: rb_scope_visibility_t,
903}
904pub type rb_cref_t = rb_cref_struct;
905#[repr(C)]
906#[derive(Debug, Copy, Clone)]
907pub struct rb_method_entry_struct {
908 pub flags: VALUE,
909 pub defined_class: VALUE,
910 pub def: *mut rb_method_definition_struct,
911 pub called_id: ID,
912 pub owner: VALUE,
913}
914#[repr(C)]
915#[derive(Debug, Copy, Clone)]
916pub struct rb_callable_method_entry_struct {
917 pub flags: VALUE,
918 pub defined_class: VALUE,
919 pub def: *mut rb_method_definition_struct,
920 pub called_id: ID,
921 pub owner: VALUE,
922}
923pub const rb_method_type_t_VM_METHOD_TYPE_ISEQ: rb_method_type_t = 0;
924pub const rb_method_type_t_VM_METHOD_TYPE_CFUNC: rb_method_type_t = 1;
925pub const rb_method_type_t_VM_METHOD_TYPE_ATTRSET: rb_method_type_t = 2;
926pub const rb_method_type_t_VM_METHOD_TYPE_IVAR: rb_method_type_t = 3;
927pub const rb_method_type_t_VM_METHOD_TYPE_BMETHOD: rb_method_type_t = 4;
928pub const rb_method_type_t_VM_METHOD_TYPE_ZSUPER: rb_method_type_t = 5;
929pub const rb_method_type_t_VM_METHOD_TYPE_ALIAS: rb_method_type_t = 6;
930pub const rb_method_type_t_VM_METHOD_TYPE_UNDEF: rb_method_type_t = 7;
931pub const rb_method_type_t_VM_METHOD_TYPE_NOTIMPLEMENTED: rb_method_type_t = 8;
932pub const rb_method_type_t_VM_METHOD_TYPE_OPTIMIZED: rb_method_type_t = 9;
933pub const rb_method_type_t_VM_METHOD_TYPE_MISSING: rb_method_type_t = 10;
934pub const rb_method_type_t_VM_METHOD_TYPE_REFINED: rb_method_type_t = 11;
935pub type rb_method_type_t = ::std::os::raw::c_uint;
936pub type rb_iseq_t = rb_iseq_struct;
937#[repr(C)]
938#[derive(Debug, Copy, Clone)]
939pub struct rb_method_iseq_struct {
940 pub iseqptr: *mut rb_iseq_t,
941 pub cref: *mut rb_cref_t,
942}
943pub type rb_method_iseq_t = rb_method_iseq_struct;
944#[repr(C)]
945#[derive(Debug, Copy, Clone)]
946pub struct rb_method_cfunc_struct {
947 pub func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
948 pub invoker: ::std::option::Option<
949 unsafe extern "C" fn(
950 recv: VALUE,
951 argc: ::std::os::raw::c_int,
952 argv: *const VALUE,
953 func: ::std::option::Option<unsafe extern "C" fn() -> VALUE>,
954 ) -> VALUE,
955 >,
956 pub argc: ::std::os::raw::c_int,
957}
958pub type rb_method_cfunc_t = rb_method_cfunc_struct;
959#[repr(C)]
960#[derive(Debug, Copy, Clone)]
961pub struct rb_method_attr_struct {
962 pub id: ID,
963 pub location: VALUE,
964}
965pub type rb_method_attr_t = rb_method_attr_struct;
966#[repr(C)]
967#[derive(Debug, Copy, Clone)]
968pub struct rb_method_alias_struct {
969 pub original_me: *mut rb_method_entry_struct,
970}
971pub type rb_method_alias_t = rb_method_alias_struct;
972#[repr(C)]
973#[derive(Debug, Copy, Clone)]
974pub struct rb_method_refined_struct {
975 pub orig_me: *mut rb_method_entry_struct,
976 pub owner: VALUE,
977}
978pub type rb_method_refined_t = rb_method_refined_struct;
979#[repr(C)]
980#[derive(Debug, Copy, Clone)]
981pub struct rb_method_bmethod_struct {
982 pub proc_: VALUE,
983 pub hooks: *mut rb_hook_list_struct,
984}
985pub type rb_method_bmethod_t = rb_method_bmethod_struct;
986pub const method_optimized_type_OPTIMIZED_METHOD_TYPE_SEND: method_optimized_type = 0;
987pub const method_optimized_type_OPTIMIZED_METHOD_TYPE_CALL: method_optimized_type = 1;
988pub const method_optimized_type_OPTIMIZED_METHOD_TYPE_BLOCK_CALL: method_optimized_type = 2;
989pub const method_optimized_type_OPTIMIZED_METHOD_TYPE__MAX: method_optimized_type = 3;
990pub type method_optimized_type = ::std::os::raw::c_uint;
991#[repr(C)]
992#[derive(Copy, Clone)]
993pub struct rb_method_definition_struct {
994 pub _bitfield_align_1: [u32; 0],
995 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
996 pub body: rb_method_definition_struct__bindgen_ty_1,
997 pub original_id: ID,
998 pub method_serial: usize,
999}
1000#[repr(C)]
1001#[derive(Copy, Clone)]
1002pub union rb_method_definition_struct__bindgen_ty_1 {
1003 pub iseq: rb_method_iseq_t,
1004 pub cfunc: rb_method_cfunc_t,
1005 pub attr: rb_method_attr_t,
1006 pub alias: rb_method_alias_t,
1007 pub refined: rb_method_refined_t,
1008 pub bmethod: rb_method_bmethod_t,
1009 pub optimize_type: method_optimized_type,
1010}
1011impl ::std::fmt::Debug for rb_method_definition_struct__bindgen_ty_1 {
1012 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1013 write!(f, "rb_method_definition_struct__bindgen_ty_1 {{ union }}")
1014 }
1015}
1016impl rb_method_definition_struct {
1017 #[inline]
1018 pub fn type_(&self) -> rb_method_type_t {
1019 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
1020 }
1021 #[inline]
1022 pub fn set_type(&mut self, val: rb_method_type_t) {
1023 unsafe {
1024 let val: u32 = ::std::mem::transmute(val);
1025 self._bitfield_1.set(0usize, 4u8, val as u64)
1026 }
1027 }
1028 #[inline]
1029 pub unsafe fn type__raw(this: *const Self) -> rb_method_type_t {
1030 unsafe {
1031 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1032 ::std::ptr::addr_of!((*this)._bitfield_1),
1033 0usize,
1034 4u8,
1035 ) as u32)
1036 }
1037 }
1038 #[inline]
1039 pub unsafe fn set_type_raw(this: *mut Self, val: rb_method_type_t) {
1040 unsafe {
1041 let val: u32 = ::std::mem::transmute(val);
1042 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1043 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1044 0usize,
1045 4u8,
1046 val as u64,
1047 )
1048 }
1049 }
1050 #[inline]
1051 pub fn alias_count(&self) -> ::std::os::raw::c_int {
1052 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
1053 }
1054 #[inline]
1055 pub fn set_alias_count(&mut self, val: ::std::os::raw::c_int) {
1056 unsafe {
1057 let val: u32 = ::std::mem::transmute(val);
1058 self._bitfield_1.set(4usize, 28u8, val as u64)
1059 }
1060 }
1061 #[inline]
1062 pub unsafe fn alias_count_raw(this: *const Self) -> ::std::os::raw::c_int {
1063 unsafe {
1064 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1065 ::std::ptr::addr_of!((*this)._bitfield_1),
1066 4usize,
1067 28u8,
1068 ) as u32)
1069 }
1070 }
1071 #[inline]
1072 pub unsafe fn set_alias_count_raw(this: *mut Self, val: ::std::os::raw::c_int) {
1073 unsafe {
1074 let val: u32 = ::std::mem::transmute(val);
1075 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1076 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1077 4usize,
1078 28u8,
1079 val as u64,
1080 )
1081 }
1082 }
1083 #[inline]
1084 pub fn complemented_count(&self) -> ::std::os::raw::c_int {
1085 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 28u8) as u32) }
1086 }
1087 #[inline]
1088 pub fn set_complemented_count(&mut self, val: ::std::os::raw::c_int) {
1089 unsafe {
1090 let val: u32 = ::std::mem::transmute(val);
1091 self._bitfield_1.set(32usize, 28u8, val as u64)
1092 }
1093 }
1094 #[inline]
1095 pub unsafe fn complemented_count_raw(this: *const Self) -> ::std::os::raw::c_int {
1096 unsafe {
1097 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
1098 ::std::ptr::addr_of!((*this)._bitfield_1),
1099 32usize,
1100 28u8,
1101 ) as u32)
1102 }
1103 }
1104 #[inline]
1105 pub unsafe fn set_complemented_count_raw(this: *mut Self, val: ::std::os::raw::c_int) {
1106 unsafe {
1107 let val: u32 = ::std::mem::transmute(val);
1108 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
1109 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1110 32usize,
1111 28u8,
1112 val as u64,
1113 )
1114 }
1115 }
1116 #[inline]
1117 pub fn new_bitfield_1(
1118 type_: rb_method_type_t,
1119 alias_count: ::std::os::raw::c_int,
1120 complemented_count: ::std::os::raw::c_int,
1121 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1122 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1123 __bindgen_bitfield_unit.set(0usize, 4u8, {
1124 let type_: u32 = unsafe { ::std::mem::transmute(type_) };
1125 type_ as u64
1126 });
1127 __bindgen_bitfield_unit.set(4usize, 28u8, {
1128 let alias_count: u32 = unsafe { ::std::mem::transmute(alias_count) };
1129 alias_count as u64
1130 });
1131 __bindgen_bitfield_unit.set(32usize, 28u8, {
1132 let complemented_count: u32 = unsafe { ::std::mem::transmute(complemented_count) };
1133 complemented_count as u64
1134 });
1135 __bindgen_bitfield_unit
1136 }
1137}
1138pub type rb_atomic_t = ::std::os::raw::c_uint;
1139#[repr(C)]
1140#[derive(Debug, Copy, Clone)]
1141pub struct list_node {
1142 pub next: *mut list_node,
1143 pub prev: *mut list_node,
1144}
1145#[repr(C)]
1146#[derive(Debug, Copy, Clone)]
1147pub struct list_head {
1148 pub n: list_node,
1149}
1150pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
1151pub type rb_nativethread_id_t = pthread_t;
1152pub type rb_nativethread_lock_t = pthread_mutex_t;
1153pub type rb_nativethread_cond_t = pthread_cond_t;
1154#[repr(C)]
1155#[derive(Copy, Clone)]
1156pub struct native_thread_data_struct {
1157 pub node: native_thread_data_struct__bindgen_ty_1,
1158 pub cond: native_thread_data_struct__bindgen_ty_2,
1159}
1160#[repr(C)]
1161#[derive(Copy, Clone)]
1162pub union native_thread_data_struct__bindgen_ty_1 {
1163 pub ubf: list_node,
1164 pub gvl: list_node,
1165}
1166impl ::std::fmt::Debug for native_thread_data_struct__bindgen_ty_1 {
1167 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1168 write!(f, "native_thread_data_struct__bindgen_ty_1 {{ union }}")
1169 }
1170}
1171#[repr(C)]
1172#[derive(Copy, Clone)]
1173pub union native_thread_data_struct__bindgen_ty_2 {
1174 pub intr: rb_nativethread_cond_t,
1175 pub gvlq: rb_nativethread_cond_t,
1176}
1177impl ::std::fmt::Debug for native_thread_data_struct__bindgen_ty_2 {
1178 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1179 write!(f, "native_thread_data_struct__bindgen_ty_2 {{ union }}")
1180 }
1181}
1182impl ::std::fmt::Debug for native_thread_data_struct {
1183 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1184 write!(
1185 f,
1186 "native_thread_data_struct {{ node: {:?}, cond: {:?} }}",
1187 self.node, self.cond
1188 )
1189 }
1190}
1191pub type native_thread_data_t = native_thread_data_struct;
1192#[repr(C)]
1193#[derive(Copy, Clone)]
1194pub struct rb_global_vm_lock_struct {
1195 pub owner: *const rb_thread_struct,
1196 pub lock: rb_nativethread_lock_t,
1197 pub waitq: list_head,
1198 pub timer: *const rb_thread_struct,
1199 pub timer_err: ::std::os::raw::c_int,
1200 pub switch_cond: rb_nativethread_cond_t,
1201 pub switch_wait_cond: rb_nativethread_cond_t,
1202 pub need_yield: ::std::os::raw::c_int,
1203 pub wait_yield: ::std::os::raw::c_int,
1204}
1205impl ::std::fmt::Debug for rb_global_vm_lock_struct {
1206 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1207 write ! (f , "rb_global_vm_lock_struct {{ owner: {:?}, lock: {:?}, waitq: {:?}, timer: {:?}, timer_err: {:?}, switch_cond: {:?}, switch_wait_cond: {:?}, need_yield: {:?}, wait_yield: {:?} }}" , self . owner , self . lock , self . waitq , self . timer , self . timer_err , self . switch_cond , self . switch_wait_cond , self . need_yield , self . wait_yield)
1208 }
1209}
1210pub type rb_global_vm_lock_t = rb_global_vm_lock_struct;
1211#[repr(C)]
1212#[derive(Debug, Copy, Clone)]
1213pub struct __jmp_buf_tag {
1214 pub __jmpbuf: __jmp_buf,
1215 pub __mask_was_saved: ::std::os::raw::c_int,
1216 pub __saved_mask: __sigset_t,
1217}
1218pub type jmp_buf = [__jmp_buf_tag; 1usize];
1219pub type sigjmp_buf = [__jmp_buf_tag; 1usize];
1220pub type rb_snum_t = ::std::os::raw::c_long;
1221pub const ruby_tag_type_RUBY_TAG_NONE: ruby_tag_type = 0;
1222pub const ruby_tag_type_RUBY_TAG_RETURN: ruby_tag_type = 1;
1223pub const ruby_tag_type_RUBY_TAG_BREAK: ruby_tag_type = 2;
1224pub const ruby_tag_type_RUBY_TAG_NEXT: ruby_tag_type = 3;
1225pub const ruby_tag_type_RUBY_TAG_RETRY: ruby_tag_type = 4;
1226pub const ruby_tag_type_RUBY_TAG_REDO: ruby_tag_type = 5;
1227pub const ruby_tag_type_RUBY_TAG_RAISE: ruby_tag_type = 6;
1228pub const ruby_tag_type_RUBY_TAG_THROW: ruby_tag_type = 7;
1229pub const ruby_tag_type_RUBY_TAG_FATAL: ruby_tag_type = 8;
1230pub const ruby_tag_type_RUBY_TAG_MASK: ruby_tag_type = 15;
1231pub type ruby_tag_type = ::std::os::raw::c_uint;
1232pub type rb_compile_option_t = rb_compile_option_struct;
1233#[repr(C)]
1234#[derive(Debug, Copy, Clone)]
1235pub struct iseq_inline_cache_entry {
1236 pub ic_serial: rb_serial_t,
1237 pub ic_cref: *const rb_cref_t,
1238 pub value: VALUE,
1239}
1240#[repr(C)]
1241#[derive(Debug, Copy, Clone)]
1242pub struct iseq_inline_iv_cache_entry {
1243 pub ic_serial: rb_serial_t,
1244 pub index: usize,
1245}
1246#[repr(C)]
1247#[derive(Copy, Clone)]
1248pub union iseq_inline_storage_entry {
1249 pub once: iseq_inline_storage_entry__bindgen_ty_1,
1250 pub cache: iseq_inline_cache_entry,
1251 pub iv_cache: iseq_inline_iv_cache_entry,
1252}
1253#[repr(C)]
1254#[derive(Debug, Copy, Clone)]
1255pub struct iseq_inline_storage_entry__bindgen_ty_1 {
1256 pub running_thread: *mut rb_thread_struct,
1257 pub value: VALUE,
1258}
1259impl ::std::fmt::Debug for iseq_inline_storage_entry {
1260 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1261 write!(f, "iseq_inline_storage_entry {{ union }}")
1262 }
1263}
1264#[repr(C)]
1265#[derive(Debug, Copy, Clone)]
1266pub struct rb_calling_info {
1267 pub block_handler: VALUE,
1268 pub recv: VALUE,
1269 pub argc: ::std::os::raw::c_int,
1270 pub kw_splat: ::std::os::raw::c_int,
1271}
1272#[repr(C)]
1273#[derive(Debug, Copy, Clone)]
1274pub struct rb_iseq_location_struct {
1275 pub pathobj: VALUE,
1276 pub base_label: VALUE,
1277 pub label: VALUE,
1278 pub first_lineno: VALUE,
1279 pub node_id: ::std::os::raw::c_int,
1280 pub code_location: rb_code_location_t,
1281}
1282pub type rb_iseq_location_t = rb_iseq_location_struct;
1283#[repr(C)]
1284#[derive(Debug, Copy, Clone)]
1285pub struct rb_mjit_unit {
1286 _unused: [u8; 0],
1287}
1288#[repr(C)]
1289#[derive(Debug, Copy, Clone)]
1290pub struct rb_iseq_constant_body {
1291 pub type_: rb_iseq_constant_body_iseq_type,
1292 pub iseq_size: ::std::os::raw::c_uint,
1293 pub iseq_encoded: *mut VALUE,
1294 pub param: rb_iseq_constant_body__bindgen_ty_1,
1295 pub location: rb_iseq_location_t,
1296 pub insns_info: rb_iseq_constant_body_iseq_insn_info,
1297 pub local_table: *const ID,
1298 pub catch_table: *mut iseq_catch_table,
1299 pub parent_iseq: *const rb_iseq_struct,
1300 pub local_iseq: *mut rb_iseq_struct,
1301 pub is_entries: *mut iseq_inline_storage_entry,
1302 pub call_data: *mut rb_call_data,
1303 pub variable: rb_iseq_constant_body__bindgen_ty_2,
1304 pub local_table_size: ::std::os::raw::c_uint,
1305 pub is_size: ::std::os::raw::c_uint,
1306 pub ci_size: ::std::os::raw::c_uint,
1307 pub ci_kw_size: ::std::os::raw::c_uint,
1308 pub stack_max: ::std::os::raw::c_uint,
1309 pub catch_except_p: ::std::os::raw::c_char,
1310 pub jit_func: ::std::option::Option<
1311 unsafe extern "C" fn(
1312 arg1: *mut rb_execution_context_struct,
1313 arg2: *mut rb_control_frame_struct,
1314 ) -> VALUE,
1315 >,
1316 pub total_calls: ::std::os::raw::c_ulong,
1317 pub jit_unit: *mut rb_mjit_unit,
1318 pub iseq_unique_id: usize,
1319}
1320pub const rb_iseq_constant_body_iseq_type_ISEQ_TYPE_TOP: rb_iseq_constant_body_iseq_type = 0;
1321pub const rb_iseq_constant_body_iseq_type_ISEQ_TYPE_METHOD: rb_iseq_constant_body_iseq_type = 1;
1322pub const rb_iseq_constant_body_iseq_type_ISEQ_TYPE_BLOCK: rb_iseq_constant_body_iseq_type = 2;
1323pub const rb_iseq_constant_body_iseq_type_ISEQ_TYPE_CLASS: rb_iseq_constant_body_iseq_type = 3;
1324pub const rb_iseq_constant_body_iseq_type_ISEQ_TYPE_RESCUE: rb_iseq_constant_body_iseq_type = 4;
1325pub const rb_iseq_constant_body_iseq_type_ISEQ_TYPE_ENSURE: rb_iseq_constant_body_iseq_type = 5;
1326pub const rb_iseq_constant_body_iseq_type_ISEQ_TYPE_EVAL: rb_iseq_constant_body_iseq_type = 6;
1327pub const rb_iseq_constant_body_iseq_type_ISEQ_TYPE_MAIN: rb_iseq_constant_body_iseq_type = 7;
1328pub const rb_iseq_constant_body_iseq_type_ISEQ_TYPE_PLAIN: rb_iseq_constant_body_iseq_type = 8;
1329pub type rb_iseq_constant_body_iseq_type = ::std::os::raw::c_uint;
1330#[repr(C)]
1331#[derive(Debug, Copy, Clone)]
1332pub struct rb_iseq_constant_body__bindgen_ty_1 {
1333 pub flags: rb_iseq_constant_body__bindgen_ty_1__bindgen_ty_1,
1334 pub size: ::std::os::raw::c_uint,
1335 pub lead_num: ::std::os::raw::c_int,
1336 pub opt_num: ::std::os::raw::c_int,
1337 pub rest_start: ::std::os::raw::c_int,
1338 pub post_start: ::std::os::raw::c_int,
1339 pub post_num: ::std::os::raw::c_int,
1340 pub block_start: ::std::os::raw::c_int,
1341 pub opt_table: *const VALUE,
1342 pub keyword: *const rb_iseq_constant_body__bindgen_ty_1_rb_iseq_param_keyword,
1343}
1344#[repr(C)]
1345#[repr(align(4))]
1346#[derive(Debug, Copy, Clone)]
1347pub struct rb_iseq_constant_body__bindgen_ty_1__bindgen_ty_1 {
1348 pub _bitfield_align_1: [u8; 0],
1349 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
1350 pub __bindgen_padding_0: u16,
1351}
1352impl rb_iseq_constant_body__bindgen_ty_1__bindgen_ty_1 {
1353 #[inline]
1354 pub fn has_lead(&self) -> ::std::os::raw::c_uint {
1355 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1356 }
1357 #[inline]
1358 pub fn set_has_lead(&mut self, val: ::std::os::raw::c_uint) {
1359 unsafe {
1360 let val: u32 = ::std::mem::transmute(val);
1361 self._bitfield_1.set(0usize, 1u8, val as u64)
1362 }
1363 }
1364 #[inline]
1365 pub unsafe fn has_lead_raw(this: *const Self) -> ::std::os::raw::c_uint {
1366 unsafe {
1367 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1368 ::std::ptr::addr_of!((*this)._bitfield_1),
1369 0usize,
1370 1u8,
1371 ) as u32)
1372 }
1373 }
1374 #[inline]
1375 pub unsafe fn set_has_lead_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1376 unsafe {
1377 let val: u32 = ::std::mem::transmute(val);
1378 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1379 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1380 0usize,
1381 1u8,
1382 val as u64,
1383 )
1384 }
1385 }
1386 #[inline]
1387 pub fn has_opt(&self) -> ::std::os::raw::c_uint {
1388 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1389 }
1390 #[inline]
1391 pub fn set_has_opt(&mut self, val: ::std::os::raw::c_uint) {
1392 unsafe {
1393 let val: u32 = ::std::mem::transmute(val);
1394 self._bitfield_1.set(1usize, 1u8, val as u64)
1395 }
1396 }
1397 #[inline]
1398 pub unsafe fn has_opt_raw(this: *const Self) -> ::std::os::raw::c_uint {
1399 unsafe {
1400 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1401 ::std::ptr::addr_of!((*this)._bitfield_1),
1402 1usize,
1403 1u8,
1404 ) as u32)
1405 }
1406 }
1407 #[inline]
1408 pub unsafe fn set_has_opt_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1409 unsafe {
1410 let val: u32 = ::std::mem::transmute(val);
1411 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1412 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1413 1usize,
1414 1u8,
1415 val as u64,
1416 )
1417 }
1418 }
1419 #[inline]
1420 pub fn has_rest(&self) -> ::std::os::raw::c_uint {
1421 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1422 }
1423 #[inline]
1424 pub fn set_has_rest(&mut self, val: ::std::os::raw::c_uint) {
1425 unsafe {
1426 let val: u32 = ::std::mem::transmute(val);
1427 self._bitfield_1.set(2usize, 1u8, val as u64)
1428 }
1429 }
1430 #[inline]
1431 pub unsafe fn has_rest_raw(this: *const Self) -> ::std::os::raw::c_uint {
1432 unsafe {
1433 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1434 ::std::ptr::addr_of!((*this)._bitfield_1),
1435 2usize,
1436 1u8,
1437 ) as u32)
1438 }
1439 }
1440 #[inline]
1441 pub unsafe fn set_has_rest_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1442 unsafe {
1443 let val: u32 = ::std::mem::transmute(val);
1444 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1445 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1446 2usize,
1447 1u8,
1448 val as u64,
1449 )
1450 }
1451 }
1452 #[inline]
1453 pub fn has_post(&self) -> ::std::os::raw::c_uint {
1454 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
1455 }
1456 #[inline]
1457 pub fn set_has_post(&mut self, val: ::std::os::raw::c_uint) {
1458 unsafe {
1459 let val: u32 = ::std::mem::transmute(val);
1460 self._bitfield_1.set(3usize, 1u8, val as u64)
1461 }
1462 }
1463 #[inline]
1464 pub unsafe fn has_post_raw(this: *const Self) -> ::std::os::raw::c_uint {
1465 unsafe {
1466 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1467 ::std::ptr::addr_of!((*this)._bitfield_1),
1468 3usize,
1469 1u8,
1470 ) as u32)
1471 }
1472 }
1473 #[inline]
1474 pub unsafe fn set_has_post_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1475 unsafe {
1476 let val: u32 = ::std::mem::transmute(val);
1477 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1478 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1479 3usize,
1480 1u8,
1481 val as u64,
1482 )
1483 }
1484 }
1485 #[inline]
1486 pub fn has_kw(&self) -> ::std::os::raw::c_uint {
1487 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1488 }
1489 #[inline]
1490 pub fn set_has_kw(&mut self, val: ::std::os::raw::c_uint) {
1491 unsafe {
1492 let val: u32 = ::std::mem::transmute(val);
1493 self._bitfield_1.set(4usize, 1u8, val as u64)
1494 }
1495 }
1496 #[inline]
1497 pub unsafe fn has_kw_raw(this: *const Self) -> ::std::os::raw::c_uint {
1498 unsafe {
1499 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1500 ::std::ptr::addr_of!((*this)._bitfield_1),
1501 4usize,
1502 1u8,
1503 ) as u32)
1504 }
1505 }
1506 #[inline]
1507 pub unsafe fn set_has_kw_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1508 unsafe {
1509 let val: u32 = ::std::mem::transmute(val);
1510 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1511 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1512 4usize,
1513 1u8,
1514 val as u64,
1515 )
1516 }
1517 }
1518 #[inline]
1519 pub fn has_kwrest(&self) -> ::std::os::raw::c_uint {
1520 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1521 }
1522 #[inline]
1523 pub fn set_has_kwrest(&mut self, val: ::std::os::raw::c_uint) {
1524 unsafe {
1525 let val: u32 = ::std::mem::transmute(val);
1526 self._bitfield_1.set(5usize, 1u8, val as u64)
1527 }
1528 }
1529 #[inline]
1530 pub unsafe fn has_kwrest_raw(this: *const Self) -> ::std::os::raw::c_uint {
1531 unsafe {
1532 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1533 ::std::ptr::addr_of!((*this)._bitfield_1),
1534 5usize,
1535 1u8,
1536 ) as u32)
1537 }
1538 }
1539 #[inline]
1540 pub unsafe fn set_has_kwrest_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1541 unsafe {
1542 let val: u32 = ::std::mem::transmute(val);
1543 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1544 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1545 5usize,
1546 1u8,
1547 val as u64,
1548 )
1549 }
1550 }
1551 #[inline]
1552 pub fn has_block(&self) -> ::std::os::raw::c_uint {
1553 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1554 }
1555 #[inline]
1556 pub fn set_has_block(&mut self, val: ::std::os::raw::c_uint) {
1557 unsafe {
1558 let val: u32 = ::std::mem::transmute(val);
1559 self._bitfield_1.set(6usize, 1u8, val as u64)
1560 }
1561 }
1562 #[inline]
1563 pub unsafe fn has_block_raw(this: *const Self) -> ::std::os::raw::c_uint {
1564 unsafe {
1565 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1566 ::std::ptr::addr_of!((*this)._bitfield_1),
1567 6usize,
1568 1u8,
1569 ) as u32)
1570 }
1571 }
1572 #[inline]
1573 pub unsafe fn set_has_block_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1574 unsafe {
1575 let val: u32 = ::std::mem::transmute(val);
1576 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1577 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1578 6usize,
1579 1u8,
1580 val as u64,
1581 )
1582 }
1583 }
1584 #[inline]
1585 pub fn ambiguous_param0(&self) -> ::std::os::raw::c_uint {
1586 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
1587 }
1588 #[inline]
1589 pub fn set_ambiguous_param0(&mut self, val: ::std::os::raw::c_uint) {
1590 unsafe {
1591 let val: u32 = ::std::mem::transmute(val);
1592 self._bitfield_1.set(7usize, 1u8, val as u64)
1593 }
1594 }
1595 #[inline]
1596 pub unsafe fn ambiguous_param0_raw(this: *const Self) -> ::std::os::raw::c_uint {
1597 unsafe {
1598 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1599 ::std::ptr::addr_of!((*this)._bitfield_1),
1600 7usize,
1601 1u8,
1602 ) as u32)
1603 }
1604 }
1605 #[inline]
1606 pub unsafe fn set_ambiguous_param0_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1607 unsafe {
1608 let val: u32 = ::std::mem::transmute(val);
1609 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1610 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1611 7usize,
1612 1u8,
1613 val as u64,
1614 )
1615 }
1616 }
1617 #[inline]
1618 pub fn accepts_no_kwarg(&self) -> ::std::os::raw::c_uint {
1619 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
1620 }
1621 #[inline]
1622 pub fn set_accepts_no_kwarg(&mut self, val: ::std::os::raw::c_uint) {
1623 unsafe {
1624 let val: u32 = ::std::mem::transmute(val);
1625 self._bitfield_1.set(8usize, 1u8, val as u64)
1626 }
1627 }
1628 #[inline]
1629 pub unsafe fn accepts_no_kwarg_raw(this: *const Self) -> ::std::os::raw::c_uint {
1630 unsafe {
1631 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1632 ::std::ptr::addr_of!((*this)._bitfield_1),
1633 8usize,
1634 1u8,
1635 ) as u32)
1636 }
1637 }
1638 #[inline]
1639 pub unsafe fn set_accepts_no_kwarg_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1640 unsafe {
1641 let val: u32 = ::std::mem::transmute(val);
1642 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1643 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1644 8usize,
1645 1u8,
1646 val as u64,
1647 )
1648 }
1649 }
1650 #[inline]
1651 pub fn ruby2_keywords(&self) -> ::std::os::raw::c_uint {
1652 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
1653 }
1654 #[inline]
1655 pub fn set_ruby2_keywords(&mut self, val: ::std::os::raw::c_uint) {
1656 unsafe {
1657 let val: u32 = ::std::mem::transmute(val);
1658 self._bitfield_1.set(9usize, 1u8, val as u64)
1659 }
1660 }
1661 #[inline]
1662 pub unsafe fn ruby2_keywords_raw(this: *const Self) -> ::std::os::raw::c_uint {
1663 unsafe {
1664 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
1665 ::std::ptr::addr_of!((*this)._bitfield_1),
1666 9usize,
1667 1u8,
1668 ) as u32)
1669 }
1670 }
1671 #[inline]
1672 pub unsafe fn set_ruby2_keywords_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1673 unsafe {
1674 let val: u32 = ::std::mem::transmute(val);
1675 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
1676 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1677 9usize,
1678 1u8,
1679 val as u64,
1680 )
1681 }
1682 }
1683 #[inline]
1684 pub fn new_bitfield_1(
1685 has_lead: ::std::os::raw::c_uint,
1686 has_opt: ::std::os::raw::c_uint,
1687 has_rest: ::std::os::raw::c_uint,
1688 has_post: ::std::os::raw::c_uint,
1689 has_kw: ::std::os::raw::c_uint,
1690 has_kwrest: ::std::os::raw::c_uint,
1691 has_block: ::std::os::raw::c_uint,
1692 ambiguous_param0: ::std::os::raw::c_uint,
1693 accepts_no_kwarg: ::std::os::raw::c_uint,
1694 ruby2_keywords: ::std::os::raw::c_uint,
1695 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
1696 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
1697 __bindgen_bitfield_unit.set(0usize, 1u8, {
1698 let has_lead: u32 = unsafe { ::std::mem::transmute(has_lead) };
1699 has_lead as u64
1700 });
1701 __bindgen_bitfield_unit.set(1usize, 1u8, {
1702 let has_opt: u32 = unsafe { ::std::mem::transmute(has_opt) };
1703 has_opt as u64
1704 });
1705 __bindgen_bitfield_unit.set(2usize, 1u8, {
1706 let has_rest: u32 = unsafe { ::std::mem::transmute(has_rest) };
1707 has_rest as u64
1708 });
1709 __bindgen_bitfield_unit.set(3usize, 1u8, {
1710 let has_post: u32 = unsafe { ::std::mem::transmute(has_post) };
1711 has_post as u64
1712 });
1713 __bindgen_bitfield_unit.set(4usize, 1u8, {
1714 let has_kw: u32 = unsafe { ::std::mem::transmute(has_kw) };
1715 has_kw as u64
1716 });
1717 __bindgen_bitfield_unit.set(5usize, 1u8, {
1718 let has_kwrest: u32 = unsafe { ::std::mem::transmute(has_kwrest) };
1719 has_kwrest as u64
1720 });
1721 __bindgen_bitfield_unit.set(6usize, 1u8, {
1722 let has_block: u32 = unsafe { ::std::mem::transmute(has_block) };
1723 has_block as u64
1724 });
1725 __bindgen_bitfield_unit.set(7usize, 1u8, {
1726 let ambiguous_param0: u32 = unsafe { ::std::mem::transmute(ambiguous_param0) };
1727 ambiguous_param0 as u64
1728 });
1729 __bindgen_bitfield_unit.set(8usize, 1u8, {
1730 let accepts_no_kwarg: u32 = unsafe { ::std::mem::transmute(accepts_no_kwarg) };
1731 accepts_no_kwarg as u64
1732 });
1733 __bindgen_bitfield_unit.set(9usize, 1u8, {
1734 let ruby2_keywords: u32 = unsafe { ::std::mem::transmute(ruby2_keywords) };
1735 ruby2_keywords as u64
1736 });
1737 __bindgen_bitfield_unit
1738 }
1739}
1740#[repr(C)]
1741#[derive(Debug, Copy, Clone)]
1742pub struct rb_iseq_constant_body__bindgen_ty_1_rb_iseq_param_keyword {
1743 pub num: ::std::os::raw::c_int,
1744 pub required_num: ::std::os::raw::c_int,
1745 pub bits_start: ::std::os::raw::c_int,
1746 pub rest_start: ::std::os::raw::c_int,
1747 pub table: *const ID,
1748 pub default_values: *mut VALUE,
1749}
1750#[repr(C)]
1751#[derive(Debug, Copy, Clone)]
1752pub struct rb_iseq_constant_body_iseq_insn_info {
1753 pub body: *const iseq_insn_info_entry,
1754 pub positions: *mut ::std::os::raw::c_uint,
1755 pub size: ::std::os::raw::c_uint,
1756 pub succ_index_table: *mut succ_index_table,
1757}
1758#[repr(C)]
1759#[derive(Debug, Copy, Clone)]
1760pub struct rb_iseq_constant_body__bindgen_ty_2 {
1761 pub flip_count: rb_snum_t,
1762 pub coverage: VALUE,
1763 pub pc2branchindex: VALUE,
1764 pub original_iseq: *mut VALUE,
1765}
1766#[repr(C)]
1767#[derive(Copy, Clone)]
1768pub struct rb_iseq_struct {
1769 pub flags: VALUE,
1770 pub wrapper: VALUE,
1771 pub body: *mut rb_iseq_constant_body,
1772 pub aux: rb_iseq_struct__bindgen_ty_1,
1773}
1774#[repr(C)]
1775#[derive(Copy, Clone)]
1776pub union rb_iseq_struct__bindgen_ty_1 {
1777 pub compile_data: *mut iseq_compile_data,
1778 pub loader: rb_iseq_struct__bindgen_ty_1__bindgen_ty_1,
1779 pub exec: rb_iseq_struct__bindgen_ty_1__bindgen_ty_2,
1780}
1781#[repr(C)]
1782#[derive(Debug, Copy, Clone)]
1783pub struct rb_iseq_struct__bindgen_ty_1__bindgen_ty_1 {
1784 pub obj: VALUE,
1785 pub index: ::std::os::raw::c_int,
1786}
1787#[repr(C)]
1788#[derive(Debug, Copy, Clone)]
1789pub struct rb_iseq_struct__bindgen_ty_1__bindgen_ty_2 {
1790 pub local_hooks: *mut rb_hook_list_struct,
1791 pub global_trace_events: rb_event_flag_t,
1792}
1793impl ::std::fmt::Debug for rb_iseq_struct__bindgen_ty_1 {
1794 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1795 write!(f, "rb_iseq_struct__bindgen_ty_1 {{ union }}")
1796 }
1797}
1798impl ::std::fmt::Debug for rb_iseq_struct {
1799 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1800 write!(
1801 f,
1802 "rb_iseq_struct {{ flags: {:?}, wrapper: {:?}, body: {:?}, aux: {:?} }}",
1803 self.flags, self.wrapper, self.body, self.aux
1804 )
1805 }
1806}
1807pub type rb_vm_at_exit_func = ::std::option::Option<unsafe extern "C" fn(arg1: *mut rb_vm_struct)>;
1808#[repr(C)]
1809#[derive(Debug, Copy, Clone)]
1810pub struct rb_at_exit_list {
1811 pub func: rb_vm_at_exit_func,
1812 pub next: *mut rb_at_exit_list,
1813}
1814#[repr(C)]
1815#[derive(Debug, Copy, Clone)]
1816pub struct rb_objspace {
1817 _unused: [u8; 0],
1818}
1819#[repr(C)]
1820#[derive(Debug, Copy, Clone)]
1821pub struct rb_hook_list_struct {
1822 pub hooks: *mut rb_event_hook_struct,
1823 pub events: rb_event_flag_t,
1824 pub need_clean: ::std::os::raw::c_uint,
1825 pub running: ::std::os::raw::c_uint,
1826}
1827pub type rb_hook_list_t = rb_hook_list_struct;
1828#[repr(C)]
1829#[derive(Debug, Copy, Clone)]
1830pub struct rb_builtin_function {
1831 _unused: [u8; 0],
1832}
1833#[repr(C)]
1834#[derive(Copy, Clone)]
1835pub struct rb_vm_struct {
1836 pub self_: VALUE,
1837 pub gvl: rb_global_vm_lock_t,
1838 pub main_thread: *mut rb_thread_struct,
1839 pub running_thread: *const rb_thread_struct,
1840 pub main_altstack: *mut ::std::os::raw::c_void,
1841 pub fork_gen: rb_serial_t,
1842 pub waitpid_lock: rb_nativethread_lock_t,
1843 pub waiting_pids: list_head,
1844 pub waiting_grps: list_head,
1845 pub waiting_fds: list_head,
1846 pub living_threads: list_head,
1847 pub thgroup_default: VALUE,
1848 pub living_thread_num: ::std::os::raw::c_int,
1849 pub ubf_async_safe: ::std::os::raw::c_int,
1850 pub _bitfield_align_1: [u8; 0],
1851 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1852 pub sleeper: ::std::os::raw::c_int,
1853 pub mark_object_ary: VALUE,
1854 pub special_exceptions: [VALUE; 5usize],
1855 pub top_self: VALUE,
1856 pub load_path: VALUE,
1857 pub load_path_snapshot: VALUE,
1858 pub load_path_check_cache: VALUE,
1859 pub expanded_load_path: VALUE,
1860 pub loaded_features: VALUE,
1861 pub loaded_features_snapshot: VALUE,
1862 pub loaded_features_index: *mut st_table,
1863 pub loading_table: *mut st_table,
1864 pub trap_list: rb_vm_struct__bindgen_ty_1,
1865 pub global_hooks: rb_hook_list_t,
1866 pub ensure_rollback_table: *mut st_table,
1867 pub postponed_job_buffer: *mut rb_postponed_job_struct,
1868 pub postponed_job_index: ::std::os::raw::c_int,
1869 pub src_encoding_index: ::std::os::raw::c_int,
1870 pub workqueue: list_head,
1871 pub workqueue_lock: rb_nativethread_lock_t,
1872 pub verbose: VALUE,
1873 pub debug: VALUE,
1874 pub orig_progname: VALUE,
1875 pub progname: VALUE,
1876 pub coverages: VALUE,
1877 pub coverage_mode: ::std::os::raw::c_int,
1878 pub defined_module_hash: *mut st_table,
1879 pub objspace: *mut rb_objspace,
1880 pub at_exit: *mut rb_at_exit_list,
1881 pub defined_strings: *mut VALUE,
1882 pub frozen_strings: *mut st_table,
1883 pub builtin_function_table: *const rb_builtin_function,
1884 pub builtin_inline_index: ::std::os::raw::c_int,
1885 pub default_params: rb_vm_struct__bindgen_ty_2,
1886 pub redefined_flag: [::std::os::raw::c_short; 29usize],
1887}
1888#[repr(C)]
1889#[derive(Debug, Copy, Clone)]
1890pub struct rb_vm_struct__bindgen_ty_1 {
1891 pub cmd: [VALUE; 65usize],
1892}
1893#[repr(C)]
1894#[derive(Debug, Copy, Clone)]
1895pub struct rb_vm_struct__bindgen_ty_2 {
1896 pub thread_vm_stack_size: usize,
1897 pub thread_machine_stack_size: usize,
1898 pub fiber_vm_stack_size: usize,
1899 pub fiber_machine_stack_size: usize,
1900}
1901impl ::std::fmt::Debug for rb_vm_struct {
1902 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1903 write ! (f , "rb_vm_struct {{ self: {:?}, gvl: {:?}, main_thread: {:?}, running_thread: {:?}, main_altstack: {:?}, fork_gen: {:?}, waitpid_lock: {:?}, waiting_pids: {:?}, waiting_grps: {:?}, waiting_fds: {:?}, living_threads: {:?}, thgroup_default: {:?}, living_thread_num: {:?}, ubf_async_safe: {:?}, running : {:?}, thread_abort_on_exception : {:?}, thread_report_on_exception : {:?}, safe_level_ : {:?}, 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: {:?}, global_hooks: {:?}, ensure_rollback_table: {:?}, postponed_job_buffer: {:?}, postponed_job_index: {:?}, src_encoding_index: {:?}, workqueue: {:?}, workqueue_lock: {:?}, verbose: {:?}, debug: {:?}, orig_progname: {:?}, progname: {:?}, coverages: {:?}, coverage_mode: {:?}, defined_module_hash: {:?}, objspace: {:?}, at_exit: {:?}, defined_strings: {:?}, frozen_strings: {:?}, builtin_function_table: {:?}, builtin_inline_index: {:?}, default_params: {:?}, redefined_flag: {:?} }}" , self . self_ , self . gvl , self . main_thread , self . running_thread , self . main_altstack , self . fork_gen , self . waitpid_lock , self . waiting_pids , self . waiting_grps , self . waiting_fds , self . living_threads , self . thgroup_default , self . living_thread_num , self . ubf_async_safe , self . running () , self . thread_abort_on_exception () , self . thread_report_on_exception () , self . safe_level_ () , 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 . global_hooks , self . ensure_rollback_table , self . postponed_job_buffer , self . postponed_job_index , self . src_encoding_index , self . workqueue , self . workqueue_lock , self . verbose , self . debug , self . orig_progname , self . progname , self . coverages , self . coverage_mode , self . defined_module_hash , self . objspace , self . at_exit , self . defined_strings , self . frozen_strings , self . builtin_function_table , self . builtin_inline_index , self . default_params , self . redefined_flag)
1904 }
1905}
1906impl rb_vm_struct {
1907 #[inline]
1908 pub fn running(&self) -> ::std::os::raw::c_uint {
1909 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1910 }
1911 #[inline]
1912 pub fn set_running(&mut self, val: ::std::os::raw::c_uint) {
1913 unsafe {
1914 let val: u32 = ::std::mem::transmute(val);
1915 self._bitfield_1.set(0usize, 1u8, val as u64)
1916 }
1917 }
1918 #[inline]
1919 pub unsafe fn running_raw(this: *const Self) -> ::std::os::raw::c_uint {
1920 unsafe {
1921 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1922 ::std::ptr::addr_of!((*this)._bitfield_1),
1923 0usize,
1924 1u8,
1925 ) as u32)
1926 }
1927 }
1928 #[inline]
1929 pub unsafe fn set_running_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1930 unsafe {
1931 let val: u32 = ::std::mem::transmute(val);
1932 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1933 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1934 0usize,
1935 1u8,
1936 val as u64,
1937 )
1938 }
1939 }
1940 #[inline]
1941 pub fn thread_abort_on_exception(&self) -> ::std::os::raw::c_uint {
1942 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1943 }
1944 #[inline]
1945 pub fn set_thread_abort_on_exception(&mut self, val: ::std::os::raw::c_uint) {
1946 unsafe {
1947 let val: u32 = ::std::mem::transmute(val);
1948 self._bitfield_1.set(1usize, 1u8, val as u64)
1949 }
1950 }
1951 #[inline]
1952 pub unsafe fn thread_abort_on_exception_raw(this: *const Self) -> ::std::os::raw::c_uint {
1953 unsafe {
1954 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1955 ::std::ptr::addr_of!((*this)._bitfield_1),
1956 1usize,
1957 1u8,
1958 ) as u32)
1959 }
1960 }
1961 #[inline]
1962 pub unsafe fn set_thread_abort_on_exception_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1963 unsafe {
1964 let val: u32 = ::std::mem::transmute(val);
1965 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1966 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
1967 1usize,
1968 1u8,
1969 val as u64,
1970 )
1971 }
1972 }
1973 #[inline]
1974 pub fn thread_report_on_exception(&self) -> ::std::os::raw::c_uint {
1975 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1976 }
1977 #[inline]
1978 pub fn set_thread_report_on_exception(&mut self, val: ::std::os::raw::c_uint) {
1979 unsafe {
1980 let val: u32 = ::std::mem::transmute(val);
1981 self._bitfield_1.set(2usize, 1u8, val as u64)
1982 }
1983 }
1984 #[inline]
1985 pub unsafe fn thread_report_on_exception_raw(this: *const Self) -> ::std::os::raw::c_uint {
1986 unsafe {
1987 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
1988 ::std::ptr::addr_of!((*this)._bitfield_1),
1989 2usize,
1990 1u8,
1991 ) as u32)
1992 }
1993 }
1994 #[inline]
1995 pub unsafe fn set_thread_report_on_exception_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
1996 unsafe {
1997 let val: u32 = ::std::mem::transmute(val);
1998 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
1999 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2000 2usize,
2001 1u8,
2002 val as u64,
2003 )
2004 }
2005 }
2006 #[inline]
2007 pub fn safe_level_(&self) -> ::std::os::raw::c_uint {
2008 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2009 }
2010 #[inline]
2011 pub fn set_safe_level_(&mut self, val: ::std::os::raw::c_uint) {
2012 unsafe {
2013 let val: u32 = ::std::mem::transmute(val);
2014 self._bitfield_1.set(3usize, 1u8, val as u64)
2015 }
2016 }
2017 #[inline]
2018 pub unsafe fn safe_level__raw(this: *const Self) -> ::std::os::raw::c_uint {
2019 unsafe {
2020 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2021 ::std::ptr::addr_of!((*this)._bitfield_1),
2022 3usize,
2023 1u8,
2024 ) as u32)
2025 }
2026 }
2027 #[inline]
2028 pub unsafe fn set_safe_level__raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2029 unsafe {
2030 let val: u32 = ::std::mem::transmute(val);
2031 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2032 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2033 3usize,
2034 1u8,
2035 val as u64,
2036 )
2037 }
2038 }
2039 #[inline]
2040 pub fn new_bitfield_1(
2041 running: ::std::os::raw::c_uint,
2042 thread_abort_on_exception: ::std::os::raw::c_uint,
2043 thread_report_on_exception: ::std::os::raw::c_uint,
2044 safe_level_: ::std::os::raw::c_uint,
2045 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2046 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2047 __bindgen_bitfield_unit.set(0usize, 1u8, {
2048 let running: u32 = unsafe { ::std::mem::transmute(running) };
2049 running as u64
2050 });
2051 __bindgen_bitfield_unit.set(1usize, 1u8, {
2052 let thread_abort_on_exception: u32 =
2053 unsafe { ::std::mem::transmute(thread_abort_on_exception) };
2054 thread_abort_on_exception as u64
2055 });
2056 __bindgen_bitfield_unit.set(2usize, 1u8, {
2057 let thread_report_on_exception: u32 =
2058 unsafe { ::std::mem::transmute(thread_report_on_exception) };
2059 thread_report_on_exception as u64
2060 });
2061 __bindgen_bitfield_unit.set(3usize, 1u8, {
2062 let safe_level_: u32 = unsafe { ::std::mem::transmute(safe_level_) };
2063 safe_level_ as u64
2064 });
2065 __bindgen_bitfield_unit
2066 }
2067}
2068pub type rb_vm_t = rb_vm_struct;
2069#[repr(C)]
2070#[derive(Debug, Copy, Clone)]
2071pub struct rb_control_frame_struct {
2072 pub pc: *const VALUE,
2073 pub sp: *mut VALUE,
2074 pub iseq: *const rb_iseq_t,
2075 pub self_: VALUE,
2076 pub ep: *const VALUE,
2077 pub block_code: *const ::std::os::raw::c_void,
2078 pub __bp__: *mut VALUE,
2079}
2080pub type rb_control_frame_t = rb_control_frame_struct;
2081pub const rb_thread_status_THREAD_RUNNABLE: rb_thread_status = 0;
2082pub const rb_thread_status_THREAD_STOPPED: rb_thread_status = 1;
2083pub const rb_thread_status_THREAD_STOPPED_FOREVER: rb_thread_status = 2;
2084pub const rb_thread_status_THREAD_KILLED: rb_thread_status = 3;
2085pub type rb_thread_status = ::std::os::raw::c_uint;
2086pub type rb_jmpbuf_t = sigjmp_buf;
2087#[repr(C)]
2088#[derive(Debug, Copy, Clone)]
2089pub struct rb_vm_tag {
2090 pub tag: VALUE,
2091 pub retval: VALUE,
2092 pub buf: rb_jmpbuf_t,
2093 pub prev: *mut rb_vm_tag,
2094 pub state: ruby_tag_type,
2095}
2096#[repr(C)]
2097#[derive(Debug, Copy, Clone)]
2098pub struct rb_vm_protect_tag {
2099 pub prev: *mut rb_vm_protect_tag,
2100}
2101#[repr(C)]
2102#[derive(Debug, Copy, Clone)]
2103pub struct rb_unblock_callback {
2104 pub func: rb_unblock_function_t,
2105 pub arg: *mut ::std::os::raw::c_void,
2106}
2107#[repr(C)]
2108#[derive(Debug, Copy, Clone)]
2109pub struct rb_mutex_struct {
2110 _unused: [u8; 0],
2111}
2112#[repr(C)]
2113#[derive(Debug, Copy, Clone)]
2114pub struct rb_thread_list_struct {
2115 pub next: *mut rb_thread_list_struct,
2116 pub th: *mut rb_thread_struct,
2117}
2118pub type rb_thread_list_t = rb_thread_list_struct;
2119#[repr(C)]
2120#[derive(Debug, Copy, Clone)]
2121pub struct rb_ensure_entry {
2122 pub marker: VALUE,
2123 pub e_proc: ::std::option::Option<unsafe extern "C" fn(arg1: VALUE) -> VALUE>,
2124 pub data2: VALUE,
2125}
2126#[repr(C)]
2127#[derive(Debug, Copy, Clone)]
2128pub struct rb_ensure_list {
2129 pub next: *mut rb_ensure_list,
2130 pub entry: rb_ensure_entry,
2131}
2132pub type rb_ensure_list_t = rb_ensure_list;
2133#[repr(C)]
2134#[derive(Debug, Copy, Clone)]
2135pub struct rb_fiber_struct {
2136 _unused: [u8; 0],
2137}
2138pub type rb_fiber_t = rb_fiber_struct;
2139#[repr(C)]
2140#[derive(Debug, Copy, Clone)]
2141pub struct rb_execution_context_struct {
2142 pub vm_stack: *mut VALUE,
2143 pub vm_stack_size: usize,
2144 pub cfp: *mut rb_control_frame_t,
2145 pub tag: *mut rb_vm_tag,
2146 pub protect_tag: *mut rb_vm_protect_tag,
2147 pub interrupt_flag: rb_atomic_t,
2148 pub interrupt_mask: rb_atomic_t,
2149 pub fiber_ptr: *mut rb_fiber_t,
2150 pub thread_ptr: *mut rb_thread_struct,
2151 pub local_storage: *mut st_table,
2152 pub local_storage_recursive_hash: VALUE,
2153 pub local_storage_recursive_hash_for_trace: VALUE,
2154 pub root_lep: *const VALUE,
2155 pub root_svar: VALUE,
2156 pub ensure_list: *mut rb_ensure_list_t,
2157 pub trace_arg: *mut rb_trace_arg_struct,
2158 pub errinfo: VALUE,
2159 pub passed_block_handler: VALUE,
2160 pub raised_flag: u8,
2161 pub _bitfield_align_1: [u8; 0],
2162 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2163 pub private_const_reference: VALUE,
2164 pub machine: rb_execution_context_struct__bindgen_ty_1,
2165}
2166#[repr(C)]
2167#[derive(Debug, Copy, Clone)]
2168pub struct rb_execution_context_struct__bindgen_ty_1 {
2169 pub stack_start: *mut VALUE,
2170 pub stack_end: *mut VALUE,
2171 pub stack_maxsize: usize,
2172 pub regs: jmp_buf,
2173}
2174impl rb_execution_context_struct {
2175 #[inline]
2176 pub fn method_missing_reason(&self) -> method_missing_reason {
2177 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
2178 }
2179 #[inline]
2180 pub fn set_method_missing_reason(&mut self, val: method_missing_reason) {
2181 unsafe {
2182 let val: u32 = ::std::mem::transmute(val);
2183 self._bitfield_1.set(0usize, 8u8, val as u64)
2184 }
2185 }
2186 #[inline]
2187 pub unsafe fn method_missing_reason_raw(this: *const Self) -> method_missing_reason {
2188 unsafe {
2189 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2190 ::std::ptr::addr_of!((*this)._bitfield_1),
2191 0usize,
2192 8u8,
2193 ) as u32)
2194 }
2195 }
2196 #[inline]
2197 pub unsafe fn set_method_missing_reason_raw(this: *mut Self, val: method_missing_reason) {
2198 unsafe {
2199 let val: u32 = ::std::mem::transmute(val);
2200 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2201 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2202 0usize,
2203 8u8,
2204 val as u64,
2205 )
2206 }
2207 }
2208 #[inline]
2209 pub fn new_bitfield_1(
2210 method_missing_reason: method_missing_reason,
2211 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2212 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2213 __bindgen_bitfield_unit.set(0usize, 8u8, {
2214 let method_missing_reason: u32 =
2215 unsafe { ::std::mem::transmute(method_missing_reason) };
2216 method_missing_reason as u64
2217 });
2218 __bindgen_bitfield_unit
2219 }
2220}
2221pub type rb_execution_context_t = rb_execution_context_struct;
2222#[repr(C)]
2223#[derive(Copy, Clone)]
2224pub struct rb_thread_struct {
2225 pub vmlt_node: list_node,
2226 pub self_: VALUE,
2227 pub vm: *mut rb_vm_t,
2228 pub ec: *mut rb_execution_context_t,
2229 pub last_status: VALUE,
2230 pub calling: *mut rb_calling_info,
2231 pub top_self: VALUE,
2232 pub top_wrapper: VALUE,
2233 pub thread_id: rb_nativethread_id_t,
2234 pub _bitfield_align_1: [u8; 0],
2235 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2236 pub priority: i8,
2237 pub running_time_us: u32,
2238 pub native_thread_data: native_thread_data_t,
2239 pub blocking_region_buffer: *mut ::std::os::raw::c_void,
2240 pub thgroup: VALUE,
2241 pub value: VALUE,
2242 pub pending_interrupt_queue: VALUE,
2243 pub pending_interrupt_mask_stack: VALUE,
2244 pub interrupt_lock: rb_nativethread_lock_t,
2245 pub unblock: rb_unblock_callback,
2246 pub locking_mutex: VALUE,
2247 pub keeping_mutexes: *mut rb_mutex_struct,
2248 pub join_list: *mut rb_thread_list_t,
2249 pub invoke_arg: rb_thread_struct__bindgen_ty_1,
2250 pub invoke_type: rb_thread_struct__bindgen_ty_2,
2251 pub stat_insn_usage: VALUE,
2252 pub root_fiber: *mut rb_fiber_t,
2253 pub root_jmpbuf: rb_jmpbuf_t,
2254 pub name: VALUE,
2255}
2256#[repr(C)]
2257#[derive(Copy, Clone)]
2258pub union rb_thread_struct__bindgen_ty_1 {
2259 pub proc_: rb_thread_struct__bindgen_ty_1__bindgen_ty_1,
2260 pub func: rb_thread_struct__bindgen_ty_1__bindgen_ty_2,
2261}
2262#[repr(C)]
2263#[derive(Debug, Copy, Clone)]
2264pub struct rb_thread_struct__bindgen_ty_1__bindgen_ty_1 {
2265 pub proc_: VALUE,
2266 pub args: VALUE,
2267 pub kw_splat: ::std::os::raw::c_int,
2268}
2269#[repr(C)]
2270#[derive(Debug, Copy, Clone)]
2271pub struct rb_thread_struct__bindgen_ty_1__bindgen_ty_2 {
2272 pub func:
2273 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> VALUE>,
2274 pub arg: *mut ::std::os::raw::c_void,
2275}
2276impl ::std::fmt::Debug for rb_thread_struct__bindgen_ty_1 {
2277 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2278 write!(f, "rb_thread_struct__bindgen_ty_1 {{ union }}")
2279 }
2280}
2281pub const rb_thread_struct_thread_invoke_type_none: rb_thread_struct__bindgen_ty_2 = 0;
2282pub const rb_thread_struct_thread_invoke_type_proc: rb_thread_struct__bindgen_ty_2 = 1;
2283pub const rb_thread_struct_thread_invoke_type_func: rb_thread_struct__bindgen_ty_2 = 2;
2284pub type rb_thread_struct__bindgen_ty_2 = ::std::os::raw::c_uint;
2285impl ::std::fmt::Debug for rb_thread_struct {
2286 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2287 write ! (f , "rb_thread_struct {{ vmlt_node: {:?}, self: {:?}, vm: {:?}, ec: {:?}, last_status: {:?}, calling: {:?}, top_self: {:?}, top_wrapper: {:?}, thread_id: {:?}, status : {:?}, to_kill : {:?}, abort_on_exception : {:?}, report_on_exception : {:?}, pending_interrupt_queue_checked : {:?}, native_thread_data: {:?}, blocking_region_buffer: {:?}, thgroup: {:?}, value: {:?}, pending_interrupt_queue: {:?}, pending_interrupt_mask_stack: {:?}, interrupt_lock: {:?}, unblock: {:?}, locking_mutex: {:?}, keeping_mutexes: {:?}, join_list: {:?}, invoke_arg: {:?}, invoke_type: {:?}, stat_insn_usage: {:?}, root_fiber: {:?}, root_jmpbuf: {:?}, name: {:?} }}" , self . vmlt_node , self . self_ , self . vm , self . ec , self . last_status , self . calling , self . top_self , self . top_wrapper , self . thread_id , self . status () , self . to_kill () , self . abort_on_exception () , self . report_on_exception () , self . pending_interrupt_queue_checked () , self . native_thread_data , self . blocking_region_buffer , self . thgroup , self . value , self . pending_interrupt_queue , self . pending_interrupt_mask_stack , self . interrupt_lock , self . unblock , self . locking_mutex , self . keeping_mutexes , self . join_list , self . invoke_arg , self . invoke_type , self . stat_insn_usage , self . root_fiber , self . root_jmpbuf , self . name)
2288 }
2289}
2290impl rb_thread_struct {
2291 #[inline]
2292 pub fn status(&self) -> rb_thread_status {
2293 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
2294 }
2295 #[inline]
2296 pub fn set_status(&mut self, val: rb_thread_status) {
2297 unsafe {
2298 let val: u32 = ::std::mem::transmute(val);
2299 self._bitfield_1.set(0usize, 2u8, val as u64)
2300 }
2301 }
2302 #[inline]
2303 pub unsafe fn status_raw(this: *const Self) -> rb_thread_status {
2304 unsafe {
2305 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2306 ::std::ptr::addr_of!((*this)._bitfield_1),
2307 0usize,
2308 2u8,
2309 ) as u32)
2310 }
2311 }
2312 #[inline]
2313 pub unsafe fn set_status_raw(this: *mut Self, val: rb_thread_status) {
2314 unsafe {
2315 let val: u32 = ::std::mem::transmute(val);
2316 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2317 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2318 0usize,
2319 2u8,
2320 val as u64,
2321 )
2322 }
2323 }
2324 #[inline]
2325 pub fn to_kill(&self) -> ::std::os::raw::c_uint {
2326 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2327 }
2328 #[inline]
2329 pub fn set_to_kill(&mut self, val: ::std::os::raw::c_uint) {
2330 unsafe {
2331 let val: u32 = ::std::mem::transmute(val);
2332 self._bitfield_1.set(2usize, 1u8, val as u64)
2333 }
2334 }
2335 #[inline]
2336 pub unsafe fn to_kill_raw(this: *const Self) -> ::std::os::raw::c_uint {
2337 unsafe {
2338 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2339 ::std::ptr::addr_of!((*this)._bitfield_1),
2340 2usize,
2341 1u8,
2342 ) as u32)
2343 }
2344 }
2345 #[inline]
2346 pub unsafe fn set_to_kill_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2347 unsafe {
2348 let val: u32 = ::std::mem::transmute(val);
2349 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2350 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2351 2usize,
2352 1u8,
2353 val as u64,
2354 )
2355 }
2356 }
2357 #[inline]
2358 pub fn abort_on_exception(&self) -> ::std::os::raw::c_uint {
2359 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2360 }
2361 #[inline]
2362 pub fn set_abort_on_exception(&mut self, val: ::std::os::raw::c_uint) {
2363 unsafe {
2364 let val: u32 = ::std::mem::transmute(val);
2365 self._bitfield_1.set(3usize, 1u8, val as u64)
2366 }
2367 }
2368 #[inline]
2369 pub unsafe fn abort_on_exception_raw(this: *const Self) -> ::std::os::raw::c_uint {
2370 unsafe {
2371 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2372 ::std::ptr::addr_of!((*this)._bitfield_1),
2373 3usize,
2374 1u8,
2375 ) as u32)
2376 }
2377 }
2378 #[inline]
2379 pub unsafe fn set_abort_on_exception_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2380 unsafe {
2381 let val: u32 = ::std::mem::transmute(val);
2382 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2383 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2384 3usize,
2385 1u8,
2386 val as u64,
2387 )
2388 }
2389 }
2390 #[inline]
2391 pub fn report_on_exception(&self) -> ::std::os::raw::c_uint {
2392 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2393 }
2394 #[inline]
2395 pub fn set_report_on_exception(&mut self, val: ::std::os::raw::c_uint) {
2396 unsafe {
2397 let val: u32 = ::std::mem::transmute(val);
2398 self._bitfield_1.set(4usize, 1u8, val as u64)
2399 }
2400 }
2401 #[inline]
2402 pub unsafe fn report_on_exception_raw(this: *const Self) -> ::std::os::raw::c_uint {
2403 unsafe {
2404 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2405 ::std::ptr::addr_of!((*this)._bitfield_1),
2406 4usize,
2407 1u8,
2408 ) as u32)
2409 }
2410 }
2411 #[inline]
2412 pub unsafe fn set_report_on_exception_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2413 unsafe {
2414 let val: u32 = ::std::mem::transmute(val);
2415 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2416 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2417 4usize,
2418 1u8,
2419 val as u64,
2420 )
2421 }
2422 }
2423 #[inline]
2424 pub fn pending_interrupt_queue_checked(&self) -> ::std::os::raw::c_uint {
2425 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2426 }
2427 #[inline]
2428 pub fn set_pending_interrupt_queue_checked(&mut self, val: ::std::os::raw::c_uint) {
2429 unsafe {
2430 let val: u32 = ::std::mem::transmute(val);
2431 self._bitfield_1.set(5usize, 1u8, val as u64)
2432 }
2433 }
2434 #[inline]
2435 pub unsafe fn pending_interrupt_queue_checked_raw(this: *const Self) -> ::std::os::raw::c_uint {
2436 unsafe {
2437 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 1usize]>>::raw_get(
2438 ::std::ptr::addr_of!((*this)._bitfield_1),
2439 5usize,
2440 1u8,
2441 ) as u32)
2442 }
2443 }
2444 #[inline]
2445 pub unsafe fn set_pending_interrupt_queue_checked_raw(
2446 this: *mut Self,
2447 val: ::std::os::raw::c_uint,
2448 ) {
2449 unsafe {
2450 let val: u32 = ::std::mem::transmute(val);
2451 <__BindgenBitfieldUnit<[u8; 1usize]>>::raw_set(
2452 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2453 5usize,
2454 1u8,
2455 val as u64,
2456 )
2457 }
2458 }
2459 #[inline]
2460 pub fn new_bitfield_1(
2461 status: rb_thread_status,
2462 to_kill: ::std::os::raw::c_uint,
2463 abort_on_exception: ::std::os::raw::c_uint,
2464 report_on_exception: ::std::os::raw::c_uint,
2465 pending_interrupt_queue_checked: ::std::os::raw::c_uint,
2466 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2467 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2468 __bindgen_bitfield_unit.set(0usize, 2u8, {
2469 let status: u32 = unsafe { ::std::mem::transmute(status) };
2470 status as u64
2471 });
2472 __bindgen_bitfield_unit.set(2usize, 1u8, {
2473 let to_kill: u32 = unsafe { ::std::mem::transmute(to_kill) };
2474 to_kill as u64
2475 });
2476 __bindgen_bitfield_unit.set(3usize, 1u8, {
2477 let abort_on_exception: u32 = unsafe { ::std::mem::transmute(abort_on_exception) };
2478 abort_on_exception as u64
2479 });
2480 __bindgen_bitfield_unit.set(4usize, 1u8, {
2481 let report_on_exception: u32 = unsafe { ::std::mem::transmute(report_on_exception) };
2482 report_on_exception as u64
2483 });
2484 __bindgen_bitfield_unit.set(5usize, 1u8, {
2485 let pending_interrupt_queue_checked: u32 =
2486 unsafe { ::std::mem::transmute(pending_interrupt_queue_checked) };
2487 pending_interrupt_queue_checked as u64
2488 });
2489 __bindgen_bitfield_unit
2490 }
2491}
2492pub type rb_thread_t = rb_thread_struct;
2493#[repr(C)]
2494#[derive(Debug, Copy, Clone)]
2495pub struct rb_trace_arg_struct {
2496 pub event: rb_event_flag_t,
2497 pub ec: *mut rb_execution_context_t,
2498 pub cfp: *const rb_control_frame_t,
2499 pub self_: VALUE,
2500 pub id: ID,
2501 pub called_id: ID,
2502 pub klass: VALUE,
2503 pub data: VALUE,
2504 pub klass_solved: ::std::os::raw::c_int,
2505 pub lineno: ::std::os::raw::c_int,
2506 pub path: VALUE,
2507}
2508#[repr(C)]
2509#[derive(Debug, Copy, Clone)]
2510pub struct iseq_compile_data {
2511 pub err_info: VALUE,
2512 pub catch_table_ary: VALUE,
2513 pub start_label: *mut iseq_label_data,
2514 pub end_label: *mut iseq_label_data,
2515 pub redo_label: *mut iseq_label_data,
2516 pub current_block: *const rb_iseq_t,
2517 pub ensure_node_stack: *mut iseq_compile_data_ensure_node_stack,
2518 pub node: iseq_compile_data__bindgen_ty_1,
2519 pub insn: iseq_compile_data__bindgen_ty_2,
2520 pub loopval_popped: ::std::os::raw::c_int,
2521 pub last_line: ::std::os::raw::c_int,
2522 pub label_no: ::std::os::raw::c_int,
2523 pub node_level: ::std::os::raw::c_int,
2524 pub ci_index: ::std::os::raw::c_uint,
2525 pub ci_kw_index: ::std::os::raw::c_uint,
2526 pub option: *const rb_compile_option_t,
2527 pub ivar_cache_table: *mut rb_id_table,
2528 pub builtin_function_table: *const rb_builtin_function,
2529}
2530#[repr(C)]
2531#[derive(Debug, Copy, Clone)]
2532pub struct iseq_compile_data__bindgen_ty_1 {
2533 pub storage_head: *mut iseq_compile_data_storage,
2534 pub storage_current: *mut iseq_compile_data_storage,
2535}
2536#[repr(C)]
2537#[derive(Debug, Copy, Clone)]
2538pub struct iseq_compile_data__bindgen_ty_2 {
2539 pub storage_head: *mut iseq_compile_data_storage,
2540 pub storage_current: *mut iseq_compile_data_storage,
2541}
2542#[repr(C)]
2543#[derive(Debug, Copy, Clone)]
2544pub struct rb_compile_option_struct {
2545 pub _bitfield_align_1: [u8; 0],
2546 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
2547 pub debug_level: ::std::os::raw::c_int,
2548}
2549impl rb_compile_option_struct {
2550 #[inline]
2551 pub fn inline_const_cache(&self) -> ::std::os::raw::c_uint {
2552 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2553 }
2554 #[inline]
2555 pub fn set_inline_const_cache(&mut self, val: ::std::os::raw::c_uint) {
2556 unsafe {
2557 let val: u32 = ::std::mem::transmute(val);
2558 self._bitfield_1.set(0usize, 1u8, val as u64)
2559 }
2560 }
2561 #[inline]
2562 pub unsafe fn inline_const_cache_raw(this: *const Self) -> ::std::os::raw::c_uint {
2563 unsafe {
2564 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2565 ::std::ptr::addr_of!((*this)._bitfield_1),
2566 0usize,
2567 1u8,
2568 ) as u32)
2569 }
2570 }
2571 #[inline]
2572 pub unsafe fn set_inline_const_cache_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2573 unsafe {
2574 let val: u32 = ::std::mem::transmute(val);
2575 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2576 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2577 0usize,
2578 1u8,
2579 val as u64,
2580 )
2581 }
2582 }
2583 #[inline]
2584 pub fn peephole_optimization(&self) -> ::std::os::raw::c_uint {
2585 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2586 }
2587 #[inline]
2588 pub fn set_peephole_optimization(&mut self, val: ::std::os::raw::c_uint) {
2589 unsafe {
2590 let val: u32 = ::std::mem::transmute(val);
2591 self._bitfield_1.set(1usize, 1u8, val as u64)
2592 }
2593 }
2594 #[inline]
2595 pub unsafe fn peephole_optimization_raw(this: *const Self) -> ::std::os::raw::c_uint {
2596 unsafe {
2597 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2598 ::std::ptr::addr_of!((*this)._bitfield_1),
2599 1usize,
2600 1u8,
2601 ) as u32)
2602 }
2603 }
2604 #[inline]
2605 pub unsafe fn set_peephole_optimization_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2606 unsafe {
2607 let val: u32 = ::std::mem::transmute(val);
2608 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2609 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2610 1usize,
2611 1u8,
2612 val as u64,
2613 )
2614 }
2615 }
2616 #[inline]
2617 pub fn tailcall_optimization(&self) -> ::std::os::raw::c_uint {
2618 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2619 }
2620 #[inline]
2621 pub fn set_tailcall_optimization(&mut self, val: ::std::os::raw::c_uint) {
2622 unsafe {
2623 let val: u32 = ::std::mem::transmute(val);
2624 self._bitfield_1.set(2usize, 1u8, val as u64)
2625 }
2626 }
2627 #[inline]
2628 pub unsafe fn tailcall_optimization_raw(this: *const Self) -> ::std::os::raw::c_uint {
2629 unsafe {
2630 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2631 ::std::ptr::addr_of!((*this)._bitfield_1),
2632 2usize,
2633 1u8,
2634 ) as u32)
2635 }
2636 }
2637 #[inline]
2638 pub unsafe fn set_tailcall_optimization_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2639 unsafe {
2640 let val: u32 = ::std::mem::transmute(val);
2641 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2642 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2643 2usize,
2644 1u8,
2645 val as u64,
2646 )
2647 }
2648 }
2649 #[inline]
2650 pub fn specialized_instruction(&self) -> ::std::os::raw::c_uint {
2651 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2652 }
2653 #[inline]
2654 pub fn set_specialized_instruction(&mut self, val: ::std::os::raw::c_uint) {
2655 unsafe {
2656 let val: u32 = ::std::mem::transmute(val);
2657 self._bitfield_1.set(3usize, 1u8, val as u64)
2658 }
2659 }
2660 #[inline]
2661 pub unsafe fn specialized_instruction_raw(this: *const Self) -> ::std::os::raw::c_uint {
2662 unsafe {
2663 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2664 ::std::ptr::addr_of!((*this)._bitfield_1),
2665 3usize,
2666 1u8,
2667 ) as u32)
2668 }
2669 }
2670 #[inline]
2671 pub unsafe fn set_specialized_instruction_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2672 unsafe {
2673 let val: u32 = ::std::mem::transmute(val);
2674 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2675 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2676 3usize,
2677 1u8,
2678 val as u64,
2679 )
2680 }
2681 }
2682 #[inline]
2683 pub fn operands_unification(&self) -> ::std::os::raw::c_uint {
2684 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2685 }
2686 #[inline]
2687 pub fn set_operands_unification(&mut self, val: ::std::os::raw::c_uint) {
2688 unsafe {
2689 let val: u32 = ::std::mem::transmute(val);
2690 self._bitfield_1.set(4usize, 1u8, val as u64)
2691 }
2692 }
2693 #[inline]
2694 pub unsafe fn operands_unification_raw(this: *const Self) -> ::std::os::raw::c_uint {
2695 unsafe {
2696 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2697 ::std::ptr::addr_of!((*this)._bitfield_1),
2698 4usize,
2699 1u8,
2700 ) as u32)
2701 }
2702 }
2703 #[inline]
2704 pub unsafe fn set_operands_unification_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2705 unsafe {
2706 let val: u32 = ::std::mem::transmute(val);
2707 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2708 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2709 4usize,
2710 1u8,
2711 val as u64,
2712 )
2713 }
2714 }
2715 #[inline]
2716 pub fn instructions_unification(&self) -> ::std::os::raw::c_uint {
2717 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2718 }
2719 #[inline]
2720 pub fn set_instructions_unification(&mut self, val: ::std::os::raw::c_uint) {
2721 unsafe {
2722 let val: u32 = ::std::mem::transmute(val);
2723 self._bitfield_1.set(5usize, 1u8, val as u64)
2724 }
2725 }
2726 #[inline]
2727 pub unsafe fn instructions_unification_raw(this: *const Self) -> ::std::os::raw::c_uint {
2728 unsafe {
2729 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2730 ::std::ptr::addr_of!((*this)._bitfield_1),
2731 5usize,
2732 1u8,
2733 ) as u32)
2734 }
2735 }
2736 #[inline]
2737 pub unsafe fn set_instructions_unification_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2738 unsafe {
2739 let val: u32 = ::std::mem::transmute(val);
2740 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2741 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2742 5usize,
2743 1u8,
2744 val as u64,
2745 )
2746 }
2747 }
2748 #[inline]
2749 pub fn stack_caching(&self) -> ::std::os::raw::c_uint {
2750 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
2751 }
2752 #[inline]
2753 pub fn set_stack_caching(&mut self, val: ::std::os::raw::c_uint) {
2754 unsafe {
2755 let val: u32 = ::std::mem::transmute(val);
2756 self._bitfield_1.set(6usize, 1u8, val as u64)
2757 }
2758 }
2759 #[inline]
2760 pub unsafe fn stack_caching_raw(this: *const Self) -> ::std::os::raw::c_uint {
2761 unsafe {
2762 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2763 ::std::ptr::addr_of!((*this)._bitfield_1),
2764 6usize,
2765 1u8,
2766 ) as u32)
2767 }
2768 }
2769 #[inline]
2770 pub unsafe fn set_stack_caching_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2771 unsafe {
2772 let val: u32 = ::std::mem::transmute(val);
2773 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2774 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2775 6usize,
2776 1u8,
2777 val as u64,
2778 )
2779 }
2780 }
2781 #[inline]
2782 pub fn frozen_string_literal(&self) -> ::std::os::raw::c_uint {
2783 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
2784 }
2785 #[inline]
2786 pub fn set_frozen_string_literal(&mut self, val: ::std::os::raw::c_uint) {
2787 unsafe {
2788 let val: u32 = ::std::mem::transmute(val);
2789 self._bitfield_1.set(7usize, 1u8, val as u64)
2790 }
2791 }
2792 #[inline]
2793 pub unsafe fn frozen_string_literal_raw(this: *const Self) -> ::std::os::raw::c_uint {
2794 unsafe {
2795 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2796 ::std::ptr::addr_of!((*this)._bitfield_1),
2797 7usize,
2798 1u8,
2799 ) as u32)
2800 }
2801 }
2802 #[inline]
2803 pub unsafe fn set_frozen_string_literal_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2804 unsafe {
2805 let val: u32 = ::std::mem::transmute(val);
2806 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2807 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2808 7usize,
2809 1u8,
2810 val as u64,
2811 )
2812 }
2813 }
2814 #[inline]
2815 pub fn debug_frozen_string_literal(&self) -> ::std::os::raw::c_uint {
2816 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
2817 }
2818 #[inline]
2819 pub fn set_debug_frozen_string_literal(&mut self, val: ::std::os::raw::c_uint) {
2820 unsafe {
2821 let val: u32 = ::std::mem::transmute(val);
2822 self._bitfield_1.set(8usize, 1u8, val as u64)
2823 }
2824 }
2825 #[inline]
2826 pub unsafe fn debug_frozen_string_literal_raw(this: *const Self) -> ::std::os::raw::c_uint {
2827 unsafe {
2828 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2829 ::std::ptr::addr_of!((*this)._bitfield_1),
2830 8usize,
2831 1u8,
2832 ) as u32)
2833 }
2834 }
2835 #[inline]
2836 pub unsafe fn set_debug_frozen_string_literal_raw(
2837 this: *mut Self,
2838 val: ::std::os::raw::c_uint,
2839 ) {
2840 unsafe {
2841 let val: u32 = ::std::mem::transmute(val);
2842 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2843 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2844 8usize,
2845 1u8,
2846 val as u64,
2847 )
2848 }
2849 }
2850 #[inline]
2851 pub fn coverage_enabled(&self) -> ::std::os::raw::c_uint {
2852 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
2853 }
2854 #[inline]
2855 pub fn set_coverage_enabled(&mut self, val: ::std::os::raw::c_uint) {
2856 unsafe {
2857 let val: u32 = ::std::mem::transmute(val);
2858 self._bitfield_1.set(9usize, 1u8, val as u64)
2859 }
2860 }
2861 #[inline]
2862 pub unsafe fn coverage_enabled_raw(this: *const Self) -> ::std::os::raw::c_uint {
2863 unsafe {
2864 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
2865 ::std::ptr::addr_of!((*this)._bitfield_1),
2866 9usize,
2867 1u8,
2868 ) as u32)
2869 }
2870 }
2871 #[inline]
2872 pub unsafe fn set_coverage_enabled_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
2873 unsafe {
2874 let val: u32 = ::std::mem::transmute(val);
2875 <__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
2876 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
2877 9usize,
2878 1u8,
2879 val as u64,
2880 )
2881 }
2882 }
2883 #[inline]
2884 pub fn new_bitfield_1(
2885 inline_const_cache: ::std::os::raw::c_uint,
2886 peephole_optimization: ::std::os::raw::c_uint,
2887 tailcall_optimization: ::std::os::raw::c_uint,
2888 specialized_instruction: ::std::os::raw::c_uint,
2889 operands_unification: ::std::os::raw::c_uint,
2890 instructions_unification: ::std::os::raw::c_uint,
2891 stack_caching: ::std::os::raw::c_uint,
2892 frozen_string_literal: ::std::os::raw::c_uint,
2893 debug_frozen_string_literal: ::std::os::raw::c_uint,
2894 coverage_enabled: ::std::os::raw::c_uint,
2895 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
2896 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
2897 __bindgen_bitfield_unit.set(0usize, 1u8, {
2898 let inline_const_cache: u32 = unsafe { ::std::mem::transmute(inline_const_cache) };
2899 inline_const_cache as u64
2900 });
2901 __bindgen_bitfield_unit.set(1usize, 1u8, {
2902 let peephole_optimization: u32 =
2903 unsafe { ::std::mem::transmute(peephole_optimization) };
2904 peephole_optimization as u64
2905 });
2906 __bindgen_bitfield_unit.set(2usize, 1u8, {
2907 let tailcall_optimization: u32 =
2908 unsafe { ::std::mem::transmute(tailcall_optimization) };
2909 tailcall_optimization as u64
2910 });
2911 __bindgen_bitfield_unit.set(3usize, 1u8, {
2912 let specialized_instruction: u32 =
2913 unsafe { ::std::mem::transmute(specialized_instruction) };
2914 specialized_instruction as u64
2915 });
2916 __bindgen_bitfield_unit.set(4usize, 1u8, {
2917 let operands_unification: u32 = unsafe { ::std::mem::transmute(operands_unification) };
2918 operands_unification as u64
2919 });
2920 __bindgen_bitfield_unit.set(5usize, 1u8, {
2921 let instructions_unification: u32 =
2922 unsafe { ::std::mem::transmute(instructions_unification) };
2923 instructions_unification as u64
2924 });
2925 __bindgen_bitfield_unit.set(6usize, 1u8, {
2926 let stack_caching: u32 = unsafe { ::std::mem::transmute(stack_caching) };
2927 stack_caching as u64
2928 });
2929 __bindgen_bitfield_unit.set(7usize, 1u8, {
2930 let frozen_string_literal: u32 =
2931 unsafe { ::std::mem::transmute(frozen_string_literal) };
2932 frozen_string_literal as u64
2933 });
2934 __bindgen_bitfield_unit.set(8usize, 1u8, {
2935 let debug_frozen_string_literal: u32 =
2936 unsafe { ::std::mem::transmute(debug_frozen_string_literal) };
2937 debug_frozen_string_literal as u64
2938 });
2939 __bindgen_bitfield_unit.set(9usize, 1u8, {
2940 let coverage_enabled: u32 = unsafe { ::std::mem::transmute(coverage_enabled) };
2941 coverage_enabled as u64
2942 });
2943 __bindgen_bitfield_unit
2944 }
2945}
2946#[repr(C)]
2947#[derive(Debug, Copy, Clone)]
2948pub struct iseq_insn_info_entry {
2949 pub line_no: ::std::os::raw::c_int,
2950 pub events: rb_event_flag_t,
2951}
2952#[repr(C)]
2953#[derive(Debug, Copy, Clone)]
2954pub struct iseq_catch_table_entry {
2955 pub type_: iseq_catch_table_entry_catch_type,
2956 pub iseq: *mut rb_iseq_t,
2957 pub start: ::std::os::raw::c_uint,
2958 pub end: ::std::os::raw::c_uint,
2959 pub cont: ::std::os::raw::c_uint,
2960 pub sp: ::std::os::raw::c_uint,
2961}
2962pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_RESCUE: iseq_catch_table_entry_catch_type =
2963 3;
2964pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_ENSURE: iseq_catch_table_entry_catch_type =
2965 5;
2966pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_RETRY: iseq_catch_table_entry_catch_type = 7;
2967pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_BREAK: iseq_catch_table_entry_catch_type = 9;
2968pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_REDO: iseq_catch_table_entry_catch_type = 11;
2969pub const iseq_catch_table_entry_catch_type_CATCH_TYPE_NEXT: iseq_catch_table_entry_catch_type = 13;
2970pub type iseq_catch_table_entry_catch_type = ::std::os::raw::c_uint;
2971#[repr(C, packed)]
2972pub struct iseq_catch_table {
2973 pub size: ::std::os::raw::c_uint,
2974 pub entries: __IncompleteArrayField<iseq_catch_table_entry>,
2975}
2976#[repr(C)]
2977#[derive(Debug)]
2978pub struct iseq_compile_data_storage {
2979 pub next: *mut iseq_compile_data_storage,
2980 pub pos: ::std::os::raw::c_uint,
2981 pub size: ::std::os::raw::c_uint,
2982 pub buff: __IncompleteArrayField<::std::os::raw::c_char>,
2983}
2984#[repr(C)]
2985#[derive(Debug, Copy, Clone)]
2986pub struct rb_id_table {
2987 pub _address: u8,
2988}
2989#[repr(C)]
2990#[derive(Debug, Copy, Clone)]
2991pub struct succ_index_table {
2992 pub _address: u8,
2993}
2994#[repr(C)]
2995#[derive(Debug, Copy, Clone)]
2996pub struct rb_event_hook_struct {
2997 pub _address: u8,
2998}
2999#[repr(C)]
3000#[derive(Debug, Copy, Clone)]
3001pub struct rb_postponed_job_struct {
3002 pub _address: u8,
3003}
3004#[repr(C)]
3005#[derive(Debug, Copy, Clone)]
3006pub struct iseq_label_data {
3007 pub _address: u8,
3008}
3009#[repr(C)]
3010#[derive(Debug, Copy, Clone)]
3011pub struct iseq_compile_data_ensure_node_stack {
3012 pub _address: u8,
3013}