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