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