1#![allow(
2 non_snake_case,
3 non_camel_case_types,
4 non_upper_case_globals,
5 deref_nullptr,
6 improper_ctypes
7)]
8
9#[repr(C)]
10#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
11pub struct __BindgenBitfieldUnit<Storage> {
12 storage: Storage,
13}
14impl<Storage> __BindgenBitfieldUnit<Storage> {
15 #[inline]
16 pub const fn new(storage: Storage) -> Self {
17 Self { storage }
18 }
19}
20impl<Storage> __BindgenBitfieldUnit<Storage>
21where
22 Storage: AsRef<[u8]> + AsMut<[u8]>,
23{
24 #[inline]
25 pub fn get_bit(&self, index: usize) -> bool {
26 debug_assert!(index / 8 < self.storage.as_ref().len());
27 let byte_index = index / 8;
28 let byte = self.storage.as_ref()[byte_index];
29 let bit_index = if cfg!(target_endian = "big") {
30 7 - (index % 8)
31 } else {
32 index % 8
33 };
34 let mask = 1 << bit_index;
35 byte & mask == mask
36 }
37 #[inline]
38 pub fn set_bit(&mut self, index: usize, val: bool) {
39 debug_assert!(index / 8 < self.storage.as_ref().len());
40 let byte_index = index / 8;
41 let byte = &mut self.storage.as_mut()[byte_index];
42 let bit_index = if cfg!(target_endian = "big") {
43 7 - (index % 8)
44 } else {
45 index % 8
46 };
47 let mask = 1 << bit_index;
48 if val {
49 *byte |= mask;
50 } else {
51 *byte &= !mask;
52 }
53 }
54 #[inline]
55 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
56 debug_assert!(bit_width <= 64);
57 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
58 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
59 let mut val = 0;
60 for i in 0..(bit_width as usize) {
61 if self.get_bit(i + bit_offset) {
62 let index = if cfg!(target_endian = "big") {
63 bit_width as usize - 1 - i
64 } else {
65 i
66 };
67 val |= 1 << index;
68 }
69 }
70 val
71 }
72 #[inline]
73 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
74 debug_assert!(bit_width <= 64);
75 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
76 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
77 for i in 0..(bit_width as usize) {
78 let mask = 1 << i;
79 let val_bit_is_set = val & mask == mask;
80 let index = if cfg!(target_endian = "big") {
81 bit_width as usize - 1 - i
82 } else {
83 i
84 };
85 self.set_bit(index + bit_offset, val_bit_is_set);
86 }
87 }
88}
89#[repr(C)]
90#[derive(Default)]
91pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
92impl<T> __IncompleteArrayField<T> {
93 #[inline]
94 pub const fn new() -> Self {
95 __IncompleteArrayField(::std::marker::PhantomData, [])
96 }
97 #[inline]
98 pub fn as_ptr(&self) -> *const T {
99 self as *const _ as *const T
100 }
101 #[inline]
102 pub fn as_mut_ptr(&mut self) -> *mut T {
103 self as *mut _ as *mut T
104 }
105 #[inline]
106 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
107 ::std::slice::from_raw_parts(self.as_ptr(), len)
108 }
109 #[inline]
110 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
111 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
112 }
113}
114impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
115 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
116 fmt.write_str("__IncompleteArrayField")
117 }
118}
119pub const _STDINT_H: u32 = 1;
120pub const _FEATURES_H: u32 = 1;
121pub const _DEFAULT_SOURCE: u32 = 1;
122pub const __GLIBC_USE_ISOC2X: u32 = 0;
123pub const __USE_ISOC11: u32 = 1;
124pub const __USE_ISOC99: u32 = 1;
125pub const __USE_ISOC95: u32 = 1;
126pub const __USE_POSIX_IMPLICITLY: u32 = 1;
127pub const _POSIX_SOURCE: u32 = 1;
128pub const _POSIX_C_SOURCE: u32 = 200809;
129pub const __USE_POSIX: u32 = 1;
130pub const __USE_POSIX2: u32 = 1;
131pub const __USE_POSIX199309: u32 = 1;
132pub const __USE_POSIX199506: u32 = 1;
133pub const __USE_XOPEN2K: u32 = 1;
134pub const __USE_XOPEN2K8: u32 = 1;
135pub const _ATFILE_SOURCE: u32 = 1;
136pub const __WORDSIZE: u32 = 64;
137pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
138pub const __SYSCALL_WORDSIZE: u32 = 64;
139pub const __TIMESIZE: u32 = 64;
140pub const __USE_MISC: u32 = 1;
141pub const __USE_ATFILE: u32 = 1;
142pub const __USE_FORTIFY_LEVEL: u32 = 0;
143pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
144pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
145pub const _STDC_PREDEF_H: u32 = 1;
146pub const __STDC_IEC_559__: u32 = 1;
147pub const __STDC_IEC_60559_BFP__: u32 = 201404;
148pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
149pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
150pub const __STDC_ISO_10646__: u32 = 201706;
151pub const __GNU_LIBRARY__: u32 = 6;
152pub const __GLIBC__: u32 = 2;
153pub const __GLIBC_MINOR__: u32 = 36;
154pub const _SYS_CDEFS_H: u32 = 1;
155pub const __glibc_c99_flexarr_available: u32 = 1;
156pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
157pub const __HAVE_GENERIC_SELECTION: u32 = 1;
158pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
159pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
160pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
161pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
162pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
163pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
164pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
165pub const _BITS_TYPES_H: u32 = 1;
166pub const _BITS_TYPESIZES_H: u32 = 1;
167pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
168pub const __INO_T_MATCHES_INO64_T: u32 = 1;
169pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
170pub const __STATFS_MATCHES_STATFS64: u32 = 1;
171pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
172pub const __FD_SETSIZE: u32 = 1024;
173pub const _BITS_TIME64_H: u32 = 1;
174pub const _BITS_WCHAR_H: u32 = 1;
175pub const _BITS_STDINT_INTN_H: u32 = 1;
176pub const _BITS_STDINT_UINTN_H: u32 = 1;
177pub const INT8_MIN: i32 = -128;
178pub const INT16_MIN: i32 = -32768;
179pub const INT32_MIN: i32 = -2147483648;
180pub const INT8_MAX: u32 = 127;
181pub const INT16_MAX: u32 = 32767;
182pub const INT32_MAX: u32 = 2147483647;
183pub const UINT8_MAX: u32 = 255;
184pub const UINT16_MAX: u32 = 65535;
185pub const UINT32_MAX: u32 = 4294967295;
186pub const INT_LEAST8_MIN: i32 = -128;
187pub const INT_LEAST16_MIN: i32 = -32768;
188pub const INT_LEAST32_MIN: i32 = -2147483648;
189pub const INT_LEAST8_MAX: u32 = 127;
190pub const INT_LEAST16_MAX: u32 = 32767;
191pub const INT_LEAST32_MAX: u32 = 2147483647;
192pub const UINT_LEAST8_MAX: u32 = 255;
193pub const UINT_LEAST16_MAX: u32 = 65535;
194pub const UINT_LEAST32_MAX: u32 = 4294967295;
195pub const INT_FAST8_MIN: i32 = -128;
196pub const INT_FAST16_MIN: i64 = -9223372036854775808;
197pub const INT_FAST32_MIN: i64 = -9223372036854775808;
198pub const INT_FAST8_MAX: u32 = 127;
199pub const INT_FAST16_MAX: u64 = 9223372036854775807;
200pub const INT_FAST32_MAX: u64 = 9223372036854775807;
201pub const UINT_FAST8_MAX: u32 = 255;
202pub const UINT_FAST16_MAX: i32 = -1;
203pub const UINT_FAST32_MAX: i32 = -1;
204pub const INTPTR_MIN: i64 = -9223372036854775808;
205pub const INTPTR_MAX: u64 = 9223372036854775807;
206pub const UINTPTR_MAX: i32 = -1;
207pub const PTRDIFF_MIN: i64 = -9223372036854775808;
208pub const PTRDIFF_MAX: u64 = 9223372036854775807;
209pub const SIG_ATOMIC_MIN: i32 = -2147483648;
210pub const SIG_ATOMIC_MAX: u32 = 2147483647;
211pub const SIZE_MAX: i32 = -1;
212pub const WINT_MIN: u32 = 0;
213pub const WINT_MAX: u32 = 4294967295;
214pub const _STDLIB_H: u32 = 1;
215pub const WNOHANG: u32 = 1;
216pub const WUNTRACED: u32 = 2;
217pub const WSTOPPED: u32 = 2;
218pub const WEXITED: u32 = 4;
219pub const WCONTINUED: u32 = 8;
220pub const WNOWAIT: u32 = 16777216;
221pub const __WNOTHREAD: u32 = 536870912;
222pub const __WALL: u32 = 1073741824;
223pub const __WCLONE: u32 = 2147483648;
224pub const __W_CONTINUED: u32 = 65535;
225pub const __WCOREFLAG: u32 = 128;
226pub const __HAVE_FLOAT128: u32 = 0;
227pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
228pub const __HAVE_FLOAT64X: u32 = 1;
229pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
230pub const __HAVE_FLOAT16: u32 = 0;
231pub const __HAVE_FLOAT32: u32 = 1;
232pub const __HAVE_FLOAT64: u32 = 1;
233pub const __HAVE_FLOAT32X: u32 = 1;
234pub const __HAVE_FLOAT128X: u32 = 0;
235pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
236pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
237pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
238pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
239pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
240pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
241pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
242pub const __ldiv_t_defined: u32 = 1;
243pub const __lldiv_t_defined: u32 = 1;
244pub const RAND_MAX: u32 = 2147483647;
245pub const EXIT_FAILURE: u32 = 1;
246pub const EXIT_SUCCESS: u32 = 0;
247pub const _SYS_TYPES_H: u32 = 1;
248pub const __clock_t_defined: u32 = 1;
249pub const __clockid_t_defined: u32 = 1;
250pub const __time_t_defined: u32 = 1;
251pub const __timer_t_defined: u32 = 1;
252pub const __BIT_TYPES_DEFINED__: u32 = 1;
253pub const _ENDIAN_H: u32 = 1;
254pub const _BITS_ENDIAN_H: u32 = 1;
255pub const __LITTLE_ENDIAN: u32 = 1234;
256pub const __BIG_ENDIAN: u32 = 4321;
257pub const __PDP_ENDIAN: u32 = 3412;
258pub const _BITS_ENDIANNESS_H: u32 = 1;
259pub const __BYTE_ORDER: u32 = 1234;
260pub const __FLOAT_WORD_ORDER: u32 = 1234;
261pub const LITTLE_ENDIAN: u32 = 1234;
262pub const BIG_ENDIAN: u32 = 4321;
263pub const PDP_ENDIAN: u32 = 3412;
264pub const BYTE_ORDER: u32 = 1234;
265pub const _BITS_BYTESWAP_H: u32 = 1;
266pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
267pub const _SYS_SELECT_H: u32 = 1;
268pub const __sigset_t_defined: u32 = 1;
269pub const __timeval_defined: u32 = 1;
270pub const _STRUCT_TIMESPEC: u32 = 1;
271pub const FD_SETSIZE: u32 = 1024;
272pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
273pub const _THREAD_SHARED_TYPES_H: u32 = 1;
274pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
275pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
276pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
277pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
278pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
279pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
280pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
281pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
282pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
283pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
284pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
285pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
286pub const __have_pthread_attr_t: u32 = 1;
287pub const _ALLOCA_H: u32 = 1;
288pub const MONO_ALLOCATOR_VTABLE_VERSION: u32 = 1;
289pub const MONO_ZERO_LEN_ARRAY: u32 = 0;
290pub const _STDIO_H: u32 = 1;
291pub const __GNUC_VA_LIST: u32 = 1;
292pub const _____fpos_t_defined: u32 = 1;
293pub const ____mbstate_t_defined: u32 = 1;
294pub const _____fpos64_t_defined: u32 = 1;
295pub const ____FILE_defined: u32 = 1;
296pub const __FILE_defined: u32 = 1;
297pub const __struct_FILE_defined: u32 = 1;
298pub const _IO_EOF_SEEN: u32 = 16;
299pub const _IO_ERR_SEEN: u32 = 32;
300pub const _IO_USER_LOCK: u32 = 32768;
301pub const _IOFBF: u32 = 0;
302pub const _IOLBF: u32 = 1;
303pub const _IONBF: u32 = 2;
304pub const BUFSIZ: u32 = 8192;
305pub const EOF: i32 = -1;
306pub const SEEK_SET: u32 = 0;
307pub const SEEK_CUR: u32 = 1;
308pub const SEEK_END: u32 = 2;
309pub const P_tmpdir: &[u8; 5usize] = b"/tmp\0";
310pub const _BITS_STDIO_LIM_H: u32 = 1;
311pub const L_tmpnam: u32 = 20;
312pub const TMP_MAX: u32 = 238328;
313pub const FILENAME_MAX: u32 = 4096;
314pub const L_ctermid: u32 = 9;
315pub const FOPEN_MAX: u32 = 16;
316pub const _MONO_METADATA_LOADER_H_: u32 = 1;
317pub const MONO_DECLSEC_ACTION_MIN: u32 = 1;
318pub const MONO_DECLSEC_ACTION_MAX: u32 = 18;
319pub type __u_char = ::std::os::raw::c_uchar;
320pub type __u_short = ::std::os::raw::c_ushort;
321pub type __u_int = ::std::os::raw::c_uint;
322pub type __u_long = ::std::os::raw::c_ulong;
323pub type __int8_t = ::std::os::raw::c_schar;
324pub type __uint8_t = ::std::os::raw::c_uchar;
325pub type __int16_t = ::std::os::raw::c_short;
326pub type __uint16_t = ::std::os::raw::c_ushort;
327pub type __int32_t = ::std::os::raw::c_int;
328pub type __uint32_t = ::std::os::raw::c_uint;
329pub type __int64_t = ::std::os::raw::c_long;
330pub type __uint64_t = ::std::os::raw::c_ulong;
331pub type __int_least8_t = __int8_t;
332pub type __uint_least8_t = __uint8_t;
333pub type __int_least16_t = __int16_t;
334pub type __uint_least16_t = __uint16_t;
335pub type __int_least32_t = __int32_t;
336pub type __uint_least32_t = __uint32_t;
337pub type __int_least64_t = __int64_t;
338pub type __uint_least64_t = __uint64_t;
339pub type __quad_t = ::std::os::raw::c_long;
340pub type __u_quad_t = ::std::os::raw::c_ulong;
341pub type __intmax_t = ::std::os::raw::c_long;
342pub type __uintmax_t = ::std::os::raw::c_ulong;
343pub type __dev_t = ::std::os::raw::c_ulong;
344pub type __uid_t = ::std::os::raw::c_uint;
345pub type __gid_t = ::std::os::raw::c_uint;
346pub type __ino_t = ::std::os::raw::c_ulong;
347pub type __ino64_t = ::std::os::raw::c_ulong;
348pub type __mode_t = ::std::os::raw::c_uint;
349pub type __nlink_t = ::std::os::raw::c_ulong;
350pub type __off_t = ::std::os::raw::c_long;
351pub type __off64_t = ::std::os::raw::c_long;
352pub type __pid_t = ::std::os::raw::c_int;
353#[repr(C)]
354#[derive(Debug, Copy, Clone)]
355pub struct __fsid_t {
356 pub __val: [::std::os::raw::c_int; 2usize],
357}
358#[test]
359fn bindgen_test_layout___fsid_t() {
360 assert_eq!(
361 ::std::mem::size_of::<__fsid_t>(),
362 8usize,
363 concat!("Size of: ", stringify!(__fsid_t))
364 );
365 assert_eq!(
366 ::std::mem::align_of::<__fsid_t>(),
367 4usize,
368 concat!("Alignment of ", stringify!(__fsid_t))
369 );
370 fn test_field___val() {
371 assert_eq!(
372 unsafe {
373 let uninit = ::std::mem::MaybeUninit::<__fsid_t>::uninit();
374 let ptr = uninit.as_ptr();
375 ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize
376 },
377 0usize,
378 concat!(
379 "Offset of field: ",
380 stringify!(__fsid_t),
381 "::",
382 stringify!(__val)
383 )
384 );
385 }
386 test_field___val();
387}
388pub type __clock_t = ::std::os::raw::c_long;
389pub type __rlim_t = ::std::os::raw::c_ulong;
390pub type __rlim64_t = ::std::os::raw::c_ulong;
391pub type __id_t = ::std::os::raw::c_uint;
392pub type __time_t = ::std::os::raw::c_long;
393pub type __useconds_t = ::std::os::raw::c_uint;
394pub type __suseconds_t = ::std::os::raw::c_long;
395pub type __suseconds64_t = ::std::os::raw::c_long;
396pub type __daddr_t = ::std::os::raw::c_int;
397pub type __key_t = ::std::os::raw::c_int;
398pub type __clockid_t = ::std::os::raw::c_int;
399pub type __timer_t = *mut ::std::os::raw::c_void;
400pub type __blksize_t = ::std::os::raw::c_long;
401pub type __blkcnt_t = ::std::os::raw::c_long;
402pub type __blkcnt64_t = ::std::os::raw::c_long;
403pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
404pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
405pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
406pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
407pub type __fsword_t = ::std::os::raw::c_long;
408pub type __ssize_t = ::std::os::raw::c_long;
409pub type __syscall_slong_t = ::std::os::raw::c_long;
410pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
411pub type __loff_t = __off64_t;
412pub type __caddr_t = *mut ::std::os::raw::c_char;
413pub type __intptr_t = ::std::os::raw::c_long;
414pub type __socklen_t = ::std::os::raw::c_uint;
415pub type __sig_atomic_t = ::std::os::raw::c_int;
416pub type int_least8_t = __int_least8_t;
417pub type int_least16_t = __int_least16_t;
418pub type int_least32_t = __int_least32_t;
419pub type int_least64_t = __int_least64_t;
420pub type uint_least8_t = __uint_least8_t;
421pub type uint_least16_t = __uint_least16_t;
422pub type uint_least32_t = __uint_least32_t;
423pub type uint_least64_t = __uint_least64_t;
424pub type int_fast8_t = ::std::os::raw::c_schar;
425pub type int_fast16_t = ::std::os::raw::c_long;
426pub type int_fast32_t = ::std::os::raw::c_long;
427pub type int_fast64_t = ::std::os::raw::c_long;
428pub type uint_fast8_t = ::std::os::raw::c_uchar;
429pub type uint_fast16_t = ::std::os::raw::c_ulong;
430pub type uint_fast32_t = ::std::os::raw::c_ulong;
431pub type uint_fast64_t = ::std::os::raw::c_ulong;
432pub type intmax_t = __intmax_t;
433pub type uintmax_t = __uintmax_t;
434pub type size_t = ::std::os::raw::c_ulong;
435pub type wchar_t = ::std::os::raw::c_int;
436pub type _Float32 = f32;
437pub type _Float64 = f64;
438pub type _Float32x = f64;
439pub type _Float64x = u128;
440#[repr(C)]
441#[derive(Debug, Copy, Clone)]
442pub struct div_t {
443 pub quot: ::std::os::raw::c_int,
444 pub rem: ::std::os::raw::c_int,
445}
446#[test]
447fn bindgen_test_layout_div_t() {
448 assert_eq!(
449 ::std::mem::size_of::<div_t>(),
450 8usize,
451 concat!("Size of: ", stringify!(div_t))
452 );
453 assert_eq!(
454 ::std::mem::align_of::<div_t>(),
455 4usize,
456 concat!("Alignment of ", stringify!(div_t))
457 );
458 fn test_field_quot() {
459 assert_eq!(
460 unsafe {
461 let uninit = ::std::mem::MaybeUninit::<div_t>::uninit();
462 let ptr = uninit.as_ptr();
463 ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize
464 },
465 0usize,
466 concat!(
467 "Offset of field: ",
468 stringify!(div_t),
469 "::",
470 stringify!(quot)
471 )
472 );
473 }
474 test_field_quot();
475 fn test_field_rem() {
476 assert_eq!(
477 unsafe {
478 let uninit = ::std::mem::MaybeUninit::<div_t>::uninit();
479 let ptr = uninit.as_ptr();
480 ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize
481 },
482 4usize,
483 concat!(
484 "Offset of field: ",
485 stringify!(div_t),
486 "::",
487 stringify!(rem)
488 )
489 );
490 }
491 test_field_rem();
492}
493#[repr(C)]
494#[derive(Debug, Copy, Clone)]
495pub struct ldiv_t {
496 pub quot: ::std::os::raw::c_long,
497 pub rem: ::std::os::raw::c_long,
498}
499#[test]
500fn bindgen_test_layout_ldiv_t() {
501 assert_eq!(
502 ::std::mem::size_of::<ldiv_t>(),
503 16usize,
504 concat!("Size of: ", stringify!(ldiv_t))
505 );
506 assert_eq!(
507 ::std::mem::align_of::<ldiv_t>(),
508 8usize,
509 concat!("Alignment of ", stringify!(ldiv_t))
510 );
511 fn test_field_quot() {
512 assert_eq!(
513 unsafe {
514 let uninit = ::std::mem::MaybeUninit::<ldiv_t>::uninit();
515 let ptr = uninit.as_ptr();
516 ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize
517 },
518 0usize,
519 concat!(
520 "Offset of field: ",
521 stringify!(ldiv_t),
522 "::",
523 stringify!(quot)
524 )
525 );
526 }
527 test_field_quot();
528 fn test_field_rem() {
529 assert_eq!(
530 unsafe {
531 let uninit = ::std::mem::MaybeUninit::<ldiv_t>::uninit();
532 let ptr = uninit.as_ptr();
533 ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize
534 },
535 8usize,
536 concat!(
537 "Offset of field: ",
538 stringify!(ldiv_t),
539 "::",
540 stringify!(rem)
541 )
542 );
543 }
544 test_field_rem();
545}
546#[repr(C)]
547#[derive(Debug, Copy, Clone)]
548pub struct lldiv_t {
549 pub quot: ::std::os::raw::c_longlong,
550 pub rem: ::std::os::raw::c_longlong,
551}
552#[test]
553fn bindgen_test_layout_lldiv_t() {
554 assert_eq!(
555 ::std::mem::size_of::<lldiv_t>(),
556 16usize,
557 concat!("Size of: ", stringify!(lldiv_t))
558 );
559 assert_eq!(
560 ::std::mem::align_of::<lldiv_t>(),
561 8usize,
562 concat!("Alignment of ", stringify!(lldiv_t))
563 );
564 fn test_field_quot() {
565 assert_eq!(
566 unsafe {
567 let uninit = ::std::mem::MaybeUninit::<lldiv_t>::uninit();
568 let ptr = uninit.as_ptr();
569 ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize
570 },
571 0usize,
572 concat!(
573 "Offset of field: ",
574 stringify!(lldiv_t),
575 "::",
576 stringify!(quot)
577 )
578 );
579 }
580 test_field_quot();
581 fn test_field_rem() {
582 assert_eq!(
583 unsafe {
584 let uninit = ::std::mem::MaybeUninit::<lldiv_t>::uninit();
585 let ptr = uninit.as_ptr();
586 ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize
587 },
588 8usize,
589 concat!(
590 "Offset of field: ",
591 stringify!(lldiv_t),
592 "::",
593 stringify!(rem)
594 )
595 );
596 }
597 test_field_rem();
598}
599extern "C" {
600 pub fn __ctype_get_mb_cur_max() -> size_t;
601}
602extern "C" {
603 pub fn atof(__nptr: *const ::std::os::raw::c_char) -> f64;
604}
605extern "C" {
606 pub fn atoi(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
607}
608extern "C" {
609 pub fn atol(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
610}
611extern "C" {
612 pub fn atoll(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
613}
614extern "C" {
615 pub fn strtod(
616 __nptr: *const ::std::os::raw::c_char,
617 __endptr: *mut *mut ::std::os::raw::c_char,
618 ) -> f64;
619}
620extern "C" {
621 pub fn strtof(
622 __nptr: *const ::std::os::raw::c_char,
623 __endptr: *mut *mut ::std::os::raw::c_char,
624 ) -> f32;
625}
626extern "C" {
627 pub fn strtold(
628 __nptr: *const ::std::os::raw::c_char,
629 __endptr: *mut *mut ::std::os::raw::c_char,
630 ) -> u128;
631}
632extern "C" {
633 pub fn strtol(
634 __nptr: *const ::std::os::raw::c_char,
635 __endptr: *mut *mut ::std::os::raw::c_char,
636 __base: ::std::os::raw::c_int,
637 ) -> ::std::os::raw::c_long;
638}
639extern "C" {
640 pub fn strtoul(
641 __nptr: *const ::std::os::raw::c_char,
642 __endptr: *mut *mut ::std::os::raw::c_char,
643 __base: ::std::os::raw::c_int,
644 ) -> ::std::os::raw::c_ulong;
645}
646extern "C" {
647 pub fn strtoq(
648 __nptr: *const ::std::os::raw::c_char,
649 __endptr: *mut *mut ::std::os::raw::c_char,
650 __base: ::std::os::raw::c_int,
651 ) -> ::std::os::raw::c_longlong;
652}
653extern "C" {
654 pub fn strtouq(
655 __nptr: *const ::std::os::raw::c_char,
656 __endptr: *mut *mut ::std::os::raw::c_char,
657 __base: ::std::os::raw::c_int,
658 ) -> ::std::os::raw::c_ulonglong;
659}
660extern "C" {
661 pub fn strtoll(
662 __nptr: *const ::std::os::raw::c_char,
663 __endptr: *mut *mut ::std::os::raw::c_char,
664 __base: ::std::os::raw::c_int,
665 ) -> ::std::os::raw::c_longlong;
666}
667extern "C" {
668 pub fn strtoull(
669 __nptr: *const ::std::os::raw::c_char,
670 __endptr: *mut *mut ::std::os::raw::c_char,
671 __base: ::std::os::raw::c_int,
672 ) -> ::std::os::raw::c_ulonglong;
673}
674extern "C" {
675 pub fn l64a(__n: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
676}
677extern "C" {
678 pub fn a64l(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
679}
680pub type u_char = __u_char;
681pub type u_short = __u_short;
682pub type u_int = __u_int;
683pub type u_long = __u_long;
684pub type quad_t = __quad_t;
685pub type u_quad_t = __u_quad_t;
686pub type fsid_t = __fsid_t;
687pub type loff_t = __loff_t;
688pub type ino_t = __ino_t;
689pub type dev_t = __dev_t;
690pub type gid_t = __gid_t;
691pub type mode_t = __mode_t;
692pub type nlink_t = __nlink_t;
693pub type uid_t = __uid_t;
694pub type off_t = __off_t;
695pub type pid_t = __pid_t;
696pub type id_t = __id_t;
697pub type ssize_t = __ssize_t;
698pub type daddr_t = __daddr_t;
699pub type caddr_t = __caddr_t;
700pub type key_t = __key_t;
701pub type clock_t = __clock_t;
702pub type clockid_t = __clockid_t;
703pub type time_t = __time_t;
704pub type timer_t = __timer_t;
705pub type ulong = ::std::os::raw::c_ulong;
706pub type ushort = ::std::os::raw::c_ushort;
707pub type uint = ::std::os::raw::c_uint;
708pub type u_int8_t = __uint8_t;
709pub type u_int16_t = __uint16_t;
710pub type u_int32_t = __uint32_t;
711pub type u_int64_t = __uint64_t;
712pub type register_t = ::std::os::raw::c_long;
713#[repr(C)]
714#[derive(Debug, Copy, Clone)]
715pub struct __sigset_t {
716 pub __val: [::std::os::raw::c_ulong; 16usize],
717}
718#[test]
719fn bindgen_test_layout___sigset_t() {
720 assert_eq!(
721 ::std::mem::size_of::<__sigset_t>(),
722 128usize,
723 concat!("Size of: ", stringify!(__sigset_t))
724 );
725 assert_eq!(
726 ::std::mem::align_of::<__sigset_t>(),
727 8usize,
728 concat!("Alignment of ", stringify!(__sigset_t))
729 );
730 fn test_field___val() {
731 assert_eq!(
732 unsafe {
733 let uninit = ::std::mem::MaybeUninit::<__sigset_t>::uninit();
734 let ptr = uninit.as_ptr();
735 ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize
736 },
737 0usize,
738 concat!(
739 "Offset of field: ",
740 stringify!(__sigset_t),
741 "::",
742 stringify!(__val)
743 )
744 );
745 }
746 test_field___val();
747}
748pub type sigset_t = __sigset_t;
749#[repr(C)]
750#[derive(Debug, Copy, Clone)]
751pub struct timeval {
752 pub tv_sec: __time_t,
753 pub tv_usec: __suseconds_t,
754}
755#[test]
756fn bindgen_test_layout_timeval() {
757 assert_eq!(
758 ::std::mem::size_of::<timeval>(),
759 16usize,
760 concat!("Size of: ", stringify!(timeval))
761 );
762 assert_eq!(
763 ::std::mem::align_of::<timeval>(),
764 8usize,
765 concat!("Alignment of ", stringify!(timeval))
766 );
767 fn test_field_tv_sec() {
768 assert_eq!(
769 unsafe {
770 let uninit = ::std::mem::MaybeUninit::<timeval>::uninit();
771 let ptr = uninit.as_ptr();
772 ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize
773 },
774 0usize,
775 concat!(
776 "Offset of field: ",
777 stringify!(timeval),
778 "::",
779 stringify!(tv_sec)
780 )
781 );
782 }
783 test_field_tv_sec();
784 fn test_field_tv_usec() {
785 assert_eq!(
786 unsafe {
787 let uninit = ::std::mem::MaybeUninit::<timeval>::uninit();
788 let ptr = uninit.as_ptr();
789 ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize
790 },
791 8usize,
792 concat!(
793 "Offset of field: ",
794 stringify!(timeval),
795 "::",
796 stringify!(tv_usec)
797 )
798 );
799 }
800 test_field_tv_usec();
801}
802#[repr(C)]
803#[derive(Debug, Copy, Clone)]
804pub struct timespec {
805 pub tv_sec: __time_t,
806 pub tv_nsec: __syscall_slong_t,
807}
808#[test]
809fn bindgen_test_layout_timespec() {
810 assert_eq!(
811 ::std::mem::size_of::<timespec>(),
812 16usize,
813 concat!("Size of: ", stringify!(timespec))
814 );
815 assert_eq!(
816 ::std::mem::align_of::<timespec>(),
817 8usize,
818 concat!("Alignment of ", stringify!(timespec))
819 );
820 fn test_field_tv_sec() {
821 assert_eq!(
822 unsafe {
823 let uninit = ::std::mem::MaybeUninit::<timespec>::uninit();
824 let ptr = uninit.as_ptr();
825 ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize
826 },
827 0usize,
828 concat!(
829 "Offset of field: ",
830 stringify!(timespec),
831 "::",
832 stringify!(tv_sec)
833 )
834 );
835 }
836 test_field_tv_sec();
837 fn test_field_tv_nsec() {
838 assert_eq!(
839 unsafe {
840 let uninit = ::std::mem::MaybeUninit::<timespec>::uninit();
841 let ptr = uninit.as_ptr();
842 ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize
843 },
844 8usize,
845 concat!(
846 "Offset of field: ",
847 stringify!(timespec),
848 "::",
849 stringify!(tv_nsec)
850 )
851 );
852 }
853 test_field_tv_nsec();
854}
855pub type suseconds_t = __suseconds_t;
856pub type __fd_mask = ::std::os::raw::c_long;
857#[repr(C)]
858#[derive(Debug, Copy, Clone)]
859pub struct fd_set {
860 pub __fds_bits: [__fd_mask; 16usize],
861}
862#[test]
863fn bindgen_test_layout_fd_set() {
864 assert_eq!(
865 ::std::mem::size_of::<fd_set>(),
866 128usize,
867 concat!("Size of: ", stringify!(fd_set))
868 );
869 assert_eq!(
870 ::std::mem::align_of::<fd_set>(),
871 8usize,
872 concat!("Alignment of ", stringify!(fd_set))
873 );
874 fn test_field___fds_bits() {
875 assert_eq!(
876 unsafe {
877 let uninit = ::std::mem::MaybeUninit::<fd_set>::uninit();
878 let ptr = uninit.as_ptr();
879 ::std::ptr::addr_of!((*ptr).__fds_bits) as usize - ptr as usize
880 },
881 0usize,
882 concat!(
883 "Offset of field: ",
884 stringify!(fd_set),
885 "::",
886 stringify!(__fds_bits)
887 )
888 );
889 }
890 test_field___fds_bits();
891}
892pub type fd_mask = __fd_mask;
893extern "C" {
894 pub fn select(
895 __nfds: ::std::os::raw::c_int,
896 __readfds: *mut fd_set,
897 __writefds: *mut fd_set,
898 __exceptfds: *mut fd_set,
899 __timeout: *mut timeval,
900 ) -> ::std::os::raw::c_int;
901}
902extern "C" {
903 pub fn pselect(
904 __nfds: ::std::os::raw::c_int,
905 __readfds: *mut fd_set,
906 __writefds: *mut fd_set,
907 __exceptfds: *mut fd_set,
908 __timeout: *const timespec,
909 __sigmask: *const __sigset_t,
910 ) -> ::std::os::raw::c_int;
911}
912pub type blksize_t = __blksize_t;
913pub type blkcnt_t = __blkcnt_t;
914pub type fsblkcnt_t = __fsblkcnt_t;
915pub type fsfilcnt_t = __fsfilcnt_t;
916#[repr(C)]
917#[derive(Copy, Clone)]
918pub union __atomic_wide_counter {
919 pub __value64: ::std::os::raw::c_ulonglong,
920 pub __value32: __atomic_wide_counter__bindgen_ty_1,
921}
922#[repr(C)]
923#[derive(Debug, Copy, Clone)]
924pub struct __atomic_wide_counter__bindgen_ty_1 {
925 pub __low: ::std::os::raw::c_uint,
926 pub __high: ::std::os::raw::c_uint,
927}
928#[test]
929fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
930 assert_eq!(
931 ::std::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(),
932 8usize,
933 concat!("Size of: ", stringify!(__atomic_wide_counter__bindgen_ty_1))
934 );
935 assert_eq!(
936 ::std::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>(),
937 4usize,
938 concat!(
939 "Alignment of ",
940 stringify!(__atomic_wide_counter__bindgen_ty_1)
941 )
942 );
943 fn test_field___low() {
944 assert_eq!(
945 unsafe {
946 let uninit =
947 ::std::mem::MaybeUninit::<__atomic_wide_counter__bindgen_ty_1>::uninit();
948 let ptr = uninit.as_ptr();
949 ::std::ptr::addr_of!((*ptr).__low) as usize - ptr as usize
950 },
951 0usize,
952 concat!(
953 "Offset of field: ",
954 stringify!(__atomic_wide_counter__bindgen_ty_1),
955 "::",
956 stringify!(__low)
957 )
958 );
959 }
960 test_field___low();
961 fn test_field___high() {
962 assert_eq!(
963 unsafe {
964 let uninit =
965 ::std::mem::MaybeUninit::<__atomic_wide_counter__bindgen_ty_1>::uninit();
966 let ptr = uninit.as_ptr();
967 ::std::ptr::addr_of!((*ptr).__high) as usize - ptr as usize
968 },
969 4usize,
970 concat!(
971 "Offset of field: ",
972 stringify!(__atomic_wide_counter__bindgen_ty_1),
973 "::",
974 stringify!(__high)
975 )
976 );
977 }
978 test_field___high();
979}
980#[test]
981fn bindgen_test_layout___atomic_wide_counter() {
982 assert_eq!(
983 ::std::mem::size_of::<__atomic_wide_counter>(),
984 8usize,
985 concat!("Size of: ", stringify!(__atomic_wide_counter))
986 );
987 assert_eq!(
988 ::std::mem::align_of::<__atomic_wide_counter>(),
989 8usize,
990 concat!("Alignment of ", stringify!(__atomic_wide_counter))
991 );
992 fn test_field___value64() {
993 assert_eq!(
994 unsafe {
995 let uninit = ::std::mem::MaybeUninit::<__atomic_wide_counter>::uninit();
996 let ptr = uninit.as_ptr();
997 ::std::ptr::addr_of!((*ptr).__value64) as usize - ptr as usize
998 },
999 0usize,
1000 concat!(
1001 "Offset of field: ",
1002 stringify!(__atomic_wide_counter),
1003 "::",
1004 stringify!(__value64)
1005 )
1006 );
1007 }
1008 test_field___value64();
1009 fn test_field___value32() {
1010 assert_eq!(
1011 unsafe {
1012 let uninit = ::std::mem::MaybeUninit::<__atomic_wide_counter>::uninit();
1013 let ptr = uninit.as_ptr();
1014 ::std::ptr::addr_of!((*ptr).__value32) as usize - ptr as usize
1015 },
1016 0usize,
1017 concat!(
1018 "Offset of field: ",
1019 stringify!(__atomic_wide_counter),
1020 "::",
1021 stringify!(__value32)
1022 )
1023 );
1024 }
1025 test_field___value32();
1026}
1027#[repr(C)]
1028#[derive(Debug, Copy, Clone)]
1029pub struct __pthread_internal_list {
1030 pub __prev: *mut __pthread_internal_list,
1031 pub __next: *mut __pthread_internal_list,
1032}
1033#[test]
1034fn bindgen_test_layout___pthread_internal_list() {
1035 assert_eq!(
1036 ::std::mem::size_of::<__pthread_internal_list>(),
1037 16usize,
1038 concat!("Size of: ", stringify!(__pthread_internal_list))
1039 );
1040 assert_eq!(
1041 ::std::mem::align_of::<__pthread_internal_list>(),
1042 8usize,
1043 concat!("Alignment of ", stringify!(__pthread_internal_list))
1044 );
1045 fn test_field___prev() {
1046 assert_eq!(
1047 unsafe {
1048 let uninit = ::std::mem::MaybeUninit::<__pthread_internal_list>::uninit();
1049 let ptr = uninit.as_ptr();
1050 ::std::ptr::addr_of!((*ptr).__prev) as usize - ptr as usize
1051 },
1052 0usize,
1053 concat!(
1054 "Offset of field: ",
1055 stringify!(__pthread_internal_list),
1056 "::",
1057 stringify!(__prev)
1058 )
1059 );
1060 }
1061 test_field___prev();
1062 fn test_field___next() {
1063 assert_eq!(
1064 unsafe {
1065 let uninit = ::std::mem::MaybeUninit::<__pthread_internal_list>::uninit();
1066 let ptr = uninit.as_ptr();
1067 ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize
1068 },
1069 8usize,
1070 concat!(
1071 "Offset of field: ",
1072 stringify!(__pthread_internal_list),
1073 "::",
1074 stringify!(__next)
1075 )
1076 );
1077 }
1078 test_field___next();
1079}
1080pub type __pthread_list_t = __pthread_internal_list;
1081#[repr(C)]
1082#[derive(Debug, Copy, Clone)]
1083pub struct __pthread_internal_slist {
1084 pub __next: *mut __pthread_internal_slist,
1085}
1086#[test]
1087fn bindgen_test_layout___pthread_internal_slist() {
1088 assert_eq!(
1089 ::std::mem::size_of::<__pthread_internal_slist>(),
1090 8usize,
1091 concat!("Size of: ", stringify!(__pthread_internal_slist))
1092 );
1093 assert_eq!(
1094 ::std::mem::align_of::<__pthread_internal_slist>(),
1095 8usize,
1096 concat!("Alignment of ", stringify!(__pthread_internal_slist))
1097 );
1098 fn test_field___next() {
1099 assert_eq!(
1100 unsafe {
1101 let uninit = ::std::mem::MaybeUninit::<__pthread_internal_slist>::uninit();
1102 let ptr = uninit.as_ptr();
1103 ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize
1104 },
1105 0usize,
1106 concat!(
1107 "Offset of field: ",
1108 stringify!(__pthread_internal_slist),
1109 "::",
1110 stringify!(__next)
1111 )
1112 );
1113 }
1114 test_field___next();
1115}
1116pub type __pthread_slist_t = __pthread_internal_slist;
1117#[repr(C)]
1118#[derive(Debug, Copy, Clone)]
1119pub struct __pthread_mutex_s {
1120 pub __lock: ::std::os::raw::c_int,
1121 pub __count: ::std::os::raw::c_uint,
1122 pub __owner: ::std::os::raw::c_int,
1123 pub __nusers: ::std::os::raw::c_uint,
1124 pub __kind: ::std::os::raw::c_int,
1125 pub __spins: ::std::os::raw::c_short,
1126 pub __elision: ::std::os::raw::c_short,
1127 pub __list: __pthread_list_t,
1128}
1129#[test]
1130fn bindgen_test_layout___pthread_mutex_s() {
1131 assert_eq!(
1132 ::std::mem::size_of::<__pthread_mutex_s>(),
1133 40usize,
1134 concat!("Size of: ", stringify!(__pthread_mutex_s))
1135 );
1136 assert_eq!(
1137 ::std::mem::align_of::<__pthread_mutex_s>(),
1138 8usize,
1139 concat!("Alignment of ", stringify!(__pthread_mutex_s))
1140 );
1141 fn test_field___lock() {
1142 assert_eq!(
1143 unsafe {
1144 let uninit = ::std::mem::MaybeUninit::<__pthread_mutex_s>::uninit();
1145 let ptr = uninit.as_ptr();
1146 ::std::ptr::addr_of!((*ptr).__lock) as usize - ptr as usize
1147 },
1148 0usize,
1149 concat!(
1150 "Offset of field: ",
1151 stringify!(__pthread_mutex_s),
1152 "::",
1153 stringify!(__lock)
1154 )
1155 );
1156 }
1157 test_field___lock();
1158 fn test_field___count() {
1159 assert_eq!(
1160 unsafe {
1161 let uninit = ::std::mem::MaybeUninit::<__pthread_mutex_s>::uninit();
1162 let ptr = uninit.as_ptr();
1163 ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize
1164 },
1165 4usize,
1166 concat!(
1167 "Offset of field: ",
1168 stringify!(__pthread_mutex_s),
1169 "::",
1170 stringify!(__count)
1171 )
1172 );
1173 }
1174 test_field___count();
1175 fn test_field___owner() {
1176 assert_eq!(
1177 unsafe {
1178 let uninit = ::std::mem::MaybeUninit::<__pthread_mutex_s>::uninit();
1179 let ptr = uninit.as_ptr();
1180 ::std::ptr::addr_of!((*ptr).__owner) as usize - ptr as usize
1181 },
1182 8usize,
1183 concat!(
1184 "Offset of field: ",
1185 stringify!(__pthread_mutex_s),
1186 "::",
1187 stringify!(__owner)
1188 )
1189 );
1190 }
1191 test_field___owner();
1192 fn test_field___nusers() {
1193 assert_eq!(
1194 unsafe {
1195 let uninit = ::std::mem::MaybeUninit::<__pthread_mutex_s>::uninit();
1196 let ptr = uninit.as_ptr();
1197 ::std::ptr::addr_of!((*ptr).__nusers) as usize - ptr as usize
1198 },
1199 12usize,
1200 concat!(
1201 "Offset of field: ",
1202 stringify!(__pthread_mutex_s),
1203 "::",
1204 stringify!(__nusers)
1205 )
1206 );
1207 }
1208 test_field___nusers();
1209 fn test_field___kind() {
1210 assert_eq!(
1211 unsafe {
1212 let uninit = ::std::mem::MaybeUninit::<__pthread_mutex_s>::uninit();
1213 let ptr = uninit.as_ptr();
1214 ::std::ptr::addr_of!((*ptr).__kind) as usize - ptr as usize
1215 },
1216 16usize,
1217 concat!(
1218 "Offset of field: ",
1219 stringify!(__pthread_mutex_s),
1220 "::",
1221 stringify!(__kind)
1222 )
1223 );
1224 }
1225 test_field___kind();
1226 fn test_field___spins() {
1227 assert_eq!(
1228 unsafe {
1229 let uninit = ::std::mem::MaybeUninit::<__pthread_mutex_s>::uninit();
1230 let ptr = uninit.as_ptr();
1231 ::std::ptr::addr_of!((*ptr).__spins) as usize - ptr as usize
1232 },
1233 20usize,
1234 concat!(
1235 "Offset of field: ",
1236 stringify!(__pthread_mutex_s),
1237 "::",
1238 stringify!(__spins)
1239 )
1240 );
1241 }
1242 test_field___spins();
1243 fn test_field___elision() {
1244 assert_eq!(
1245 unsafe {
1246 let uninit = ::std::mem::MaybeUninit::<__pthread_mutex_s>::uninit();
1247 let ptr = uninit.as_ptr();
1248 ::std::ptr::addr_of!((*ptr).__elision) as usize - ptr as usize
1249 },
1250 22usize,
1251 concat!(
1252 "Offset of field: ",
1253 stringify!(__pthread_mutex_s),
1254 "::",
1255 stringify!(__elision)
1256 )
1257 );
1258 }
1259 test_field___elision();
1260 fn test_field___list() {
1261 assert_eq!(
1262 unsafe {
1263 let uninit = ::std::mem::MaybeUninit::<__pthread_mutex_s>::uninit();
1264 let ptr = uninit.as_ptr();
1265 ::std::ptr::addr_of!((*ptr).__list) as usize - ptr as usize
1266 },
1267 24usize,
1268 concat!(
1269 "Offset of field: ",
1270 stringify!(__pthread_mutex_s),
1271 "::",
1272 stringify!(__list)
1273 )
1274 );
1275 }
1276 test_field___list();
1277}
1278#[repr(C)]
1279#[derive(Debug, Copy, Clone)]
1280pub struct __pthread_rwlock_arch_t {
1281 pub __readers: ::std::os::raw::c_uint,
1282 pub __writers: ::std::os::raw::c_uint,
1283 pub __wrphase_futex: ::std::os::raw::c_uint,
1284 pub __writers_futex: ::std::os::raw::c_uint,
1285 pub __pad3: ::std::os::raw::c_uint,
1286 pub __pad4: ::std::os::raw::c_uint,
1287 pub __cur_writer: ::std::os::raw::c_int,
1288 pub __shared: ::std::os::raw::c_int,
1289 pub __rwelision: ::std::os::raw::c_schar,
1290 pub __pad1: [::std::os::raw::c_uchar; 7usize],
1291 pub __pad2: ::std::os::raw::c_ulong,
1292 pub __flags: ::std::os::raw::c_uint,
1293}
1294#[test]
1295fn bindgen_test_layout___pthread_rwlock_arch_t() {
1296 assert_eq!(
1297 ::std::mem::size_of::<__pthread_rwlock_arch_t>(),
1298 56usize,
1299 concat!("Size of: ", stringify!(__pthread_rwlock_arch_t))
1300 );
1301 assert_eq!(
1302 ::std::mem::align_of::<__pthread_rwlock_arch_t>(),
1303 8usize,
1304 concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
1305 );
1306 fn test_field___readers() {
1307 assert_eq!(
1308 unsafe {
1309 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1310 let ptr = uninit.as_ptr();
1311 ::std::ptr::addr_of!((*ptr).__readers) as usize - ptr as usize
1312 },
1313 0usize,
1314 concat!(
1315 "Offset of field: ",
1316 stringify!(__pthread_rwlock_arch_t),
1317 "::",
1318 stringify!(__readers)
1319 )
1320 );
1321 }
1322 test_field___readers();
1323 fn test_field___writers() {
1324 assert_eq!(
1325 unsafe {
1326 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1327 let ptr = uninit.as_ptr();
1328 ::std::ptr::addr_of!((*ptr).__writers) as usize - ptr as usize
1329 },
1330 4usize,
1331 concat!(
1332 "Offset of field: ",
1333 stringify!(__pthread_rwlock_arch_t),
1334 "::",
1335 stringify!(__writers)
1336 )
1337 );
1338 }
1339 test_field___writers();
1340 fn test_field___wrphase_futex() {
1341 assert_eq!(
1342 unsafe {
1343 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1344 let ptr = uninit.as_ptr();
1345 ::std::ptr::addr_of!((*ptr).__wrphase_futex) as usize - ptr as usize
1346 },
1347 8usize,
1348 concat!(
1349 "Offset of field: ",
1350 stringify!(__pthread_rwlock_arch_t),
1351 "::",
1352 stringify!(__wrphase_futex)
1353 )
1354 );
1355 }
1356 test_field___wrphase_futex();
1357 fn test_field___writers_futex() {
1358 assert_eq!(
1359 unsafe {
1360 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1361 let ptr = uninit.as_ptr();
1362 ::std::ptr::addr_of!((*ptr).__writers_futex) as usize - ptr as usize
1363 },
1364 12usize,
1365 concat!(
1366 "Offset of field: ",
1367 stringify!(__pthread_rwlock_arch_t),
1368 "::",
1369 stringify!(__writers_futex)
1370 )
1371 );
1372 }
1373 test_field___writers_futex();
1374 fn test_field___pad3() {
1375 assert_eq!(
1376 unsafe {
1377 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1378 let ptr = uninit.as_ptr();
1379 ::std::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize
1380 },
1381 16usize,
1382 concat!(
1383 "Offset of field: ",
1384 stringify!(__pthread_rwlock_arch_t),
1385 "::",
1386 stringify!(__pad3)
1387 )
1388 );
1389 }
1390 test_field___pad3();
1391 fn test_field___pad4() {
1392 assert_eq!(
1393 unsafe {
1394 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1395 let ptr = uninit.as_ptr();
1396 ::std::ptr::addr_of!((*ptr).__pad4) as usize - ptr as usize
1397 },
1398 20usize,
1399 concat!(
1400 "Offset of field: ",
1401 stringify!(__pthread_rwlock_arch_t),
1402 "::",
1403 stringify!(__pad4)
1404 )
1405 );
1406 }
1407 test_field___pad4();
1408 fn test_field___cur_writer() {
1409 assert_eq!(
1410 unsafe {
1411 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1412 let ptr = uninit.as_ptr();
1413 ::std::ptr::addr_of!((*ptr).__cur_writer) as usize - ptr as usize
1414 },
1415 24usize,
1416 concat!(
1417 "Offset of field: ",
1418 stringify!(__pthread_rwlock_arch_t),
1419 "::",
1420 stringify!(__cur_writer)
1421 )
1422 );
1423 }
1424 test_field___cur_writer();
1425 fn test_field___shared() {
1426 assert_eq!(
1427 unsafe {
1428 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1429 let ptr = uninit.as_ptr();
1430 ::std::ptr::addr_of!((*ptr).__shared) as usize - ptr as usize
1431 },
1432 28usize,
1433 concat!(
1434 "Offset of field: ",
1435 stringify!(__pthread_rwlock_arch_t),
1436 "::",
1437 stringify!(__shared)
1438 )
1439 );
1440 }
1441 test_field___shared();
1442 fn test_field___rwelision() {
1443 assert_eq!(
1444 unsafe {
1445 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1446 let ptr = uninit.as_ptr();
1447 ::std::ptr::addr_of!((*ptr).__rwelision) as usize - ptr as usize
1448 },
1449 32usize,
1450 concat!(
1451 "Offset of field: ",
1452 stringify!(__pthread_rwlock_arch_t),
1453 "::",
1454 stringify!(__rwelision)
1455 )
1456 );
1457 }
1458 test_field___rwelision();
1459 fn test_field___pad1() {
1460 assert_eq!(
1461 unsafe {
1462 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1463 let ptr = uninit.as_ptr();
1464 ::std::ptr::addr_of!((*ptr).__pad1) as usize - ptr as usize
1465 },
1466 33usize,
1467 concat!(
1468 "Offset of field: ",
1469 stringify!(__pthread_rwlock_arch_t),
1470 "::",
1471 stringify!(__pad1)
1472 )
1473 );
1474 }
1475 test_field___pad1();
1476 fn test_field___pad2() {
1477 assert_eq!(
1478 unsafe {
1479 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1480 let ptr = uninit.as_ptr();
1481 ::std::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize
1482 },
1483 40usize,
1484 concat!(
1485 "Offset of field: ",
1486 stringify!(__pthread_rwlock_arch_t),
1487 "::",
1488 stringify!(__pad2)
1489 )
1490 );
1491 }
1492 test_field___pad2();
1493 fn test_field___flags() {
1494 assert_eq!(
1495 unsafe {
1496 let uninit = ::std::mem::MaybeUninit::<__pthread_rwlock_arch_t>::uninit();
1497 let ptr = uninit.as_ptr();
1498 ::std::ptr::addr_of!((*ptr).__flags) as usize - ptr as usize
1499 },
1500 48usize,
1501 concat!(
1502 "Offset of field: ",
1503 stringify!(__pthread_rwlock_arch_t),
1504 "::",
1505 stringify!(__flags)
1506 )
1507 );
1508 }
1509 test_field___flags();
1510}
1511#[repr(C)]
1512#[derive(Copy, Clone)]
1513pub struct __pthread_cond_s {
1514 pub __wseq: __atomic_wide_counter,
1515 pub __g1_start: __atomic_wide_counter,
1516 pub __g_refs: [::std::os::raw::c_uint; 2usize],
1517 pub __g_size: [::std::os::raw::c_uint; 2usize],
1518 pub __g1_orig_size: ::std::os::raw::c_uint,
1519 pub __wrefs: ::std::os::raw::c_uint,
1520 pub __g_signals: [::std::os::raw::c_uint; 2usize],
1521}
1522#[test]
1523fn bindgen_test_layout___pthread_cond_s() {
1524 assert_eq!(
1525 ::std::mem::size_of::<__pthread_cond_s>(),
1526 48usize,
1527 concat!("Size of: ", stringify!(__pthread_cond_s))
1528 );
1529 assert_eq!(
1530 ::std::mem::align_of::<__pthread_cond_s>(),
1531 8usize,
1532 concat!("Alignment of ", stringify!(__pthread_cond_s))
1533 );
1534 fn test_field___wseq() {
1535 assert_eq!(
1536 unsafe {
1537 let uninit = ::std::mem::MaybeUninit::<__pthread_cond_s>::uninit();
1538 let ptr = uninit.as_ptr();
1539 ::std::ptr::addr_of!((*ptr).__wseq) as usize - ptr as usize
1540 },
1541 0usize,
1542 concat!(
1543 "Offset of field: ",
1544 stringify!(__pthread_cond_s),
1545 "::",
1546 stringify!(__wseq)
1547 )
1548 );
1549 }
1550 test_field___wseq();
1551 fn test_field___g1_start() {
1552 assert_eq!(
1553 unsafe {
1554 let uninit = ::std::mem::MaybeUninit::<__pthread_cond_s>::uninit();
1555 let ptr = uninit.as_ptr();
1556 ::std::ptr::addr_of!((*ptr).__g1_start) as usize - ptr as usize
1557 },
1558 8usize,
1559 concat!(
1560 "Offset of field: ",
1561 stringify!(__pthread_cond_s),
1562 "::",
1563 stringify!(__g1_start)
1564 )
1565 );
1566 }
1567 test_field___g1_start();
1568 fn test_field___g_refs() {
1569 assert_eq!(
1570 unsafe {
1571 let uninit = ::std::mem::MaybeUninit::<__pthread_cond_s>::uninit();
1572 let ptr = uninit.as_ptr();
1573 ::std::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as usize
1574 },
1575 16usize,
1576 concat!(
1577 "Offset of field: ",
1578 stringify!(__pthread_cond_s),
1579 "::",
1580 stringify!(__g_refs)
1581 )
1582 );
1583 }
1584 test_field___g_refs();
1585 fn test_field___g_size() {
1586 assert_eq!(
1587 unsafe {
1588 let uninit = ::std::mem::MaybeUninit::<__pthread_cond_s>::uninit();
1589 let ptr = uninit.as_ptr();
1590 ::std::ptr::addr_of!((*ptr).__g_size) as usize - ptr as usize
1591 },
1592 24usize,
1593 concat!(
1594 "Offset of field: ",
1595 stringify!(__pthread_cond_s),
1596 "::",
1597 stringify!(__g_size)
1598 )
1599 );
1600 }
1601 test_field___g_size();
1602 fn test_field___g1_orig_size() {
1603 assert_eq!(
1604 unsafe {
1605 let uninit = ::std::mem::MaybeUninit::<__pthread_cond_s>::uninit();
1606 let ptr = uninit.as_ptr();
1607 ::std::ptr::addr_of!((*ptr).__g1_orig_size) as usize - ptr as usize
1608 },
1609 32usize,
1610 concat!(
1611 "Offset of field: ",
1612 stringify!(__pthread_cond_s),
1613 "::",
1614 stringify!(__g1_orig_size)
1615 )
1616 );
1617 }
1618 test_field___g1_orig_size();
1619 fn test_field___wrefs() {
1620 assert_eq!(
1621 unsafe {
1622 let uninit = ::std::mem::MaybeUninit::<__pthread_cond_s>::uninit();
1623 let ptr = uninit.as_ptr();
1624 ::std::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as usize
1625 },
1626 36usize,
1627 concat!(
1628 "Offset of field: ",
1629 stringify!(__pthread_cond_s),
1630 "::",
1631 stringify!(__wrefs)
1632 )
1633 );
1634 }
1635 test_field___wrefs();
1636 fn test_field___g_signals() {
1637 assert_eq!(
1638 unsafe {
1639 let uninit = ::std::mem::MaybeUninit::<__pthread_cond_s>::uninit();
1640 let ptr = uninit.as_ptr();
1641 ::std::ptr::addr_of!((*ptr).__g_signals) as usize - ptr as usize
1642 },
1643 40usize,
1644 concat!(
1645 "Offset of field: ",
1646 stringify!(__pthread_cond_s),
1647 "::",
1648 stringify!(__g_signals)
1649 )
1650 );
1651 }
1652 test_field___g_signals();
1653}
1654pub type __tss_t = ::std::os::raw::c_uint;
1655pub type __thrd_t = ::std::os::raw::c_ulong;
1656#[repr(C)]
1657#[derive(Debug, Copy, Clone)]
1658pub struct __once_flag {
1659 pub __data: ::std::os::raw::c_int,
1660}
1661#[test]
1662fn bindgen_test_layout___once_flag() {
1663 assert_eq!(
1664 ::std::mem::size_of::<__once_flag>(),
1665 4usize,
1666 concat!("Size of: ", stringify!(__once_flag))
1667 );
1668 assert_eq!(
1669 ::std::mem::align_of::<__once_flag>(),
1670 4usize,
1671 concat!("Alignment of ", stringify!(__once_flag))
1672 );
1673 fn test_field___data() {
1674 assert_eq!(
1675 unsafe {
1676 let uninit = ::std::mem::MaybeUninit::<__once_flag>::uninit();
1677 let ptr = uninit.as_ptr();
1678 ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize
1679 },
1680 0usize,
1681 concat!(
1682 "Offset of field: ",
1683 stringify!(__once_flag),
1684 "::",
1685 stringify!(__data)
1686 )
1687 );
1688 }
1689 test_field___data();
1690}
1691pub type pthread_t = ::std::os::raw::c_ulong;
1692#[repr(C)]
1693#[derive(Copy, Clone)]
1694pub union pthread_mutexattr_t {
1695 pub __size: [::std::os::raw::c_char; 4usize],
1696 pub __align: ::std::os::raw::c_int,
1697}
1698#[test]
1699fn bindgen_test_layout_pthread_mutexattr_t() {
1700 assert_eq!(
1701 ::std::mem::size_of::<pthread_mutexattr_t>(),
1702 4usize,
1703 concat!("Size of: ", stringify!(pthread_mutexattr_t))
1704 );
1705 assert_eq!(
1706 ::std::mem::align_of::<pthread_mutexattr_t>(),
1707 4usize,
1708 concat!("Alignment of ", stringify!(pthread_mutexattr_t))
1709 );
1710 fn test_field___size() {
1711 assert_eq!(
1712 unsafe {
1713 let uninit = ::std::mem::MaybeUninit::<pthread_mutexattr_t>::uninit();
1714 let ptr = uninit.as_ptr();
1715 ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize
1716 },
1717 0usize,
1718 concat!(
1719 "Offset of field: ",
1720 stringify!(pthread_mutexattr_t),
1721 "::",
1722 stringify!(__size)
1723 )
1724 );
1725 }
1726 test_field___size();
1727 fn test_field___align() {
1728 assert_eq!(
1729 unsafe {
1730 let uninit = ::std::mem::MaybeUninit::<pthread_mutexattr_t>::uninit();
1731 let ptr = uninit.as_ptr();
1732 ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize
1733 },
1734 0usize,
1735 concat!(
1736 "Offset of field: ",
1737 stringify!(pthread_mutexattr_t),
1738 "::",
1739 stringify!(__align)
1740 )
1741 );
1742 }
1743 test_field___align();
1744}
1745#[repr(C)]
1746#[derive(Copy, Clone)]
1747pub union pthread_condattr_t {
1748 pub __size: [::std::os::raw::c_char; 4usize],
1749 pub __align: ::std::os::raw::c_int,
1750}
1751#[test]
1752fn bindgen_test_layout_pthread_condattr_t() {
1753 assert_eq!(
1754 ::std::mem::size_of::<pthread_condattr_t>(),
1755 4usize,
1756 concat!("Size of: ", stringify!(pthread_condattr_t))
1757 );
1758 assert_eq!(
1759 ::std::mem::align_of::<pthread_condattr_t>(),
1760 4usize,
1761 concat!("Alignment of ", stringify!(pthread_condattr_t))
1762 );
1763 fn test_field___size() {
1764 assert_eq!(
1765 unsafe {
1766 let uninit = ::std::mem::MaybeUninit::<pthread_condattr_t>::uninit();
1767 let ptr = uninit.as_ptr();
1768 ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize
1769 },
1770 0usize,
1771 concat!(
1772 "Offset of field: ",
1773 stringify!(pthread_condattr_t),
1774 "::",
1775 stringify!(__size)
1776 )
1777 );
1778 }
1779 test_field___size();
1780 fn test_field___align() {
1781 assert_eq!(
1782 unsafe {
1783 let uninit = ::std::mem::MaybeUninit::<pthread_condattr_t>::uninit();
1784 let ptr = uninit.as_ptr();
1785 ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize
1786 },
1787 0usize,
1788 concat!(
1789 "Offset of field: ",
1790 stringify!(pthread_condattr_t),
1791 "::",
1792 stringify!(__align)
1793 )
1794 );
1795 }
1796 test_field___align();
1797}
1798pub type pthread_key_t = ::std::os::raw::c_uint;
1799pub type pthread_once_t = ::std::os::raw::c_int;
1800#[repr(C)]
1801#[derive(Copy, Clone)]
1802pub union pthread_attr_t {
1803 pub __size: [::std::os::raw::c_char; 56usize],
1804 pub __align: ::std::os::raw::c_long,
1805}
1806#[test]
1807fn bindgen_test_layout_pthread_attr_t() {
1808 assert_eq!(
1809 ::std::mem::size_of::<pthread_attr_t>(),
1810 56usize,
1811 concat!("Size of: ", stringify!(pthread_attr_t))
1812 );
1813 assert_eq!(
1814 ::std::mem::align_of::<pthread_attr_t>(),
1815 8usize,
1816 concat!("Alignment of ", stringify!(pthread_attr_t))
1817 );
1818 fn test_field___size() {
1819 assert_eq!(
1820 unsafe {
1821 let uninit = ::std::mem::MaybeUninit::<pthread_attr_t>::uninit();
1822 let ptr = uninit.as_ptr();
1823 ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize
1824 },
1825 0usize,
1826 concat!(
1827 "Offset of field: ",
1828 stringify!(pthread_attr_t),
1829 "::",
1830 stringify!(__size)
1831 )
1832 );
1833 }
1834 test_field___size();
1835 fn test_field___align() {
1836 assert_eq!(
1837 unsafe {
1838 let uninit = ::std::mem::MaybeUninit::<pthread_attr_t>::uninit();
1839 let ptr = uninit.as_ptr();
1840 ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize
1841 },
1842 0usize,
1843 concat!(
1844 "Offset of field: ",
1845 stringify!(pthread_attr_t),
1846 "::",
1847 stringify!(__align)
1848 )
1849 );
1850 }
1851 test_field___align();
1852}
1853#[repr(C)]
1854#[derive(Copy, Clone)]
1855pub union pthread_mutex_t {
1856 pub __data: __pthread_mutex_s,
1857 pub __size: [::std::os::raw::c_char; 40usize],
1858 pub __align: ::std::os::raw::c_long,
1859}
1860#[test]
1861fn bindgen_test_layout_pthread_mutex_t() {
1862 assert_eq!(
1863 ::std::mem::size_of::<pthread_mutex_t>(),
1864 40usize,
1865 concat!("Size of: ", stringify!(pthread_mutex_t))
1866 );
1867 assert_eq!(
1868 ::std::mem::align_of::<pthread_mutex_t>(),
1869 8usize,
1870 concat!("Alignment of ", stringify!(pthread_mutex_t))
1871 );
1872 fn test_field___data() {
1873 assert_eq!(
1874 unsafe {
1875 let uninit = ::std::mem::MaybeUninit::<pthread_mutex_t>::uninit();
1876 let ptr = uninit.as_ptr();
1877 ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize
1878 },
1879 0usize,
1880 concat!(
1881 "Offset of field: ",
1882 stringify!(pthread_mutex_t),
1883 "::",
1884 stringify!(__data)
1885 )
1886 );
1887 }
1888 test_field___data();
1889 fn test_field___size() {
1890 assert_eq!(
1891 unsafe {
1892 let uninit = ::std::mem::MaybeUninit::<pthread_mutex_t>::uninit();
1893 let ptr = uninit.as_ptr();
1894 ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize
1895 },
1896 0usize,
1897 concat!(
1898 "Offset of field: ",
1899 stringify!(pthread_mutex_t),
1900 "::",
1901 stringify!(__size)
1902 )
1903 );
1904 }
1905 test_field___size();
1906 fn test_field___align() {
1907 assert_eq!(
1908 unsafe {
1909 let uninit = ::std::mem::MaybeUninit::<pthread_mutex_t>::uninit();
1910 let ptr = uninit.as_ptr();
1911 ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize
1912 },
1913 0usize,
1914 concat!(
1915 "Offset of field: ",
1916 stringify!(pthread_mutex_t),
1917 "::",
1918 stringify!(__align)
1919 )
1920 );
1921 }
1922 test_field___align();
1923}
1924#[repr(C)]
1925#[derive(Copy, Clone)]
1926pub union pthread_cond_t {
1927 pub __data: __pthread_cond_s,
1928 pub __size: [::std::os::raw::c_char; 48usize],
1929 pub __align: ::std::os::raw::c_longlong,
1930}
1931#[test]
1932fn bindgen_test_layout_pthread_cond_t() {
1933 assert_eq!(
1934 ::std::mem::size_of::<pthread_cond_t>(),
1935 48usize,
1936 concat!("Size of: ", stringify!(pthread_cond_t))
1937 );
1938 assert_eq!(
1939 ::std::mem::align_of::<pthread_cond_t>(),
1940 8usize,
1941 concat!("Alignment of ", stringify!(pthread_cond_t))
1942 );
1943 fn test_field___data() {
1944 assert_eq!(
1945 unsafe {
1946 let uninit = ::std::mem::MaybeUninit::<pthread_cond_t>::uninit();
1947 let ptr = uninit.as_ptr();
1948 ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize
1949 },
1950 0usize,
1951 concat!(
1952 "Offset of field: ",
1953 stringify!(pthread_cond_t),
1954 "::",
1955 stringify!(__data)
1956 )
1957 );
1958 }
1959 test_field___data();
1960 fn test_field___size() {
1961 assert_eq!(
1962 unsafe {
1963 let uninit = ::std::mem::MaybeUninit::<pthread_cond_t>::uninit();
1964 let ptr = uninit.as_ptr();
1965 ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize
1966 },
1967 0usize,
1968 concat!(
1969 "Offset of field: ",
1970 stringify!(pthread_cond_t),
1971 "::",
1972 stringify!(__size)
1973 )
1974 );
1975 }
1976 test_field___size();
1977 fn test_field___align() {
1978 assert_eq!(
1979 unsafe {
1980 let uninit = ::std::mem::MaybeUninit::<pthread_cond_t>::uninit();
1981 let ptr = uninit.as_ptr();
1982 ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize
1983 },
1984 0usize,
1985 concat!(
1986 "Offset of field: ",
1987 stringify!(pthread_cond_t),
1988 "::",
1989 stringify!(__align)
1990 )
1991 );
1992 }
1993 test_field___align();
1994}
1995#[repr(C)]
1996#[derive(Copy, Clone)]
1997pub union pthread_rwlock_t {
1998 pub __data: __pthread_rwlock_arch_t,
1999 pub __size: [::std::os::raw::c_char; 56usize],
2000 pub __align: ::std::os::raw::c_long,
2001}
2002#[test]
2003fn bindgen_test_layout_pthread_rwlock_t() {
2004 assert_eq!(
2005 ::std::mem::size_of::<pthread_rwlock_t>(),
2006 56usize,
2007 concat!("Size of: ", stringify!(pthread_rwlock_t))
2008 );
2009 assert_eq!(
2010 ::std::mem::align_of::<pthread_rwlock_t>(),
2011 8usize,
2012 concat!("Alignment of ", stringify!(pthread_rwlock_t))
2013 );
2014 fn test_field___data() {
2015 assert_eq!(
2016 unsafe {
2017 let uninit = ::std::mem::MaybeUninit::<pthread_rwlock_t>::uninit();
2018 let ptr = uninit.as_ptr();
2019 ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize
2020 },
2021 0usize,
2022 concat!(
2023 "Offset of field: ",
2024 stringify!(pthread_rwlock_t),
2025 "::",
2026 stringify!(__data)
2027 )
2028 );
2029 }
2030 test_field___data();
2031 fn test_field___size() {
2032 assert_eq!(
2033 unsafe {
2034 let uninit = ::std::mem::MaybeUninit::<pthread_rwlock_t>::uninit();
2035 let ptr = uninit.as_ptr();
2036 ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize
2037 },
2038 0usize,
2039 concat!(
2040 "Offset of field: ",
2041 stringify!(pthread_rwlock_t),
2042 "::",
2043 stringify!(__size)
2044 )
2045 );
2046 }
2047 test_field___size();
2048 fn test_field___align() {
2049 assert_eq!(
2050 unsafe {
2051 let uninit = ::std::mem::MaybeUninit::<pthread_rwlock_t>::uninit();
2052 let ptr = uninit.as_ptr();
2053 ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize
2054 },
2055 0usize,
2056 concat!(
2057 "Offset of field: ",
2058 stringify!(pthread_rwlock_t),
2059 "::",
2060 stringify!(__align)
2061 )
2062 );
2063 }
2064 test_field___align();
2065}
2066#[repr(C)]
2067#[derive(Copy, Clone)]
2068pub union pthread_rwlockattr_t {
2069 pub __size: [::std::os::raw::c_char; 8usize],
2070 pub __align: ::std::os::raw::c_long,
2071}
2072#[test]
2073fn bindgen_test_layout_pthread_rwlockattr_t() {
2074 assert_eq!(
2075 ::std::mem::size_of::<pthread_rwlockattr_t>(),
2076 8usize,
2077 concat!("Size of: ", stringify!(pthread_rwlockattr_t))
2078 );
2079 assert_eq!(
2080 ::std::mem::align_of::<pthread_rwlockattr_t>(),
2081 8usize,
2082 concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
2083 );
2084 fn test_field___size() {
2085 assert_eq!(
2086 unsafe {
2087 let uninit = ::std::mem::MaybeUninit::<pthread_rwlockattr_t>::uninit();
2088 let ptr = uninit.as_ptr();
2089 ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize
2090 },
2091 0usize,
2092 concat!(
2093 "Offset of field: ",
2094 stringify!(pthread_rwlockattr_t),
2095 "::",
2096 stringify!(__size)
2097 )
2098 );
2099 }
2100 test_field___size();
2101 fn test_field___align() {
2102 assert_eq!(
2103 unsafe {
2104 let uninit = ::std::mem::MaybeUninit::<pthread_rwlockattr_t>::uninit();
2105 let ptr = uninit.as_ptr();
2106 ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize
2107 },
2108 0usize,
2109 concat!(
2110 "Offset of field: ",
2111 stringify!(pthread_rwlockattr_t),
2112 "::",
2113 stringify!(__align)
2114 )
2115 );
2116 }
2117 test_field___align();
2118}
2119pub type pthread_spinlock_t = ::std::os::raw::c_int;
2120#[repr(C)]
2121#[derive(Copy, Clone)]
2122pub union pthread_barrier_t {
2123 pub __size: [::std::os::raw::c_char; 32usize],
2124 pub __align: ::std::os::raw::c_long,
2125}
2126#[test]
2127fn bindgen_test_layout_pthread_barrier_t() {
2128 assert_eq!(
2129 ::std::mem::size_of::<pthread_barrier_t>(),
2130 32usize,
2131 concat!("Size of: ", stringify!(pthread_barrier_t))
2132 );
2133 assert_eq!(
2134 ::std::mem::align_of::<pthread_barrier_t>(),
2135 8usize,
2136 concat!("Alignment of ", stringify!(pthread_barrier_t))
2137 );
2138 fn test_field___size() {
2139 assert_eq!(
2140 unsafe {
2141 let uninit = ::std::mem::MaybeUninit::<pthread_barrier_t>::uninit();
2142 let ptr = uninit.as_ptr();
2143 ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize
2144 },
2145 0usize,
2146 concat!(
2147 "Offset of field: ",
2148 stringify!(pthread_barrier_t),
2149 "::",
2150 stringify!(__size)
2151 )
2152 );
2153 }
2154 test_field___size();
2155 fn test_field___align() {
2156 assert_eq!(
2157 unsafe {
2158 let uninit = ::std::mem::MaybeUninit::<pthread_barrier_t>::uninit();
2159 let ptr = uninit.as_ptr();
2160 ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize
2161 },
2162 0usize,
2163 concat!(
2164 "Offset of field: ",
2165 stringify!(pthread_barrier_t),
2166 "::",
2167 stringify!(__align)
2168 )
2169 );
2170 }
2171 test_field___align();
2172}
2173#[repr(C)]
2174#[derive(Copy, Clone)]
2175pub union pthread_barrierattr_t {
2176 pub __size: [::std::os::raw::c_char; 4usize],
2177 pub __align: ::std::os::raw::c_int,
2178}
2179#[test]
2180fn bindgen_test_layout_pthread_barrierattr_t() {
2181 assert_eq!(
2182 ::std::mem::size_of::<pthread_barrierattr_t>(),
2183 4usize,
2184 concat!("Size of: ", stringify!(pthread_barrierattr_t))
2185 );
2186 assert_eq!(
2187 ::std::mem::align_of::<pthread_barrierattr_t>(),
2188 4usize,
2189 concat!("Alignment of ", stringify!(pthread_barrierattr_t))
2190 );
2191 fn test_field___size() {
2192 assert_eq!(
2193 unsafe {
2194 let uninit = ::std::mem::MaybeUninit::<pthread_barrierattr_t>::uninit();
2195 let ptr = uninit.as_ptr();
2196 ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize
2197 },
2198 0usize,
2199 concat!(
2200 "Offset of field: ",
2201 stringify!(pthread_barrierattr_t),
2202 "::",
2203 stringify!(__size)
2204 )
2205 );
2206 }
2207 test_field___size();
2208 fn test_field___align() {
2209 assert_eq!(
2210 unsafe {
2211 let uninit = ::std::mem::MaybeUninit::<pthread_barrierattr_t>::uninit();
2212 let ptr = uninit.as_ptr();
2213 ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize
2214 },
2215 0usize,
2216 concat!(
2217 "Offset of field: ",
2218 stringify!(pthread_barrierattr_t),
2219 "::",
2220 stringify!(__align)
2221 )
2222 );
2223 }
2224 test_field___align();
2225}
2226extern "C" {
2227 pub fn random() -> ::std::os::raw::c_long;
2228}
2229extern "C" {
2230 pub fn srandom(__seed: ::std::os::raw::c_uint);
2231}
2232extern "C" {
2233 pub fn initstate(
2234 __seed: ::std::os::raw::c_uint,
2235 __statebuf: *mut ::std::os::raw::c_char,
2236 __statelen: size_t,
2237 ) -> *mut ::std::os::raw::c_char;
2238}
2239extern "C" {
2240 pub fn setstate(__statebuf: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2241}
2242#[repr(C)]
2243#[derive(Debug, Copy, Clone)]
2244pub struct random_data {
2245 pub fptr: *mut i32,
2246 pub rptr: *mut i32,
2247 pub state: *mut i32,
2248 pub rand_type: ::std::os::raw::c_int,
2249 pub rand_deg: ::std::os::raw::c_int,
2250 pub rand_sep: ::std::os::raw::c_int,
2251 pub end_ptr: *mut i32,
2252}
2253#[test]
2254fn bindgen_test_layout_random_data() {
2255 assert_eq!(
2256 ::std::mem::size_of::<random_data>(),
2257 48usize,
2258 concat!("Size of: ", stringify!(random_data))
2259 );
2260 assert_eq!(
2261 ::std::mem::align_of::<random_data>(),
2262 8usize,
2263 concat!("Alignment of ", stringify!(random_data))
2264 );
2265 fn test_field_fptr() {
2266 assert_eq!(
2267 unsafe {
2268 let uninit = ::std::mem::MaybeUninit::<random_data>::uninit();
2269 let ptr = uninit.as_ptr();
2270 ::std::ptr::addr_of!((*ptr).fptr) as usize - ptr as usize
2271 },
2272 0usize,
2273 concat!(
2274 "Offset of field: ",
2275 stringify!(random_data),
2276 "::",
2277 stringify!(fptr)
2278 )
2279 );
2280 }
2281 test_field_fptr();
2282 fn test_field_rptr() {
2283 assert_eq!(
2284 unsafe {
2285 let uninit = ::std::mem::MaybeUninit::<random_data>::uninit();
2286 let ptr = uninit.as_ptr();
2287 ::std::ptr::addr_of!((*ptr).rptr) as usize - ptr as usize
2288 },
2289 8usize,
2290 concat!(
2291 "Offset of field: ",
2292 stringify!(random_data),
2293 "::",
2294 stringify!(rptr)
2295 )
2296 );
2297 }
2298 test_field_rptr();
2299 fn test_field_state() {
2300 assert_eq!(
2301 unsafe {
2302 let uninit = ::std::mem::MaybeUninit::<random_data>::uninit();
2303 let ptr = uninit.as_ptr();
2304 ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize
2305 },
2306 16usize,
2307 concat!(
2308 "Offset of field: ",
2309 stringify!(random_data),
2310 "::",
2311 stringify!(state)
2312 )
2313 );
2314 }
2315 test_field_state();
2316 fn test_field_rand_type() {
2317 assert_eq!(
2318 unsafe {
2319 let uninit = ::std::mem::MaybeUninit::<random_data>::uninit();
2320 let ptr = uninit.as_ptr();
2321 ::std::ptr::addr_of!((*ptr).rand_type) as usize - ptr as usize
2322 },
2323 24usize,
2324 concat!(
2325 "Offset of field: ",
2326 stringify!(random_data),
2327 "::",
2328 stringify!(rand_type)
2329 )
2330 );
2331 }
2332 test_field_rand_type();
2333 fn test_field_rand_deg() {
2334 assert_eq!(
2335 unsafe {
2336 let uninit = ::std::mem::MaybeUninit::<random_data>::uninit();
2337 let ptr = uninit.as_ptr();
2338 ::std::ptr::addr_of!((*ptr).rand_deg) as usize - ptr as usize
2339 },
2340 28usize,
2341 concat!(
2342 "Offset of field: ",
2343 stringify!(random_data),
2344 "::",
2345 stringify!(rand_deg)
2346 )
2347 );
2348 }
2349 test_field_rand_deg();
2350 fn test_field_rand_sep() {
2351 assert_eq!(
2352 unsafe {
2353 let uninit = ::std::mem::MaybeUninit::<random_data>::uninit();
2354 let ptr = uninit.as_ptr();
2355 ::std::ptr::addr_of!((*ptr).rand_sep) as usize - ptr as usize
2356 },
2357 32usize,
2358 concat!(
2359 "Offset of field: ",
2360 stringify!(random_data),
2361 "::",
2362 stringify!(rand_sep)
2363 )
2364 );
2365 }
2366 test_field_rand_sep();
2367 fn test_field_end_ptr() {
2368 assert_eq!(
2369 unsafe {
2370 let uninit = ::std::mem::MaybeUninit::<random_data>::uninit();
2371 let ptr = uninit.as_ptr();
2372 ::std::ptr::addr_of!((*ptr).end_ptr) as usize - ptr as usize
2373 },
2374 40usize,
2375 concat!(
2376 "Offset of field: ",
2377 stringify!(random_data),
2378 "::",
2379 stringify!(end_ptr)
2380 )
2381 );
2382 }
2383 test_field_end_ptr();
2384}
2385extern "C" {
2386 pub fn random_r(__buf: *mut random_data, __result: *mut i32) -> ::std::os::raw::c_int;
2387}
2388extern "C" {
2389 pub fn srandom_r(
2390 __seed: ::std::os::raw::c_uint,
2391 __buf: *mut random_data,
2392 ) -> ::std::os::raw::c_int;
2393}
2394extern "C" {
2395 pub fn initstate_r(
2396 __seed: ::std::os::raw::c_uint,
2397 __statebuf: *mut ::std::os::raw::c_char,
2398 __statelen: size_t,
2399 __buf: *mut random_data,
2400 ) -> ::std::os::raw::c_int;
2401}
2402extern "C" {
2403 pub fn setstate_r(
2404 __statebuf: *mut ::std::os::raw::c_char,
2405 __buf: *mut random_data,
2406 ) -> ::std::os::raw::c_int;
2407}
2408extern "C" {
2409 pub fn rand() -> ::std::os::raw::c_int;
2410}
2411extern "C" {
2412 pub fn srand(__seed: ::std::os::raw::c_uint);
2413}
2414extern "C" {
2415 pub fn rand_r(__seed: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
2416}
2417extern "C" {
2418 pub fn drand48() -> f64;
2419}
2420extern "C" {
2421 pub fn erand48(__xsubi: *mut ::std::os::raw::c_ushort) -> f64;
2422}
2423extern "C" {
2424 pub fn lrand48() -> ::std::os::raw::c_long;
2425}
2426extern "C" {
2427 pub fn nrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
2428}
2429extern "C" {
2430 pub fn mrand48() -> ::std::os::raw::c_long;
2431}
2432extern "C" {
2433 pub fn jrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
2434}
2435extern "C" {
2436 pub fn srand48(__seedval: ::std::os::raw::c_long);
2437}
2438extern "C" {
2439 pub fn seed48(__seed16v: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
2440}
2441extern "C" {
2442 pub fn lcong48(__param: *mut ::std::os::raw::c_ushort);
2443}
2444#[repr(C)]
2445#[derive(Debug, Copy, Clone)]
2446pub struct drand48_data {
2447 pub __x: [::std::os::raw::c_ushort; 3usize],
2448 pub __old_x: [::std::os::raw::c_ushort; 3usize],
2449 pub __c: ::std::os::raw::c_ushort,
2450 pub __init: ::std::os::raw::c_ushort,
2451 pub __a: ::std::os::raw::c_ulonglong,
2452}
2453#[test]
2454fn bindgen_test_layout_drand48_data() {
2455 assert_eq!(
2456 ::std::mem::size_of::<drand48_data>(),
2457 24usize,
2458 concat!("Size of: ", stringify!(drand48_data))
2459 );
2460 assert_eq!(
2461 ::std::mem::align_of::<drand48_data>(),
2462 8usize,
2463 concat!("Alignment of ", stringify!(drand48_data))
2464 );
2465 fn test_field___x() {
2466 assert_eq!(
2467 unsafe {
2468 let uninit = ::std::mem::MaybeUninit::<drand48_data>::uninit();
2469 let ptr = uninit.as_ptr();
2470 ::std::ptr::addr_of!((*ptr).__x) as usize - ptr as usize
2471 },
2472 0usize,
2473 concat!(
2474 "Offset of field: ",
2475 stringify!(drand48_data),
2476 "::",
2477 stringify!(__x)
2478 )
2479 );
2480 }
2481 test_field___x();
2482 fn test_field___old_x() {
2483 assert_eq!(
2484 unsafe {
2485 let uninit = ::std::mem::MaybeUninit::<drand48_data>::uninit();
2486 let ptr = uninit.as_ptr();
2487 ::std::ptr::addr_of!((*ptr).__old_x) as usize - ptr as usize
2488 },
2489 6usize,
2490 concat!(
2491 "Offset of field: ",
2492 stringify!(drand48_data),
2493 "::",
2494 stringify!(__old_x)
2495 )
2496 );
2497 }
2498 test_field___old_x();
2499 fn test_field___c() {
2500 assert_eq!(
2501 unsafe {
2502 let uninit = ::std::mem::MaybeUninit::<drand48_data>::uninit();
2503 let ptr = uninit.as_ptr();
2504 ::std::ptr::addr_of!((*ptr).__c) as usize - ptr as usize
2505 },
2506 12usize,
2507 concat!(
2508 "Offset of field: ",
2509 stringify!(drand48_data),
2510 "::",
2511 stringify!(__c)
2512 )
2513 );
2514 }
2515 test_field___c();
2516 fn test_field___init() {
2517 assert_eq!(
2518 unsafe {
2519 let uninit = ::std::mem::MaybeUninit::<drand48_data>::uninit();
2520 let ptr = uninit.as_ptr();
2521 ::std::ptr::addr_of!((*ptr).__init) as usize - ptr as usize
2522 },
2523 14usize,
2524 concat!(
2525 "Offset of field: ",
2526 stringify!(drand48_data),
2527 "::",
2528 stringify!(__init)
2529 )
2530 );
2531 }
2532 test_field___init();
2533 fn test_field___a() {
2534 assert_eq!(
2535 unsafe {
2536 let uninit = ::std::mem::MaybeUninit::<drand48_data>::uninit();
2537 let ptr = uninit.as_ptr();
2538 ::std::ptr::addr_of!((*ptr).__a) as usize - ptr as usize
2539 },
2540 16usize,
2541 concat!(
2542 "Offset of field: ",
2543 stringify!(drand48_data),
2544 "::",
2545 stringify!(__a)
2546 )
2547 );
2548 }
2549 test_field___a();
2550}
2551extern "C" {
2552 pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64) -> ::std::os::raw::c_int;
2553}
2554extern "C" {
2555 pub fn erand48_r(
2556 __xsubi: *mut ::std::os::raw::c_ushort,
2557 __buffer: *mut drand48_data,
2558 __result: *mut f64,
2559 ) -> ::std::os::raw::c_int;
2560}
2561extern "C" {
2562 pub fn lrand48_r(
2563 __buffer: *mut drand48_data,
2564 __result: *mut ::std::os::raw::c_long,
2565 ) -> ::std::os::raw::c_int;
2566}
2567extern "C" {
2568 pub fn nrand48_r(
2569 __xsubi: *mut ::std::os::raw::c_ushort,
2570 __buffer: *mut drand48_data,
2571 __result: *mut ::std::os::raw::c_long,
2572 ) -> ::std::os::raw::c_int;
2573}
2574extern "C" {
2575 pub fn mrand48_r(
2576 __buffer: *mut drand48_data,
2577 __result: *mut ::std::os::raw::c_long,
2578 ) -> ::std::os::raw::c_int;
2579}
2580extern "C" {
2581 pub fn jrand48_r(
2582 __xsubi: *mut ::std::os::raw::c_ushort,
2583 __buffer: *mut drand48_data,
2584 __result: *mut ::std::os::raw::c_long,
2585 ) -> ::std::os::raw::c_int;
2586}
2587extern "C" {
2588 pub fn srand48_r(
2589 __seedval: ::std::os::raw::c_long,
2590 __buffer: *mut drand48_data,
2591 ) -> ::std::os::raw::c_int;
2592}
2593extern "C" {
2594 pub fn seed48_r(
2595 __seed16v: *mut ::std::os::raw::c_ushort,
2596 __buffer: *mut drand48_data,
2597 ) -> ::std::os::raw::c_int;
2598}
2599extern "C" {
2600 pub fn lcong48_r(
2601 __param: *mut ::std::os::raw::c_ushort,
2602 __buffer: *mut drand48_data,
2603 ) -> ::std::os::raw::c_int;
2604}
2605extern "C" {
2606 pub fn arc4random() -> __uint32_t;
2607}
2608extern "C" {
2609 pub fn arc4random_buf(__buf: *mut ::std::os::raw::c_void, __size: size_t);
2610}
2611extern "C" {
2612 pub fn arc4random_uniform(__upper_bound: __uint32_t) -> __uint32_t;
2613}
2614extern "C" {
2615 pub fn malloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
2616}
2617extern "C" {
2618 pub fn calloc(
2619 __nmemb: ::std::os::raw::c_ulong,
2620 __size: ::std::os::raw::c_ulong,
2621 ) -> *mut ::std::os::raw::c_void;
2622}
2623extern "C" {
2624 pub fn realloc(
2625 __ptr: *mut ::std::os::raw::c_void,
2626 __size: ::std::os::raw::c_ulong,
2627 ) -> *mut ::std::os::raw::c_void;
2628}
2629extern "C" {
2630 pub fn free(__ptr: *mut ::std::os::raw::c_void);
2631}
2632extern "C" {
2633 pub fn reallocarray(
2634 __ptr: *mut ::std::os::raw::c_void,
2635 __nmemb: size_t,
2636 __size: size_t,
2637 ) -> *mut ::std::os::raw::c_void;
2638}
2639extern "C" {
2640 pub fn alloca(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
2641}
2642extern "C" {
2643 pub fn valloc(__size: size_t) -> *mut ::std::os::raw::c_void;
2644}
2645extern "C" {
2646 pub fn posix_memalign(
2647 __memptr: *mut *mut ::std::os::raw::c_void,
2648 __alignment: size_t,
2649 __size: size_t,
2650 ) -> ::std::os::raw::c_int;
2651}
2652extern "C" {
2653 pub fn aligned_alloc(
2654 __alignment: ::std::os::raw::c_ulong,
2655 __size: ::std::os::raw::c_ulong,
2656 ) -> *mut ::std::os::raw::c_void;
2657}
2658extern "C" {
2659 pub fn abort();
2660}
2661extern "C" {
2662 pub fn atexit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
2663}
2664extern "C" {
2665 pub fn at_quick_exit(
2666 __func: ::std::option::Option<unsafe extern "C" fn()>,
2667 ) -> ::std::os::raw::c_int;
2668}
2669extern "C" {
2670 pub fn on_exit(
2671 __func: ::std::option::Option<
2672 unsafe extern "C" fn(
2673 __status: ::std::os::raw::c_int,
2674 __arg: *mut ::std::os::raw::c_void,
2675 ),
2676 >,
2677 __arg: *mut ::std::os::raw::c_void,
2678 ) -> ::std::os::raw::c_int;
2679}
2680extern "C" {
2681 pub fn exit(__status: ::std::os::raw::c_int);
2682}
2683extern "C" {
2684 pub fn quick_exit(__status: ::std::os::raw::c_int);
2685}
2686extern "C" {
2687 pub fn _Exit(__status: ::std::os::raw::c_int);
2688}
2689extern "C" {
2690 pub fn getenv(__name: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2691}
2692extern "C" {
2693 pub fn putenv(__string: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2694}
2695extern "C" {
2696 pub fn setenv(
2697 __name: *const ::std::os::raw::c_char,
2698 __value: *const ::std::os::raw::c_char,
2699 __replace: ::std::os::raw::c_int,
2700 ) -> ::std::os::raw::c_int;
2701}
2702extern "C" {
2703 pub fn unsetenv(__name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2704}
2705extern "C" {
2706 pub fn clearenv() -> ::std::os::raw::c_int;
2707}
2708extern "C" {
2709 pub fn mktemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2710}
2711extern "C" {
2712 pub fn mkstemp(__template: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2713}
2714extern "C" {
2715 pub fn mkstemps(
2716 __template: *mut ::std::os::raw::c_char,
2717 __suffixlen: ::std::os::raw::c_int,
2718 ) -> ::std::os::raw::c_int;
2719}
2720extern "C" {
2721 pub fn mkdtemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2722}
2723extern "C" {
2724 pub fn system(__command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2725}
2726extern "C" {
2727 pub fn realpath(
2728 __name: *const ::std::os::raw::c_char,
2729 __resolved: *mut ::std::os::raw::c_char,
2730 ) -> *mut ::std::os::raw::c_char;
2731}
2732pub type __compar_fn_t = ::std::option::Option<
2733 unsafe extern "C" fn(
2734 arg1: *const ::std::os::raw::c_void,
2735 arg2: *const ::std::os::raw::c_void,
2736 ) -> ::std::os::raw::c_int,
2737>;
2738extern "C" {
2739 pub fn bsearch(
2740 __key: *const ::std::os::raw::c_void,
2741 __base: *const ::std::os::raw::c_void,
2742 __nmemb: size_t,
2743 __size: size_t,
2744 __compar: __compar_fn_t,
2745 ) -> *mut ::std::os::raw::c_void;
2746}
2747extern "C" {
2748 pub fn qsort(
2749 __base: *mut ::std::os::raw::c_void,
2750 __nmemb: size_t,
2751 __size: size_t,
2752 __compar: __compar_fn_t,
2753 );
2754}
2755extern "C" {
2756 pub fn abs(__x: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2757}
2758extern "C" {
2759 pub fn labs(__x: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
2760}
2761extern "C" {
2762 pub fn llabs(__x: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
2763}
2764extern "C" {
2765 pub fn div(__numer: ::std::os::raw::c_int, __denom: ::std::os::raw::c_int) -> div_t;
2766}
2767extern "C" {
2768 pub fn ldiv(__numer: ::std::os::raw::c_long, __denom: ::std::os::raw::c_long) -> ldiv_t;
2769}
2770extern "C" {
2771 pub fn lldiv(
2772 __numer: ::std::os::raw::c_longlong,
2773 __denom: ::std::os::raw::c_longlong,
2774 ) -> lldiv_t;
2775}
2776extern "C" {
2777 pub fn ecvt(
2778 __value: f64,
2779 __ndigit: ::std::os::raw::c_int,
2780 __decpt: *mut ::std::os::raw::c_int,
2781 __sign: *mut ::std::os::raw::c_int,
2782 ) -> *mut ::std::os::raw::c_char;
2783}
2784extern "C" {
2785 pub fn fcvt(
2786 __value: f64,
2787 __ndigit: ::std::os::raw::c_int,
2788 __decpt: *mut ::std::os::raw::c_int,
2789 __sign: *mut ::std::os::raw::c_int,
2790 ) -> *mut ::std::os::raw::c_char;
2791}
2792extern "C" {
2793 pub fn gcvt(
2794 __value: f64,
2795 __ndigit: ::std::os::raw::c_int,
2796 __buf: *mut ::std::os::raw::c_char,
2797 ) -> *mut ::std::os::raw::c_char;
2798}
2799extern "C" {
2800 pub fn qecvt(
2801 __value: u128,
2802 __ndigit: ::std::os::raw::c_int,
2803 __decpt: *mut ::std::os::raw::c_int,
2804 __sign: *mut ::std::os::raw::c_int,
2805 ) -> *mut ::std::os::raw::c_char;
2806}
2807extern "C" {
2808 pub fn qfcvt(
2809 __value: u128,
2810 __ndigit: ::std::os::raw::c_int,
2811 __decpt: *mut ::std::os::raw::c_int,
2812 __sign: *mut ::std::os::raw::c_int,
2813 ) -> *mut ::std::os::raw::c_char;
2814}
2815extern "C" {
2816 pub fn qgcvt(
2817 __value: u128,
2818 __ndigit: ::std::os::raw::c_int,
2819 __buf: *mut ::std::os::raw::c_char,
2820 ) -> *mut ::std::os::raw::c_char;
2821}
2822extern "C" {
2823 pub fn ecvt_r(
2824 __value: f64,
2825 __ndigit: ::std::os::raw::c_int,
2826 __decpt: *mut ::std::os::raw::c_int,
2827 __sign: *mut ::std::os::raw::c_int,
2828 __buf: *mut ::std::os::raw::c_char,
2829 __len: size_t,
2830 ) -> ::std::os::raw::c_int;
2831}
2832extern "C" {
2833 pub fn fcvt_r(
2834 __value: f64,
2835 __ndigit: ::std::os::raw::c_int,
2836 __decpt: *mut ::std::os::raw::c_int,
2837 __sign: *mut ::std::os::raw::c_int,
2838 __buf: *mut ::std::os::raw::c_char,
2839 __len: size_t,
2840 ) -> ::std::os::raw::c_int;
2841}
2842extern "C" {
2843 pub fn qecvt_r(
2844 __value: u128,
2845 __ndigit: ::std::os::raw::c_int,
2846 __decpt: *mut ::std::os::raw::c_int,
2847 __sign: *mut ::std::os::raw::c_int,
2848 __buf: *mut ::std::os::raw::c_char,
2849 __len: size_t,
2850 ) -> ::std::os::raw::c_int;
2851}
2852extern "C" {
2853 pub fn qfcvt_r(
2854 __value: u128,
2855 __ndigit: ::std::os::raw::c_int,
2856 __decpt: *mut ::std::os::raw::c_int,
2857 __sign: *mut ::std::os::raw::c_int,
2858 __buf: *mut ::std::os::raw::c_char,
2859 __len: size_t,
2860 ) -> ::std::os::raw::c_int;
2861}
2862extern "C" {
2863 pub fn mblen(__s: *const ::std::os::raw::c_char, __n: size_t) -> ::std::os::raw::c_int;
2864}
2865extern "C" {
2866 pub fn mbtowc(
2867 __pwc: *mut wchar_t,
2868 __s: *const ::std::os::raw::c_char,
2869 __n: size_t,
2870 ) -> ::std::os::raw::c_int;
2871}
2872extern "C" {
2873 pub fn wctomb(__s: *mut ::std::os::raw::c_char, __wchar: wchar_t) -> ::std::os::raw::c_int;
2874}
2875extern "C" {
2876 pub fn mbstowcs(
2877 __pwcs: *mut wchar_t,
2878 __s: *const ::std::os::raw::c_char,
2879 __n: size_t,
2880 ) -> size_t;
2881}
2882extern "C" {
2883 pub fn wcstombs(
2884 __s: *mut ::std::os::raw::c_char,
2885 __pwcs: *const wchar_t,
2886 __n: size_t,
2887 ) -> size_t;
2888}
2889extern "C" {
2890 pub fn rpmatch(__response: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2891}
2892extern "C" {
2893 pub fn getsubopt(
2894 __optionp: *mut *mut ::std::os::raw::c_char,
2895 __tokens: *const *mut ::std::os::raw::c_char,
2896 __valuep: *mut *mut ::std::os::raw::c_char,
2897 ) -> ::std::os::raw::c_int;
2898}
2899extern "C" {
2900 pub fn getloadavg(__loadavg: *mut f64, __nelem: ::std::os::raw::c_int)
2901 -> ::std::os::raw::c_int;
2902}
2903pub type mono_bool = i32;
2904pub type mono_byte = u8;
2905pub type MonoBoolean = mono_byte;
2906pub type mono_unichar2 = u16;
2907pub type mono_unichar4 = u32;
2908pub type MonoFunc = ::std::option::Option<
2909 unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, user_data: *mut ::std::os::raw::c_void),
2910>;
2911pub type MonoHFunc = ::std::option::Option<
2912 unsafe extern "C" fn(
2913 key: *mut ::std::os::raw::c_void,
2914 value: *mut ::std::os::raw::c_void,
2915 user_data: *mut ::std::os::raw::c_void,
2916 ),
2917>;
2918extern "C" {
2919 pub fn mono_free(arg1: *mut ::std::os::raw::c_void);
2920}
2921#[repr(C)]
2922#[derive(Debug, Copy, Clone)]
2923pub struct MonoAllocatorVTable {
2924 pub version: ::std::os::raw::c_int,
2925 pub malloc:
2926 ::std::option::Option<unsafe extern "C" fn(size: size_t) -> *mut ::std::os::raw::c_void>,
2927 pub realloc: ::std::option::Option<
2928 unsafe extern "C" fn(
2929 mem: *mut ::std::os::raw::c_void,
2930 count: size_t,
2931 ) -> *mut ::std::os::raw::c_void,
2932 >,
2933 pub free: ::std::option::Option<unsafe extern "C" fn(mem: *mut ::std::os::raw::c_void)>,
2934 pub calloc: ::std::option::Option<
2935 unsafe extern "C" fn(count: size_t, size: size_t) -> *mut ::std::os::raw::c_void,
2936 >,
2937}
2938#[test]
2939fn bindgen_test_layout_MonoAllocatorVTable() {
2940 assert_eq!(
2941 ::std::mem::size_of::<MonoAllocatorVTable>(),
2942 40usize,
2943 concat!("Size of: ", stringify!(MonoAllocatorVTable))
2944 );
2945 assert_eq!(
2946 ::std::mem::align_of::<MonoAllocatorVTable>(),
2947 8usize,
2948 concat!("Alignment of ", stringify!(MonoAllocatorVTable))
2949 );
2950 fn test_field_version() {
2951 assert_eq!(
2952 unsafe {
2953 let uninit = ::std::mem::MaybeUninit::<MonoAllocatorVTable>::uninit();
2954 let ptr = uninit.as_ptr();
2955 ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize
2956 },
2957 0usize,
2958 concat!(
2959 "Offset of field: ",
2960 stringify!(MonoAllocatorVTable),
2961 "::",
2962 stringify!(version)
2963 )
2964 );
2965 }
2966 test_field_version();
2967 fn test_field_malloc() {
2968 assert_eq!(
2969 unsafe {
2970 let uninit = ::std::mem::MaybeUninit::<MonoAllocatorVTable>::uninit();
2971 let ptr = uninit.as_ptr();
2972 ::std::ptr::addr_of!((*ptr).malloc) as usize - ptr as usize
2973 },
2974 8usize,
2975 concat!(
2976 "Offset of field: ",
2977 stringify!(MonoAllocatorVTable),
2978 "::",
2979 stringify!(malloc)
2980 )
2981 );
2982 }
2983 test_field_malloc();
2984 fn test_field_realloc() {
2985 assert_eq!(
2986 unsafe {
2987 let uninit = ::std::mem::MaybeUninit::<MonoAllocatorVTable>::uninit();
2988 let ptr = uninit.as_ptr();
2989 ::std::ptr::addr_of!((*ptr).realloc) as usize - ptr as usize
2990 },
2991 16usize,
2992 concat!(
2993 "Offset of field: ",
2994 stringify!(MonoAllocatorVTable),
2995 "::",
2996 stringify!(realloc)
2997 )
2998 );
2999 }
3000 test_field_realloc();
3001 fn test_field_free() {
3002 assert_eq!(
3003 unsafe {
3004 let uninit = ::std::mem::MaybeUninit::<MonoAllocatorVTable>::uninit();
3005 let ptr = uninit.as_ptr();
3006 ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize
3007 },
3008 24usize,
3009 concat!(
3010 "Offset of field: ",
3011 stringify!(MonoAllocatorVTable),
3012 "::",
3013 stringify!(free)
3014 )
3015 );
3016 }
3017 test_field_free();
3018 fn test_field_calloc() {
3019 assert_eq!(
3020 unsafe {
3021 let uninit = ::std::mem::MaybeUninit::<MonoAllocatorVTable>::uninit();
3022 let ptr = uninit.as_ptr();
3023 ::std::ptr::addr_of!((*ptr).calloc) as usize - ptr as usize
3024 },
3025 32usize,
3026 concat!(
3027 "Offset of field: ",
3028 stringify!(MonoAllocatorVTable),
3029 "::",
3030 stringify!(calloc)
3031 )
3032 );
3033 }
3034 test_field_calloc();
3035}
3036extern "C" {
3037 pub fn mono_set_allocator_vtable(vtable: *mut MonoAllocatorVTable) -> mono_bool;
3038}
3039#[repr(C)]
3040#[derive(Debug, Copy, Clone)]
3041pub struct _MonoDomain {
3042 _unused: [u8; 0],
3043}
3044pub type MonoDomain = _MonoDomain;
3045#[repr(C)]
3046#[derive(Debug, Copy, Clone)]
3047pub struct _MonoJitInfo {
3048 _unused: [u8; 0],
3049}
3050pub type MonoJitInfo = _MonoJitInfo;
3051#[repr(C)]
3052#[derive(Debug, Copy, Clone)]
3053pub struct _MonoClass {
3054 _unused: [u8; 0],
3055}
3056pub type MonoClass = _MonoClass;
3057#[repr(C)]
3058#[derive(Debug, Copy, Clone)]
3059pub struct _MonoImage {
3060 _unused: [u8; 0],
3061}
3062pub type MonoImage = _MonoImage;
3063#[repr(C)]
3064#[derive(Debug, Copy, Clone)]
3065pub struct _MonoMethod {
3066 _unused: [u8; 0],
3067}
3068pub type MonoMethod = _MonoMethod;
3069pub type MonoObject = _MonoObject;
3070#[repr(C)]
3071#[derive(Debug, Copy, Clone)]
3072pub struct _MonoException {
3073 _unused: [u8; 0],
3074}
3075pub type MonoException = _MonoException;
3076#[repr(C)]
3077#[derive(Debug, Copy, Clone)]
3078pub struct _MonoReflectionAssembly {
3079 _unused: [u8; 0],
3080}
3081pub type MonoReflectionAssembly = _MonoReflectionAssembly;
3082#[repr(C)]
3083#[derive(Debug, Copy, Clone)]
3084pub struct _MonoReflectionTypeBuilder {
3085 _unused: [u8; 0],
3086}
3087pub type MonoReflectionTypeBuilder = _MonoReflectionTypeBuilder;
3088pub const MonoTypeEnum_MONO_TYPE_END: MonoTypeEnum = 0;
3089pub const MonoTypeEnum_MONO_TYPE_VOID: MonoTypeEnum = 1;
3090pub const MonoTypeEnum_MONO_TYPE_BOOLEAN: MonoTypeEnum = 2;
3091pub const MonoTypeEnum_MONO_TYPE_CHAR: MonoTypeEnum = 3;
3092pub const MonoTypeEnum_MONO_TYPE_I1: MonoTypeEnum = 4;
3093pub const MonoTypeEnum_MONO_TYPE_U1: MonoTypeEnum = 5;
3094pub const MonoTypeEnum_MONO_TYPE_I2: MonoTypeEnum = 6;
3095pub const MonoTypeEnum_MONO_TYPE_U2: MonoTypeEnum = 7;
3096pub const MonoTypeEnum_MONO_TYPE_I4: MonoTypeEnum = 8;
3097pub const MonoTypeEnum_MONO_TYPE_U4: MonoTypeEnum = 9;
3098pub const MonoTypeEnum_MONO_TYPE_I8: MonoTypeEnum = 10;
3099pub const MonoTypeEnum_MONO_TYPE_U8: MonoTypeEnum = 11;
3100pub const MonoTypeEnum_MONO_TYPE_R4: MonoTypeEnum = 12;
3101pub const MonoTypeEnum_MONO_TYPE_R8: MonoTypeEnum = 13;
3102pub const MonoTypeEnum_MONO_TYPE_STRING: MonoTypeEnum = 14;
3103pub const MonoTypeEnum_MONO_TYPE_PTR: MonoTypeEnum = 15;
3104pub const MonoTypeEnum_MONO_TYPE_BYREF: MonoTypeEnum = 16;
3105pub const MonoTypeEnum_MONO_TYPE_VALUETYPE: MonoTypeEnum = 17;
3106pub const MonoTypeEnum_MONO_TYPE_CLASS: MonoTypeEnum = 18;
3107pub const MonoTypeEnum_MONO_TYPE_VAR: MonoTypeEnum = 19;
3108pub const MonoTypeEnum_MONO_TYPE_ARRAY: MonoTypeEnum = 20;
3109pub const MonoTypeEnum_MONO_TYPE_GENERICINST: MonoTypeEnum = 21;
3110pub const MonoTypeEnum_MONO_TYPE_TYPEDBYREF: MonoTypeEnum = 22;
3111pub const MonoTypeEnum_MONO_TYPE_I: MonoTypeEnum = 24;
3112pub const MonoTypeEnum_MONO_TYPE_U: MonoTypeEnum = 25;
3113pub const MonoTypeEnum_MONO_TYPE_FNPTR: MonoTypeEnum = 27;
3114pub const MonoTypeEnum_MONO_TYPE_OBJECT: MonoTypeEnum = 28;
3115pub const MonoTypeEnum_MONO_TYPE_SZARRAY: MonoTypeEnum = 29;
3116pub const MonoTypeEnum_MONO_TYPE_MVAR: MonoTypeEnum = 30;
3117pub const MonoTypeEnum_MONO_TYPE_CMOD_REQD: MonoTypeEnum = 31;
3118pub const MonoTypeEnum_MONO_TYPE_CMOD_OPT: MonoTypeEnum = 32;
3119pub const MonoTypeEnum_MONO_TYPE_INTERNAL: MonoTypeEnum = 33;
3120pub const MonoTypeEnum_MONO_TYPE_MODIFIER: MonoTypeEnum = 64;
3121pub const MonoTypeEnum_MONO_TYPE_SENTINEL: MonoTypeEnum = 65;
3122pub const MonoTypeEnum_MONO_TYPE_PINNED: MonoTypeEnum = 69;
3123pub const MonoTypeEnum_MONO_TYPE_ENUM: MonoTypeEnum = 85;
3124pub type MonoTypeEnum = ::std::os::raw::c_uint;
3125pub const MonoMetaTableEnum_MONO_TABLE_MODULE: MonoMetaTableEnum = 0;
3126pub const MonoMetaTableEnum_MONO_TABLE_TYPEREF: MonoMetaTableEnum = 1;
3127pub const MonoMetaTableEnum_MONO_TABLE_TYPEDEF: MonoMetaTableEnum = 2;
3128pub const MonoMetaTableEnum_MONO_TABLE_FIELD_POINTER: MonoMetaTableEnum = 3;
3129pub const MonoMetaTableEnum_MONO_TABLE_FIELD: MonoMetaTableEnum = 4;
3130pub const MonoMetaTableEnum_MONO_TABLE_METHOD_POINTER: MonoMetaTableEnum = 5;
3131pub const MonoMetaTableEnum_MONO_TABLE_METHOD: MonoMetaTableEnum = 6;
3132pub const MonoMetaTableEnum_MONO_TABLE_PARAM_POINTER: MonoMetaTableEnum = 7;
3133pub const MonoMetaTableEnum_MONO_TABLE_PARAM: MonoMetaTableEnum = 8;
3134pub const MonoMetaTableEnum_MONO_TABLE_INTERFACEIMPL: MonoMetaTableEnum = 9;
3135pub const MonoMetaTableEnum_MONO_TABLE_MEMBERREF: MonoMetaTableEnum = 10;
3136pub const MonoMetaTableEnum_MONO_TABLE_CONSTANT: MonoMetaTableEnum = 11;
3137pub const MonoMetaTableEnum_MONO_TABLE_CUSTOMATTRIBUTE: MonoMetaTableEnum = 12;
3138pub const MonoMetaTableEnum_MONO_TABLE_FIELDMARSHAL: MonoMetaTableEnum = 13;
3139pub const MonoMetaTableEnum_MONO_TABLE_DECLSECURITY: MonoMetaTableEnum = 14;
3140pub const MonoMetaTableEnum_MONO_TABLE_CLASSLAYOUT: MonoMetaTableEnum = 15;
3141pub const MonoMetaTableEnum_MONO_TABLE_FIELDLAYOUT: MonoMetaTableEnum = 16;
3142pub const MonoMetaTableEnum_MONO_TABLE_STANDALONESIG: MonoMetaTableEnum = 17;
3143pub const MonoMetaTableEnum_MONO_TABLE_EVENTMAP: MonoMetaTableEnum = 18;
3144pub const MonoMetaTableEnum_MONO_TABLE_EVENT_POINTER: MonoMetaTableEnum = 19;
3145pub const MonoMetaTableEnum_MONO_TABLE_EVENT: MonoMetaTableEnum = 20;
3146pub const MonoMetaTableEnum_MONO_TABLE_PROPERTYMAP: MonoMetaTableEnum = 21;
3147pub const MonoMetaTableEnum_MONO_TABLE_PROPERTY_POINTER: MonoMetaTableEnum = 22;
3148pub const MonoMetaTableEnum_MONO_TABLE_PROPERTY: MonoMetaTableEnum = 23;
3149pub const MonoMetaTableEnum_MONO_TABLE_METHODSEMANTICS: MonoMetaTableEnum = 24;
3150pub const MonoMetaTableEnum_MONO_TABLE_METHODIMPL: MonoMetaTableEnum = 25;
3151pub const MonoMetaTableEnum_MONO_TABLE_MODULEREF: MonoMetaTableEnum = 26;
3152pub const MonoMetaTableEnum_MONO_TABLE_TYPESPEC: MonoMetaTableEnum = 27;
3153pub const MonoMetaTableEnum_MONO_TABLE_IMPLMAP: MonoMetaTableEnum = 28;
3154pub const MonoMetaTableEnum_MONO_TABLE_FIELDRVA: MonoMetaTableEnum = 29;
3155pub const MonoMetaTableEnum_MONO_TABLE_UNUSED6: MonoMetaTableEnum = 30;
3156pub const MonoMetaTableEnum_MONO_TABLE_UNUSED7: MonoMetaTableEnum = 31;
3157pub const MonoMetaTableEnum_MONO_TABLE_ASSEMBLY: MonoMetaTableEnum = 32;
3158pub const MonoMetaTableEnum_MONO_TABLE_ASSEMBLYPROCESSOR: MonoMetaTableEnum = 33;
3159pub const MonoMetaTableEnum_MONO_TABLE_ASSEMBLYOS: MonoMetaTableEnum = 34;
3160pub const MonoMetaTableEnum_MONO_TABLE_ASSEMBLYREF: MonoMetaTableEnum = 35;
3161pub const MonoMetaTableEnum_MONO_TABLE_ASSEMBLYREFPROCESSOR: MonoMetaTableEnum = 36;
3162pub const MonoMetaTableEnum_MONO_TABLE_ASSEMBLYREFOS: MonoMetaTableEnum = 37;
3163pub const MonoMetaTableEnum_MONO_TABLE_FILE: MonoMetaTableEnum = 38;
3164pub const MonoMetaTableEnum_MONO_TABLE_EXPORTEDTYPE: MonoMetaTableEnum = 39;
3165pub const MonoMetaTableEnum_MONO_TABLE_MANIFESTRESOURCE: MonoMetaTableEnum = 40;
3166pub const MonoMetaTableEnum_MONO_TABLE_NESTEDCLASS: MonoMetaTableEnum = 41;
3167pub const MonoMetaTableEnum_MONO_TABLE_GENERICPARAM: MonoMetaTableEnum = 42;
3168pub const MonoMetaTableEnum_MONO_TABLE_METHODSPEC: MonoMetaTableEnum = 43;
3169pub const MonoMetaTableEnum_MONO_TABLE_GENERICPARAMCONSTRAINT: MonoMetaTableEnum = 44;
3170pub const MonoMetaTableEnum_MONO_TABLE_UNUSED8: MonoMetaTableEnum = 45;
3171pub const MonoMetaTableEnum_MONO_TABLE_UNUSED9: MonoMetaTableEnum = 46;
3172pub const MonoMetaTableEnum_MONO_TABLE_UNUSED10: MonoMetaTableEnum = 47;
3173pub const MonoMetaTableEnum_MONO_TABLE_DOCUMENT: MonoMetaTableEnum = 48;
3174pub const MonoMetaTableEnum_MONO_TABLE_METHODBODY: MonoMetaTableEnum = 49;
3175pub const MonoMetaTableEnum_MONO_TABLE_LOCALSCOPE: MonoMetaTableEnum = 50;
3176pub const MonoMetaTableEnum_MONO_TABLE_LOCALVARIABLE: MonoMetaTableEnum = 51;
3177pub const MonoMetaTableEnum_MONO_TABLE_LOCALCONSTANT: MonoMetaTableEnum = 52;
3178pub const MonoMetaTableEnum_MONO_TABLE_IMPORTSCOPE: MonoMetaTableEnum = 53;
3179pub const MonoMetaTableEnum_MONO_TABLE_STATEMACHINEMETHOD: MonoMetaTableEnum = 54;
3180pub const MonoMetaTableEnum_MONO_TABLE_CUSTOMDEBUGINFORMATION: MonoMetaTableEnum = 55;
3181pub type MonoMetaTableEnum = ::std::os::raw::c_uint;
3182pub const MONO_ASSEMBLY_HASH_ALG: _bindgen_ty_1 = 0;
3183pub const MONO_ASSEMBLY_MAJOR_VERSION: _bindgen_ty_1 = 1;
3184pub const MONO_ASSEMBLY_MINOR_VERSION: _bindgen_ty_1 = 2;
3185pub const MONO_ASSEMBLY_BUILD_NUMBER: _bindgen_ty_1 = 3;
3186pub const MONO_ASSEMBLY_REV_NUMBER: _bindgen_ty_1 = 4;
3187pub const MONO_ASSEMBLY_FLAGS: _bindgen_ty_1 = 5;
3188pub const MONO_ASSEMBLY_PUBLIC_KEY: _bindgen_ty_1 = 6;
3189pub const MONO_ASSEMBLY_NAME: _bindgen_ty_1 = 7;
3190pub const MONO_ASSEMBLY_CULTURE: _bindgen_ty_1 = 8;
3191pub const MONO_ASSEMBLY_SIZE: _bindgen_ty_1 = 9;
3192pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
3193pub const MONO_ASSEMBLYOS_PLATFORM: _bindgen_ty_2 = 0;
3194pub const MONO_ASSEMBLYOS_MAJOR_VERSION: _bindgen_ty_2 = 1;
3195pub const MONO_ASSEMBLYOS_MINOR_VERSION: _bindgen_ty_2 = 2;
3196pub const MONO_ASSEMBLYOS_SIZE: _bindgen_ty_2 = 3;
3197pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
3198pub const MONO_ASSEMBLY_PROCESSOR: _bindgen_ty_3 = 0;
3199pub const MONO_ASSEMBLY_PROCESSOR_SIZE: _bindgen_ty_3 = 1;
3200pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
3201pub const MONO_ASSEMBLYREF_MAJOR_VERSION: _bindgen_ty_4 = 0;
3202pub const MONO_ASSEMBLYREF_MINOR_VERSION: _bindgen_ty_4 = 1;
3203pub const MONO_ASSEMBLYREF_BUILD_NUMBER: _bindgen_ty_4 = 2;
3204pub const MONO_ASSEMBLYREF_REV_NUMBER: _bindgen_ty_4 = 3;
3205pub const MONO_ASSEMBLYREF_FLAGS: _bindgen_ty_4 = 4;
3206pub const MONO_ASSEMBLYREF_PUBLIC_KEY: _bindgen_ty_4 = 5;
3207pub const MONO_ASSEMBLYREF_NAME: _bindgen_ty_4 = 6;
3208pub const MONO_ASSEMBLYREF_CULTURE: _bindgen_ty_4 = 7;
3209pub const MONO_ASSEMBLYREF_HASH_VALUE: _bindgen_ty_4 = 8;
3210pub const MONO_ASSEMBLYREF_SIZE: _bindgen_ty_4 = 9;
3211pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
3212pub const MONO_ASSEMBLYREFOS_PLATFORM: _bindgen_ty_5 = 0;
3213pub const MONO_ASSEMBLYREFOS_MAJOR_VERSION: _bindgen_ty_5 = 1;
3214pub const MONO_ASSEMBLYREFOS_MINOR_VERSION: _bindgen_ty_5 = 2;
3215pub const MONO_ASSEMBLYREFOS_ASSEMBLYREF: _bindgen_ty_5 = 3;
3216pub const MONO_ASSEMBLYREFOS_SIZE: _bindgen_ty_5 = 4;
3217pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
3218pub const MONO_ASSEMBLYREFPROC_PROCESSOR: _bindgen_ty_6 = 0;
3219pub const MONO_ASSEMBLYREFPROC_ASSEMBLYREF: _bindgen_ty_6 = 1;
3220pub const MONO_ASSEMBLYREFPROC_SIZE: _bindgen_ty_6 = 2;
3221pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
3222pub const MONO_CLASS_LAYOUT_PACKING_SIZE: _bindgen_ty_7 = 0;
3223pub const MONO_CLASS_LAYOUT_CLASS_SIZE: _bindgen_ty_7 = 1;
3224pub const MONO_CLASS_LAYOUT_PARENT: _bindgen_ty_7 = 2;
3225pub const MONO_CLASS_LAYOUT_SIZE: _bindgen_ty_7 = 3;
3226pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
3227pub const MONO_CONSTANT_TYPE: _bindgen_ty_8 = 0;
3228pub const MONO_CONSTANT_PADDING: _bindgen_ty_8 = 1;
3229pub const MONO_CONSTANT_PARENT: _bindgen_ty_8 = 2;
3230pub const MONO_CONSTANT_VALUE: _bindgen_ty_8 = 3;
3231pub const MONO_CONSTANT_SIZE: _bindgen_ty_8 = 4;
3232pub type _bindgen_ty_8 = ::std::os::raw::c_uint;
3233pub const MONO_CUSTOM_ATTR_PARENT: _bindgen_ty_9 = 0;
3234pub const MONO_CUSTOM_ATTR_TYPE: _bindgen_ty_9 = 1;
3235pub const MONO_CUSTOM_ATTR_VALUE: _bindgen_ty_9 = 2;
3236pub const MONO_CUSTOM_ATTR_SIZE: _bindgen_ty_9 = 3;
3237pub type _bindgen_ty_9 = ::std::os::raw::c_uint;
3238pub const MONO_DECL_SECURITY_ACTION: _bindgen_ty_10 = 0;
3239pub const MONO_DECL_SECURITY_PARENT: _bindgen_ty_10 = 1;
3240pub const MONO_DECL_SECURITY_PERMISSIONSET: _bindgen_ty_10 = 2;
3241pub const MONO_DECL_SECURITY_SIZE: _bindgen_ty_10 = 3;
3242pub type _bindgen_ty_10 = ::std::os::raw::c_uint;
3243pub const MONO_EVENT_MAP_PARENT: _bindgen_ty_11 = 0;
3244pub const MONO_EVENT_MAP_EVENTLIST: _bindgen_ty_11 = 1;
3245pub const MONO_EVENT_MAP_SIZE: _bindgen_ty_11 = 2;
3246pub type _bindgen_ty_11 = ::std::os::raw::c_uint;
3247pub const MONO_EVENT_FLAGS: _bindgen_ty_12 = 0;
3248pub const MONO_EVENT_NAME: _bindgen_ty_12 = 1;
3249pub const MONO_EVENT_TYPE: _bindgen_ty_12 = 2;
3250pub const MONO_EVENT_SIZE: _bindgen_ty_12 = 3;
3251pub type _bindgen_ty_12 = ::std::os::raw::c_uint;
3252pub const MONO_EVENT_POINTER_EVENT: _bindgen_ty_13 = 0;
3253pub const MONO_EVENT_POINTER_SIZE: _bindgen_ty_13 = 1;
3254pub type _bindgen_ty_13 = ::std::os::raw::c_uint;
3255pub const MONO_EXP_TYPE_FLAGS: _bindgen_ty_14 = 0;
3256pub const MONO_EXP_TYPE_TYPEDEF: _bindgen_ty_14 = 1;
3257pub const MONO_EXP_TYPE_NAME: _bindgen_ty_14 = 2;
3258pub const MONO_EXP_TYPE_NAMESPACE: _bindgen_ty_14 = 3;
3259pub const MONO_EXP_TYPE_IMPLEMENTATION: _bindgen_ty_14 = 4;
3260pub const MONO_EXP_TYPE_SIZE: _bindgen_ty_14 = 5;
3261pub type _bindgen_ty_14 = ::std::os::raw::c_uint;
3262pub const MONO_FIELD_FLAGS: _bindgen_ty_15 = 0;
3263pub const MONO_FIELD_NAME: _bindgen_ty_15 = 1;
3264pub const MONO_FIELD_SIGNATURE: _bindgen_ty_15 = 2;
3265pub const MONO_FIELD_SIZE: _bindgen_ty_15 = 3;
3266pub type _bindgen_ty_15 = ::std::os::raw::c_uint;
3267pub const MONO_FIELD_LAYOUT_OFFSET: _bindgen_ty_16 = 0;
3268pub const MONO_FIELD_LAYOUT_FIELD: _bindgen_ty_16 = 1;
3269pub const MONO_FIELD_LAYOUT_SIZE: _bindgen_ty_16 = 2;
3270pub type _bindgen_ty_16 = ::std::os::raw::c_uint;
3271pub const MONO_FIELD_MARSHAL_PARENT: _bindgen_ty_17 = 0;
3272pub const MONO_FIELD_MARSHAL_NATIVE_TYPE: _bindgen_ty_17 = 1;
3273pub const MONO_FIELD_MARSHAL_SIZE: _bindgen_ty_17 = 2;
3274pub type _bindgen_ty_17 = ::std::os::raw::c_uint;
3275pub const MONO_FIELD_POINTER_FIELD: _bindgen_ty_18 = 0;
3276pub const MONO_FIELD_POINTER_SIZE: _bindgen_ty_18 = 1;
3277pub type _bindgen_ty_18 = ::std::os::raw::c_uint;
3278pub const MONO_FIELD_RVA_RVA: _bindgen_ty_19 = 0;
3279pub const MONO_FIELD_RVA_FIELD: _bindgen_ty_19 = 1;
3280pub const MONO_FIELD_RVA_SIZE: _bindgen_ty_19 = 2;
3281pub type _bindgen_ty_19 = ::std::os::raw::c_uint;
3282pub const MONO_FILE_FLAGS: _bindgen_ty_20 = 0;
3283pub const MONO_FILE_NAME: _bindgen_ty_20 = 1;
3284pub const MONO_FILE_HASH_VALUE: _bindgen_ty_20 = 2;
3285pub const MONO_FILE_SIZE: _bindgen_ty_20 = 3;
3286pub type _bindgen_ty_20 = ::std::os::raw::c_uint;
3287pub const MONO_IMPLMAP_FLAGS: _bindgen_ty_21 = 0;
3288pub const MONO_IMPLMAP_MEMBER: _bindgen_ty_21 = 1;
3289pub const MONO_IMPLMAP_NAME: _bindgen_ty_21 = 2;
3290pub const MONO_IMPLMAP_SCOPE: _bindgen_ty_21 = 3;
3291pub const MONO_IMPLMAP_SIZE: _bindgen_ty_21 = 4;
3292pub type _bindgen_ty_21 = ::std::os::raw::c_uint;
3293pub const MONO_INTERFACEIMPL_CLASS: _bindgen_ty_22 = 0;
3294pub const MONO_INTERFACEIMPL_INTERFACE: _bindgen_ty_22 = 1;
3295pub const MONO_INTERFACEIMPL_SIZE: _bindgen_ty_22 = 2;
3296pub type _bindgen_ty_22 = ::std::os::raw::c_uint;
3297pub const MONO_MANIFEST_OFFSET: _bindgen_ty_23 = 0;
3298pub const MONO_MANIFEST_FLAGS: _bindgen_ty_23 = 1;
3299pub const MONO_MANIFEST_NAME: _bindgen_ty_23 = 2;
3300pub const MONO_MANIFEST_IMPLEMENTATION: _bindgen_ty_23 = 3;
3301pub const MONO_MANIFEST_SIZE: _bindgen_ty_23 = 4;
3302pub type _bindgen_ty_23 = ::std::os::raw::c_uint;
3303pub const MONO_MEMBERREF_CLASS: _bindgen_ty_24 = 0;
3304pub const MONO_MEMBERREF_NAME: _bindgen_ty_24 = 1;
3305pub const MONO_MEMBERREF_SIGNATURE: _bindgen_ty_24 = 2;
3306pub const MONO_MEMBERREF_SIZE: _bindgen_ty_24 = 3;
3307pub type _bindgen_ty_24 = ::std::os::raw::c_uint;
3308pub const MONO_METHOD_RVA: _bindgen_ty_25 = 0;
3309pub const MONO_METHOD_IMPLFLAGS: _bindgen_ty_25 = 1;
3310pub const MONO_METHOD_FLAGS: _bindgen_ty_25 = 2;
3311pub const MONO_METHOD_NAME: _bindgen_ty_25 = 3;
3312pub const MONO_METHOD_SIGNATURE: _bindgen_ty_25 = 4;
3313pub const MONO_METHOD_PARAMLIST: _bindgen_ty_25 = 5;
3314pub const MONO_METHOD_SIZE: _bindgen_ty_25 = 6;
3315pub type _bindgen_ty_25 = ::std::os::raw::c_uint;
3316pub const MONO_METHODIMPL_CLASS: _bindgen_ty_26 = 0;
3317pub const MONO_METHODIMPL_BODY: _bindgen_ty_26 = 1;
3318pub const MONO_METHODIMPL_DECLARATION: _bindgen_ty_26 = 2;
3319pub const MONO_METHODIMPL_SIZE: _bindgen_ty_26 = 3;
3320pub type _bindgen_ty_26 = ::std::os::raw::c_uint;
3321pub const MONO_METHOD_POINTER_METHOD: _bindgen_ty_27 = 0;
3322pub const MONO_METHOD_POINTER_SIZE: _bindgen_ty_27 = 1;
3323pub type _bindgen_ty_27 = ::std::os::raw::c_uint;
3324pub const MONO_METHOD_SEMA_SEMANTICS: _bindgen_ty_28 = 0;
3325pub const MONO_METHOD_SEMA_METHOD: _bindgen_ty_28 = 1;
3326pub const MONO_METHOD_SEMA_ASSOCIATION: _bindgen_ty_28 = 2;
3327pub const MONO_METHOD_SEMA_SIZE: _bindgen_ty_28 = 3;
3328pub type _bindgen_ty_28 = ::std::os::raw::c_uint;
3329pub const MONO_MODULE_GENERATION: _bindgen_ty_29 = 0;
3330pub const MONO_MODULE_NAME: _bindgen_ty_29 = 1;
3331pub const MONO_MODULE_MVID: _bindgen_ty_29 = 2;
3332pub const MONO_MODULE_ENC: _bindgen_ty_29 = 3;
3333pub const MONO_MODULE_ENCBASE: _bindgen_ty_29 = 4;
3334pub const MONO_MODULE_SIZE: _bindgen_ty_29 = 5;
3335pub type _bindgen_ty_29 = ::std::os::raw::c_uint;
3336pub const MONO_MODULEREF_NAME: _bindgen_ty_30 = 0;
3337pub const MONO_MODULEREF_SIZE: _bindgen_ty_30 = 1;
3338pub type _bindgen_ty_30 = ::std::os::raw::c_uint;
3339pub const MONO_NESTED_CLASS_NESTED: _bindgen_ty_31 = 0;
3340pub const MONO_NESTED_CLASS_ENCLOSING: _bindgen_ty_31 = 1;
3341pub const MONO_NESTED_CLASS_SIZE: _bindgen_ty_31 = 2;
3342pub type _bindgen_ty_31 = ::std::os::raw::c_uint;
3343pub const MONO_PARAM_FLAGS: _bindgen_ty_32 = 0;
3344pub const MONO_PARAM_SEQUENCE: _bindgen_ty_32 = 1;
3345pub const MONO_PARAM_NAME: _bindgen_ty_32 = 2;
3346pub const MONO_PARAM_SIZE: _bindgen_ty_32 = 3;
3347pub type _bindgen_ty_32 = ::std::os::raw::c_uint;
3348pub const MONO_PARAM_POINTER_PARAM: _bindgen_ty_33 = 0;
3349pub const MONO_PARAM_POINTER_SIZE: _bindgen_ty_33 = 1;
3350pub type _bindgen_ty_33 = ::std::os::raw::c_uint;
3351pub const MONO_PROPERTY_FLAGS: _bindgen_ty_34 = 0;
3352pub const MONO_PROPERTY_NAME: _bindgen_ty_34 = 1;
3353pub const MONO_PROPERTY_TYPE: _bindgen_ty_34 = 2;
3354pub const MONO_PROPERTY_SIZE: _bindgen_ty_34 = 3;
3355pub type _bindgen_ty_34 = ::std::os::raw::c_uint;
3356pub const MONO_PROPERTY_POINTER_PROPERTY: _bindgen_ty_35 = 0;
3357pub const MONO_PROPERTY_POINTER_SIZE: _bindgen_ty_35 = 1;
3358pub type _bindgen_ty_35 = ::std::os::raw::c_uint;
3359pub const MONO_PROPERTY_MAP_PARENT: _bindgen_ty_36 = 0;
3360pub const MONO_PROPERTY_MAP_PROPERTY_LIST: _bindgen_ty_36 = 1;
3361pub const MONO_PROPERTY_MAP_SIZE: _bindgen_ty_36 = 2;
3362pub type _bindgen_ty_36 = ::std::os::raw::c_uint;
3363pub const MONO_STAND_ALONE_SIGNATURE: _bindgen_ty_37 = 0;
3364pub const MONO_STAND_ALONE_SIGNATURE_SIZE: _bindgen_ty_37 = 1;
3365pub type _bindgen_ty_37 = ::std::os::raw::c_uint;
3366pub const MONO_TYPEDEF_FLAGS: _bindgen_ty_38 = 0;
3367pub const MONO_TYPEDEF_NAME: _bindgen_ty_38 = 1;
3368pub const MONO_TYPEDEF_NAMESPACE: _bindgen_ty_38 = 2;
3369pub const MONO_TYPEDEF_EXTENDS: _bindgen_ty_38 = 3;
3370pub const MONO_TYPEDEF_FIELD_LIST: _bindgen_ty_38 = 4;
3371pub const MONO_TYPEDEF_METHOD_LIST: _bindgen_ty_38 = 5;
3372pub const MONO_TYPEDEF_SIZE: _bindgen_ty_38 = 6;
3373pub type _bindgen_ty_38 = ::std::os::raw::c_uint;
3374pub const MONO_TYPEREF_SCOPE: _bindgen_ty_39 = 0;
3375pub const MONO_TYPEREF_NAME: _bindgen_ty_39 = 1;
3376pub const MONO_TYPEREF_NAMESPACE: _bindgen_ty_39 = 2;
3377pub const MONO_TYPEREF_SIZE: _bindgen_ty_39 = 3;
3378pub type _bindgen_ty_39 = ::std::os::raw::c_uint;
3379pub const MONO_TYPESPEC_SIGNATURE: _bindgen_ty_40 = 0;
3380pub const MONO_TYPESPEC_SIZE: _bindgen_ty_40 = 1;
3381pub type _bindgen_ty_40 = ::std::os::raw::c_uint;
3382pub const MONO_GENERICPARAM_NUMBER: _bindgen_ty_41 = 0;
3383pub const MONO_GENERICPARAM_FLAGS: _bindgen_ty_41 = 1;
3384pub const MONO_GENERICPARAM_OWNER: _bindgen_ty_41 = 2;
3385pub const MONO_GENERICPARAM_NAME: _bindgen_ty_41 = 3;
3386pub const MONO_GENERICPARAM_SIZE: _bindgen_ty_41 = 4;
3387pub type _bindgen_ty_41 = ::std::os::raw::c_uint;
3388pub const MONO_METHODSPEC_METHOD: _bindgen_ty_42 = 0;
3389pub const MONO_METHODSPEC_SIGNATURE: _bindgen_ty_42 = 1;
3390pub const MONO_METHODSPEC_SIZE: _bindgen_ty_42 = 2;
3391pub type _bindgen_ty_42 = ::std::os::raw::c_uint;
3392pub const MONO_GENPARCONSTRAINT_GENERICPAR: _bindgen_ty_43 = 0;
3393pub const MONO_GENPARCONSTRAINT_CONSTRAINT: _bindgen_ty_43 = 1;
3394pub const MONO_GENPARCONSTRAINT_SIZE: _bindgen_ty_43 = 2;
3395pub type _bindgen_ty_43 = ::std::os::raw::c_uint;
3396pub const MONO_DOCUMENT_NAME: _bindgen_ty_44 = 0;
3397pub const MONO_DOCUMENT_HASHALG: _bindgen_ty_44 = 1;
3398pub const MONO_DOCUMENT_HASH: _bindgen_ty_44 = 2;
3399pub const MONO_DOCUMENT_LANGUAGE: _bindgen_ty_44 = 3;
3400pub const MONO_DOCUMENT_SIZE: _bindgen_ty_44 = 4;
3401pub type _bindgen_ty_44 = ::std::os::raw::c_uint;
3402pub const MONO_METHODBODY_DOCUMENT: _bindgen_ty_45 = 0;
3403pub const MONO_METHODBODY_SEQ_POINTS: _bindgen_ty_45 = 1;
3404pub const MONO_METHODBODY_SIZE: _bindgen_ty_45 = 2;
3405pub type _bindgen_ty_45 = ::std::os::raw::c_uint;
3406pub const MONO_LOCALSCOPE_METHOD: _bindgen_ty_46 = 0;
3407pub const MONO_LOCALSCOPE_IMPORTSCOPE: _bindgen_ty_46 = 1;
3408pub const MONO_LOCALSCOPE_VARIABLELIST: _bindgen_ty_46 = 2;
3409pub const MONO_LOCALSCOPE_CONSTANTLIST: _bindgen_ty_46 = 3;
3410pub const MONO_LOCALSCOPE_STARTOFFSET: _bindgen_ty_46 = 4;
3411pub const MONO_LOCALSCOPE_LENGTH: _bindgen_ty_46 = 5;
3412pub const MONO_LOCALSCOPE_SIZE: _bindgen_ty_46 = 6;
3413pub type _bindgen_ty_46 = ::std::os::raw::c_uint;
3414pub const MONO_LOCALVARIABLE_ATTRIBUTES: _bindgen_ty_47 = 0;
3415pub const MONO_LOCALVARIABLE_INDEX: _bindgen_ty_47 = 1;
3416pub const MONO_LOCALVARIABLE_NAME: _bindgen_ty_47 = 2;
3417pub const MONO_LOCALVARIABLE_SIZE: _bindgen_ty_47 = 3;
3418pub type _bindgen_ty_47 = ::std::os::raw::c_uint;
3419pub const MONO_CUSTOMDEBUGINFORMATION_PARENT: _bindgen_ty_48 = 0;
3420pub const MONO_CUSTOMDEBUGINFORMATION_KIND: _bindgen_ty_48 = 1;
3421pub const MONO_CUSTOMDEBUGINFORMATION_VALUE: _bindgen_ty_48 = 2;
3422pub const MONO_CUSTOMDEBUGINFORMATION_SIZE: _bindgen_ty_48 = 3;
3423pub type _bindgen_ty_48 = ::std::os::raw::c_uint;
3424pub const MONO_TYPEDEFORREF_TYPEDEF: _bindgen_ty_49 = 0;
3425pub const MONO_TYPEDEFORREF_TYPEREF: _bindgen_ty_49 = 1;
3426pub const MONO_TYPEDEFORREF_TYPESPEC: _bindgen_ty_49 = 2;
3427pub const MONO_TYPEDEFORREF_BITS: _bindgen_ty_49 = 2;
3428pub const MONO_TYPEDEFORREF_MASK: _bindgen_ty_49 = 3;
3429pub type _bindgen_ty_49 = ::std::os::raw::c_uint;
3430pub const MONO_HASCONSTANT_FIEDDEF: _bindgen_ty_50 = 0;
3431pub const MONO_HASCONSTANT_PARAM: _bindgen_ty_50 = 1;
3432pub const MONO_HASCONSTANT_PROPERTY: _bindgen_ty_50 = 2;
3433pub const MONO_HASCONSTANT_BITS: _bindgen_ty_50 = 2;
3434pub const MONO_HASCONSTANT_MASK: _bindgen_ty_50 = 3;
3435pub type _bindgen_ty_50 = ::std::os::raw::c_uint;
3436pub const MONO_CUSTOM_ATTR_METHODDEF: _bindgen_ty_51 = 0;
3437pub const MONO_CUSTOM_ATTR_FIELDDEF: _bindgen_ty_51 = 1;
3438pub const MONO_CUSTOM_ATTR_TYPEREF: _bindgen_ty_51 = 2;
3439pub const MONO_CUSTOM_ATTR_TYPEDEF: _bindgen_ty_51 = 3;
3440pub const MONO_CUSTOM_ATTR_PARAMDEF: _bindgen_ty_51 = 4;
3441pub const MONO_CUSTOM_ATTR_INTERFACE: _bindgen_ty_51 = 5;
3442pub const MONO_CUSTOM_ATTR_MEMBERREF: _bindgen_ty_51 = 6;
3443pub const MONO_CUSTOM_ATTR_MODULE: _bindgen_ty_51 = 7;
3444pub const MONO_CUSTOM_ATTR_PERMISSION: _bindgen_ty_51 = 8;
3445pub const MONO_CUSTOM_ATTR_PROPERTY: _bindgen_ty_51 = 9;
3446pub const MONO_CUSTOM_ATTR_EVENT: _bindgen_ty_51 = 10;
3447pub const MONO_CUSTOM_ATTR_SIGNATURE: _bindgen_ty_51 = 11;
3448pub const MONO_CUSTOM_ATTR_MODULEREF: _bindgen_ty_51 = 12;
3449pub const MONO_CUSTOM_ATTR_TYPESPEC: _bindgen_ty_51 = 13;
3450pub const MONO_CUSTOM_ATTR_ASSEMBLY: _bindgen_ty_51 = 14;
3451pub const MONO_CUSTOM_ATTR_ASSEMBLYREF: _bindgen_ty_51 = 15;
3452pub const MONO_CUSTOM_ATTR_FILE: _bindgen_ty_51 = 16;
3453pub const MONO_CUSTOM_ATTR_EXP_TYPE: _bindgen_ty_51 = 17;
3454pub const MONO_CUSTOM_ATTR_MANIFEST: _bindgen_ty_51 = 18;
3455pub const MONO_CUSTOM_ATTR_GENERICPAR: _bindgen_ty_51 = 19;
3456pub const MONO_CUSTOM_ATTR_GENERICPARAMCONSTRAINT: _bindgen_ty_51 = 20;
3457pub const MONO_CUSTOM_ATTR_BITS: _bindgen_ty_51 = 5;
3458pub const MONO_CUSTOM_ATTR_MASK: _bindgen_ty_51 = 31;
3459pub type _bindgen_ty_51 = ::std::os::raw::c_uint;
3460pub const MONO_HAS_FIELD_MARSHAL_FIELDSREF: _bindgen_ty_52 = 0;
3461pub const MONO_HAS_FIELD_MARSHAL_PARAMDEF: _bindgen_ty_52 = 1;
3462pub const MONO_HAS_FIELD_MARSHAL_BITS: _bindgen_ty_52 = 1;
3463pub const MONO_HAS_FIELD_MARSHAL_MASK: _bindgen_ty_52 = 1;
3464pub type _bindgen_ty_52 = ::std::os::raw::c_uint;
3465pub const MONO_HAS_DECL_SECURITY_TYPEDEF: _bindgen_ty_53 = 0;
3466pub const MONO_HAS_DECL_SECURITY_METHODDEF: _bindgen_ty_53 = 1;
3467pub const MONO_HAS_DECL_SECURITY_ASSEMBLY: _bindgen_ty_53 = 2;
3468pub const MONO_HAS_DECL_SECURITY_BITS: _bindgen_ty_53 = 2;
3469pub const MONO_HAS_DECL_SECURITY_MASK: _bindgen_ty_53 = 3;
3470pub type _bindgen_ty_53 = ::std::os::raw::c_uint;
3471pub const MONO_MEMBERREF_PARENT_TYPEDEF: _bindgen_ty_54 = 0;
3472pub const MONO_MEMBERREF_PARENT_TYPEREF: _bindgen_ty_54 = 1;
3473pub const MONO_MEMBERREF_PARENT_MODULEREF: _bindgen_ty_54 = 2;
3474pub const MONO_MEMBERREF_PARENT_METHODDEF: _bindgen_ty_54 = 3;
3475pub const MONO_MEMBERREF_PARENT_TYPESPEC: _bindgen_ty_54 = 4;
3476pub const MONO_MEMBERREF_PARENT_BITS: _bindgen_ty_54 = 3;
3477pub const MONO_MEMBERREF_PARENT_MASK: _bindgen_ty_54 = 7;
3478pub type _bindgen_ty_54 = ::std::os::raw::c_uint;
3479pub const MONO_HAS_SEMANTICS_EVENT: _bindgen_ty_55 = 0;
3480pub const MONO_HAS_SEMANTICS_PROPERTY: _bindgen_ty_55 = 1;
3481pub const MONO_HAS_SEMANTICS_BITS: _bindgen_ty_55 = 1;
3482pub const MONO_HAS_SEMANTICS_MASK: _bindgen_ty_55 = 1;
3483pub type _bindgen_ty_55 = ::std::os::raw::c_uint;
3484pub const MONO_METHODDEFORREF_METHODDEF: _bindgen_ty_56 = 0;
3485pub const MONO_METHODDEFORREF_METHODREF: _bindgen_ty_56 = 1;
3486pub const MONO_METHODDEFORREF_BITS: _bindgen_ty_56 = 1;
3487pub const MONO_METHODDEFORREF_MASK: _bindgen_ty_56 = 1;
3488pub type _bindgen_ty_56 = ::std::os::raw::c_uint;
3489pub const MONO_MEMBERFORWD_FIELDDEF: _bindgen_ty_57 = 0;
3490pub const MONO_MEMBERFORWD_METHODDEF: _bindgen_ty_57 = 1;
3491pub const MONO_MEMBERFORWD_BITS: _bindgen_ty_57 = 1;
3492pub const MONO_MEMBERFORWD_MASK: _bindgen_ty_57 = 1;
3493pub type _bindgen_ty_57 = ::std::os::raw::c_uint;
3494pub const MONO_IMPLEMENTATION_FILE: _bindgen_ty_58 = 0;
3495pub const MONO_IMPLEMENTATION_ASSEMBLYREF: _bindgen_ty_58 = 1;
3496pub const MONO_IMPLEMENTATION_EXP_TYPE: _bindgen_ty_58 = 2;
3497pub const MONO_IMPLEMENTATION_BITS: _bindgen_ty_58 = 2;
3498pub const MONO_IMPLEMENTATION_MASK: _bindgen_ty_58 = 3;
3499pub type _bindgen_ty_58 = ::std::os::raw::c_uint;
3500pub const MONO_CUSTOM_ATTR_TYPE_TYPEREF: _bindgen_ty_59 = 0;
3501pub const MONO_CUSTOM_ATTR_TYPE_TYPEDEF: _bindgen_ty_59 = 1;
3502pub const MONO_CUSTOM_ATTR_TYPE_METHODDEF: _bindgen_ty_59 = 2;
3503pub const MONO_CUSTOM_ATTR_TYPE_MEMBERREF: _bindgen_ty_59 = 3;
3504pub const MONO_CUSTOM_ATTR_TYPE_STRING: _bindgen_ty_59 = 4;
3505pub const MONO_CUSTOM_ATTR_TYPE_BITS: _bindgen_ty_59 = 3;
3506pub const MONO_CUSTOM_ATTR_TYPE_MASK: _bindgen_ty_59 = 7;
3507pub type _bindgen_ty_59 = ::std::os::raw::c_uint;
3508pub const MONO_RESOLUTION_SCOPE_MODULE: _bindgen_ty_60 = 0;
3509pub const MONO_RESOLUTION_SCOPE_MODULEREF: _bindgen_ty_60 = 1;
3510pub const MONO_RESOLUTION_SCOPE_ASSEMBLYREF: _bindgen_ty_60 = 2;
3511pub const MONO_RESOLUTION_SCOPE_TYPEREF: _bindgen_ty_60 = 3;
3512pub const MONO_RESOLUTION_SCOPE_BITS: _bindgen_ty_60 = 2;
3513pub const MONO_RESOLUTION_SCOPE_MASK: _bindgen_ty_60 = 3;
3514pub type _bindgen_ty_60 = ::std::os::raw::c_uint;
3515pub const MONO_RESOLTION_SCOPE_MODULE: _bindgen_ty_61 = 0;
3516pub const MONO_RESOLTION_SCOPE_MODULEREF: _bindgen_ty_61 = 1;
3517pub const MONO_RESOLTION_SCOPE_ASSEMBLYREF: _bindgen_ty_61 = 2;
3518pub const MONO_RESOLTION_SCOPE_TYPEREF: _bindgen_ty_61 = 3;
3519pub const MONO_RESOLTION_SCOPE_BITS: _bindgen_ty_61 = 2;
3520pub const MONO_RESOLTION_SCOPE_MASK: _bindgen_ty_61 = 3;
3521pub type _bindgen_ty_61 = ::std::os::raw::c_uint;
3522pub const MONO_TYPEORMETHOD_TYPE: _bindgen_ty_62 = 0;
3523pub const MONO_TYPEORMETHOD_METHOD: _bindgen_ty_62 = 1;
3524pub const MONO_TYPEORMETHOD_BITS: _bindgen_ty_62 = 1;
3525pub const MONO_TYPEORMETHOD_MASK: _bindgen_ty_62 = 1;
3526pub type _bindgen_ty_62 = ::std::os::raw::c_uint;
3527pub type va_list = __builtin_va_list;
3528pub type __gnuc_va_list = __builtin_va_list;
3529#[repr(C)]
3530#[derive(Copy, Clone)]
3531pub struct __mbstate_t {
3532 pub __count: ::std::os::raw::c_int,
3533 pub __value: __mbstate_t__bindgen_ty_1,
3534}
3535#[repr(C)]
3536#[derive(Copy, Clone)]
3537pub union __mbstate_t__bindgen_ty_1 {
3538 pub __wch: ::std::os::raw::c_uint,
3539 pub __wchb: [::std::os::raw::c_char; 4usize],
3540}
3541#[test]
3542fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
3543 assert_eq!(
3544 ::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
3545 4usize,
3546 concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
3547 );
3548 assert_eq!(
3549 ::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
3550 4usize,
3551 concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
3552 );
3553 fn test_field___wch() {
3554 assert_eq!(
3555 unsafe {
3556 let uninit = ::std::mem::MaybeUninit::<__mbstate_t__bindgen_ty_1>::uninit();
3557 let ptr = uninit.as_ptr();
3558 ::std::ptr::addr_of!((*ptr).__wch) as usize - ptr as usize
3559 },
3560 0usize,
3561 concat!(
3562 "Offset of field: ",
3563 stringify!(__mbstate_t__bindgen_ty_1),
3564 "::",
3565 stringify!(__wch)
3566 )
3567 );
3568 }
3569 test_field___wch();
3570 fn test_field___wchb() {
3571 assert_eq!(
3572 unsafe {
3573 let uninit = ::std::mem::MaybeUninit::<__mbstate_t__bindgen_ty_1>::uninit();
3574 let ptr = uninit.as_ptr();
3575 ::std::ptr::addr_of!((*ptr).__wchb) as usize - ptr as usize
3576 },
3577 0usize,
3578 concat!(
3579 "Offset of field: ",
3580 stringify!(__mbstate_t__bindgen_ty_1),
3581 "::",
3582 stringify!(__wchb)
3583 )
3584 );
3585 }
3586 test_field___wchb();
3587}
3588#[test]
3589fn bindgen_test_layout___mbstate_t() {
3590 assert_eq!(
3591 ::std::mem::size_of::<__mbstate_t>(),
3592 8usize,
3593 concat!("Size of: ", stringify!(__mbstate_t))
3594 );
3595 assert_eq!(
3596 ::std::mem::align_of::<__mbstate_t>(),
3597 4usize,
3598 concat!("Alignment of ", stringify!(__mbstate_t))
3599 );
3600 fn test_field___count() {
3601 assert_eq!(
3602 unsafe {
3603 let uninit = ::std::mem::MaybeUninit::<__mbstate_t>::uninit();
3604 let ptr = uninit.as_ptr();
3605 ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize
3606 },
3607 0usize,
3608 concat!(
3609 "Offset of field: ",
3610 stringify!(__mbstate_t),
3611 "::",
3612 stringify!(__count)
3613 )
3614 );
3615 }
3616 test_field___count();
3617 fn test_field___value() {
3618 assert_eq!(
3619 unsafe {
3620 let uninit = ::std::mem::MaybeUninit::<__mbstate_t>::uninit();
3621 let ptr = uninit.as_ptr();
3622 ::std::ptr::addr_of!((*ptr).__value) as usize - ptr as usize
3623 },
3624 4usize,
3625 concat!(
3626 "Offset of field: ",
3627 stringify!(__mbstate_t),
3628 "::",
3629 stringify!(__value)
3630 )
3631 );
3632 }
3633 test_field___value();
3634}
3635#[repr(C)]
3636#[derive(Copy, Clone)]
3637pub struct _G_fpos_t {
3638 pub __pos: __off_t,
3639 pub __state: __mbstate_t,
3640}
3641#[test]
3642fn bindgen_test_layout__G_fpos_t() {
3643 assert_eq!(
3644 ::std::mem::size_of::<_G_fpos_t>(),
3645 16usize,
3646 concat!("Size of: ", stringify!(_G_fpos_t))
3647 );
3648 assert_eq!(
3649 ::std::mem::align_of::<_G_fpos_t>(),
3650 8usize,
3651 concat!("Alignment of ", stringify!(_G_fpos_t))
3652 );
3653 fn test_field___pos() {
3654 assert_eq!(
3655 unsafe {
3656 let uninit = ::std::mem::MaybeUninit::<_G_fpos_t>::uninit();
3657 let ptr = uninit.as_ptr();
3658 ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize
3659 },
3660 0usize,
3661 concat!(
3662 "Offset of field: ",
3663 stringify!(_G_fpos_t),
3664 "::",
3665 stringify!(__pos)
3666 )
3667 );
3668 }
3669 test_field___pos();
3670 fn test_field___state() {
3671 assert_eq!(
3672 unsafe {
3673 let uninit = ::std::mem::MaybeUninit::<_G_fpos_t>::uninit();
3674 let ptr = uninit.as_ptr();
3675 ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize
3676 },
3677 8usize,
3678 concat!(
3679 "Offset of field: ",
3680 stringify!(_G_fpos_t),
3681 "::",
3682 stringify!(__state)
3683 )
3684 );
3685 }
3686 test_field___state();
3687}
3688pub type __fpos_t = _G_fpos_t;
3689#[repr(C)]
3690#[derive(Copy, Clone)]
3691pub struct _G_fpos64_t {
3692 pub __pos: __off64_t,
3693 pub __state: __mbstate_t,
3694}
3695#[test]
3696fn bindgen_test_layout__G_fpos64_t() {
3697 assert_eq!(
3698 ::std::mem::size_of::<_G_fpos64_t>(),
3699 16usize,
3700 concat!("Size of: ", stringify!(_G_fpos64_t))
3701 );
3702 assert_eq!(
3703 ::std::mem::align_of::<_G_fpos64_t>(),
3704 8usize,
3705 concat!("Alignment of ", stringify!(_G_fpos64_t))
3706 );
3707 fn test_field___pos() {
3708 assert_eq!(
3709 unsafe {
3710 let uninit = ::std::mem::MaybeUninit::<_G_fpos64_t>::uninit();
3711 let ptr = uninit.as_ptr();
3712 ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize
3713 },
3714 0usize,
3715 concat!(
3716 "Offset of field: ",
3717 stringify!(_G_fpos64_t),
3718 "::",
3719 stringify!(__pos)
3720 )
3721 );
3722 }
3723 test_field___pos();
3724 fn test_field___state() {
3725 assert_eq!(
3726 unsafe {
3727 let uninit = ::std::mem::MaybeUninit::<_G_fpos64_t>::uninit();
3728 let ptr = uninit.as_ptr();
3729 ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize
3730 },
3731 8usize,
3732 concat!(
3733 "Offset of field: ",
3734 stringify!(_G_fpos64_t),
3735 "::",
3736 stringify!(__state)
3737 )
3738 );
3739 }
3740 test_field___state();
3741}
3742pub type __fpos64_t = _G_fpos64_t;
3743pub type __FILE = _IO_FILE;
3744pub type FILE = _IO_FILE;
3745#[repr(C)]
3746#[derive(Debug, Copy, Clone)]
3747pub struct _IO_marker {
3748 _unused: [u8; 0],
3749}
3750#[repr(C)]
3751#[derive(Debug, Copy, Clone)]
3752pub struct _IO_codecvt {
3753 _unused: [u8; 0],
3754}
3755#[repr(C)]
3756#[derive(Debug, Copy, Clone)]
3757pub struct _IO_wide_data {
3758 _unused: [u8; 0],
3759}
3760pub type _IO_lock_t = ::std::os::raw::c_void;
3761#[repr(C)]
3762#[derive(Debug, Copy, Clone)]
3763pub struct _IO_FILE {
3764 pub _flags: ::std::os::raw::c_int,
3765 pub _IO_read_ptr: *mut ::std::os::raw::c_char,
3766 pub _IO_read_end: *mut ::std::os::raw::c_char,
3767 pub _IO_read_base: *mut ::std::os::raw::c_char,
3768 pub _IO_write_base: *mut ::std::os::raw::c_char,
3769 pub _IO_write_ptr: *mut ::std::os::raw::c_char,
3770 pub _IO_write_end: *mut ::std::os::raw::c_char,
3771 pub _IO_buf_base: *mut ::std::os::raw::c_char,
3772 pub _IO_buf_end: *mut ::std::os::raw::c_char,
3773 pub _IO_save_base: *mut ::std::os::raw::c_char,
3774 pub _IO_backup_base: *mut ::std::os::raw::c_char,
3775 pub _IO_save_end: *mut ::std::os::raw::c_char,
3776 pub _markers: *mut _IO_marker,
3777 pub _chain: *mut _IO_FILE,
3778 pub _fileno: ::std::os::raw::c_int,
3779 pub _flags2: ::std::os::raw::c_int,
3780 pub _old_offset: __off_t,
3781 pub _cur_column: ::std::os::raw::c_ushort,
3782 pub _vtable_offset: ::std::os::raw::c_schar,
3783 pub _shortbuf: [::std::os::raw::c_char; 1usize],
3784 pub _lock: *mut _IO_lock_t,
3785 pub _offset: __off64_t,
3786 pub _codecvt: *mut _IO_codecvt,
3787 pub _wide_data: *mut _IO_wide_data,
3788 pub _freeres_list: *mut _IO_FILE,
3789 pub _freeres_buf: *mut ::std::os::raw::c_void,
3790 pub __pad5: size_t,
3791 pub _mode: ::std::os::raw::c_int,
3792 pub _unused2: [::std::os::raw::c_char; 20usize],
3793}
3794#[test]
3795fn bindgen_test_layout__IO_FILE() {
3796 assert_eq!(
3797 ::std::mem::size_of::<_IO_FILE>(),
3798 216usize,
3799 concat!("Size of: ", stringify!(_IO_FILE))
3800 );
3801 assert_eq!(
3802 ::std::mem::align_of::<_IO_FILE>(),
3803 8usize,
3804 concat!("Alignment of ", stringify!(_IO_FILE))
3805 );
3806 fn test_field__flags() {
3807 assert_eq!(
3808 unsafe {
3809 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3810 let ptr = uninit.as_ptr();
3811 ::std::ptr::addr_of!((*ptr)._flags) as usize - ptr as usize
3812 },
3813 0usize,
3814 concat!(
3815 "Offset of field: ",
3816 stringify!(_IO_FILE),
3817 "::",
3818 stringify!(_flags)
3819 )
3820 );
3821 }
3822 test_field__flags();
3823 fn test_field__IO_read_ptr() {
3824 assert_eq!(
3825 unsafe {
3826 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3827 let ptr = uninit.as_ptr();
3828 ::std::ptr::addr_of!((*ptr)._IO_read_ptr) as usize - ptr as usize
3829 },
3830 8usize,
3831 concat!(
3832 "Offset of field: ",
3833 stringify!(_IO_FILE),
3834 "::",
3835 stringify!(_IO_read_ptr)
3836 )
3837 );
3838 }
3839 test_field__IO_read_ptr();
3840 fn test_field__IO_read_end() {
3841 assert_eq!(
3842 unsafe {
3843 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3844 let ptr = uninit.as_ptr();
3845 ::std::ptr::addr_of!((*ptr)._IO_read_end) as usize - ptr as usize
3846 },
3847 16usize,
3848 concat!(
3849 "Offset of field: ",
3850 stringify!(_IO_FILE),
3851 "::",
3852 stringify!(_IO_read_end)
3853 )
3854 );
3855 }
3856 test_field__IO_read_end();
3857 fn test_field__IO_read_base() {
3858 assert_eq!(
3859 unsafe {
3860 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3861 let ptr = uninit.as_ptr();
3862 ::std::ptr::addr_of!((*ptr)._IO_read_base) as usize - ptr as usize
3863 },
3864 24usize,
3865 concat!(
3866 "Offset of field: ",
3867 stringify!(_IO_FILE),
3868 "::",
3869 stringify!(_IO_read_base)
3870 )
3871 );
3872 }
3873 test_field__IO_read_base();
3874 fn test_field__IO_write_base() {
3875 assert_eq!(
3876 unsafe {
3877 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3878 let ptr = uninit.as_ptr();
3879 ::std::ptr::addr_of!((*ptr)._IO_write_base) as usize - ptr as usize
3880 },
3881 32usize,
3882 concat!(
3883 "Offset of field: ",
3884 stringify!(_IO_FILE),
3885 "::",
3886 stringify!(_IO_write_base)
3887 )
3888 );
3889 }
3890 test_field__IO_write_base();
3891 fn test_field__IO_write_ptr() {
3892 assert_eq!(
3893 unsafe {
3894 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3895 let ptr = uninit.as_ptr();
3896 ::std::ptr::addr_of!((*ptr)._IO_write_ptr) as usize - ptr as usize
3897 },
3898 40usize,
3899 concat!(
3900 "Offset of field: ",
3901 stringify!(_IO_FILE),
3902 "::",
3903 stringify!(_IO_write_ptr)
3904 )
3905 );
3906 }
3907 test_field__IO_write_ptr();
3908 fn test_field__IO_write_end() {
3909 assert_eq!(
3910 unsafe {
3911 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3912 let ptr = uninit.as_ptr();
3913 ::std::ptr::addr_of!((*ptr)._IO_write_end) as usize - ptr as usize
3914 },
3915 48usize,
3916 concat!(
3917 "Offset of field: ",
3918 stringify!(_IO_FILE),
3919 "::",
3920 stringify!(_IO_write_end)
3921 )
3922 );
3923 }
3924 test_field__IO_write_end();
3925 fn test_field__IO_buf_base() {
3926 assert_eq!(
3927 unsafe {
3928 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3929 let ptr = uninit.as_ptr();
3930 ::std::ptr::addr_of!((*ptr)._IO_buf_base) as usize - ptr as usize
3931 },
3932 56usize,
3933 concat!(
3934 "Offset of field: ",
3935 stringify!(_IO_FILE),
3936 "::",
3937 stringify!(_IO_buf_base)
3938 )
3939 );
3940 }
3941 test_field__IO_buf_base();
3942 fn test_field__IO_buf_end() {
3943 assert_eq!(
3944 unsafe {
3945 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3946 let ptr = uninit.as_ptr();
3947 ::std::ptr::addr_of!((*ptr)._IO_buf_end) as usize - ptr as usize
3948 },
3949 64usize,
3950 concat!(
3951 "Offset of field: ",
3952 stringify!(_IO_FILE),
3953 "::",
3954 stringify!(_IO_buf_end)
3955 )
3956 );
3957 }
3958 test_field__IO_buf_end();
3959 fn test_field__IO_save_base() {
3960 assert_eq!(
3961 unsafe {
3962 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3963 let ptr = uninit.as_ptr();
3964 ::std::ptr::addr_of!((*ptr)._IO_save_base) as usize - ptr as usize
3965 },
3966 72usize,
3967 concat!(
3968 "Offset of field: ",
3969 stringify!(_IO_FILE),
3970 "::",
3971 stringify!(_IO_save_base)
3972 )
3973 );
3974 }
3975 test_field__IO_save_base();
3976 fn test_field__IO_backup_base() {
3977 assert_eq!(
3978 unsafe {
3979 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3980 let ptr = uninit.as_ptr();
3981 ::std::ptr::addr_of!((*ptr)._IO_backup_base) as usize - ptr as usize
3982 },
3983 80usize,
3984 concat!(
3985 "Offset of field: ",
3986 stringify!(_IO_FILE),
3987 "::",
3988 stringify!(_IO_backup_base)
3989 )
3990 );
3991 }
3992 test_field__IO_backup_base();
3993 fn test_field__IO_save_end() {
3994 assert_eq!(
3995 unsafe {
3996 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
3997 let ptr = uninit.as_ptr();
3998 ::std::ptr::addr_of!((*ptr)._IO_save_end) as usize - ptr as usize
3999 },
4000 88usize,
4001 concat!(
4002 "Offset of field: ",
4003 stringify!(_IO_FILE),
4004 "::",
4005 stringify!(_IO_save_end)
4006 )
4007 );
4008 }
4009 test_field__IO_save_end();
4010 fn test_field__markers() {
4011 assert_eq!(
4012 unsafe {
4013 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4014 let ptr = uninit.as_ptr();
4015 ::std::ptr::addr_of!((*ptr)._markers) as usize - ptr as usize
4016 },
4017 96usize,
4018 concat!(
4019 "Offset of field: ",
4020 stringify!(_IO_FILE),
4021 "::",
4022 stringify!(_markers)
4023 )
4024 );
4025 }
4026 test_field__markers();
4027 fn test_field__chain() {
4028 assert_eq!(
4029 unsafe {
4030 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4031 let ptr = uninit.as_ptr();
4032 ::std::ptr::addr_of!((*ptr)._chain) as usize - ptr as usize
4033 },
4034 104usize,
4035 concat!(
4036 "Offset of field: ",
4037 stringify!(_IO_FILE),
4038 "::",
4039 stringify!(_chain)
4040 )
4041 );
4042 }
4043 test_field__chain();
4044 fn test_field__fileno() {
4045 assert_eq!(
4046 unsafe {
4047 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4048 let ptr = uninit.as_ptr();
4049 ::std::ptr::addr_of!((*ptr)._fileno) as usize - ptr as usize
4050 },
4051 112usize,
4052 concat!(
4053 "Offset of field: ",
4054 stringify!(_IO_FILE),
4055 "::",
4056 stringify!(_fileno)
4057 )
4058 );
4059 }
4060 test_field__fileno();
4061 fn test_field__flags2() {
4062 assert_eq!(
4063 unsafe {
4064 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4065 let ptr = uninit.as_ptr();
4066 ::std::ptr::addr_of!((*ptr)._flags2) as usize - ptr as usize
4067 },
4068 116usize,
4069 concat!(
4070 "Offset of field: ",
4071 stringify!(_IO_FILE),
4072 "::",
4073 stringify!(_flags2)
4074 )
4075 );
4076 }
4077 test_field__flags2();
4078 fn test_field__old_offset() {
4079 assert_eq!(
4080 unsafe {
4081 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4082 let ptr = uninit.as_ptr();
4083 ::std::ptr::addr_of!((*ptr)._old_offset) as usize - ptr as usize
4084 },
4085 120usize,
4086 concat!(
4087 "Offset of field: ",
4088 stringify!(_IO_FILE),
4089 "::",
4090 stringify!(_old_offset)
4091 )
4092 );
4093 }
4094 test_field__old_offset();
4095 fn test_field__cur_column() {
4096 assert_eq!(
4097 unsafe {
4098 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4099 let ptr = uninit.as_ptr();
4100 ::std::ptr::addr_of!((*ptr)._cur_column) as usize - ptr as usize
4101 },
4102 128usize,
4103 concat!(
4104 "Offset of field: ",
4105 stringify!(_IO_FILE),
4106 "::",
4107 stringify!(_cur_column)
4108 )
4109 );
4110 }
4111 test_field__cur_column();
4112 fn test_field__vtable_offset() {
4113 assert_eq!(
4114 unsafe {
4115 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4116 let ptr = uninit.as_ptr();
4117 ::std::ptr::addr_of!((*ptr)._vtable_offset) as usize - ptr as usize
4118 },
4119 130usize,
4120 concat!(
4121 "Offset of field: ",
4122 stringify!(_IO_FILE),
4123 "::",
4124 stringify!(_vtable_offset)
4125 )
4126 );
4127 }
4128 test_field__vtable_offset();
4129 fn test_field__shortbuf() {
4130 assert_eq!(
4131 unsafe {
4132 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4133 let ptr = uninit.as_ptr();
4134 ::std::ptr::addr_of!((*ptr)._shortbuf) as usize - ptr as usize
4135 },
4136 131usize,
4137 concat!(
4138 "Offset of field: ",
4139 stringify!(_IO_FILE),
4140 "::",
4141 stringify!(_shortbuf)
4142 )
4143 );
4144 }
4145 test_field__shortbuf();
4146 fn test_field__lock() {
4147 assert_eq!(
4148 unsafe {
4149 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4150 let ptr = uninit.as_ptr();
4151 ::std::ptr::addr_of!((*ptr)._lock) as usize - ptr as usize
4152 },
4153 136usize,
4154 concat!(
4155 "Offset of field: ",
4156 stringify!(_IO_FILE),
4157 "::",
4158 stringify!(_lock)
4159 )
4160 );
4161 }
4162 test_field__lock();
4163 fn test_field__offset() {
4164 assert_eq!(
4165 unsafe {
4166 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4167 let ptr = uninit.as_ptr();
4168 ::std::ptr::addr_of!((*ptr)._offset) as usize - ptr as usize
4169 },
4170 144usize,
4171 concat!(
4172 "Offset of field: ",
4173 stringify!(_IO_FILE),
4174 "::",
4175 stringify!(_offset)
4176 )
4177 );
4178 }
4179 test_field__offset();
4180 fn test_field__codecvt() {
4181 assert_eq!(
4182 unsafe {
4183 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4184 let ptr = uninit.as_ptr();
4185 ::std::ptr::addr_of!((*ptr)._codecvt) as usize - ptr as usize
4186 },
4187 152usize,
4188 concat!(
4189 "Offset of field: ",
4190 stringify!(_IO_FILE),
4191 "::",
4192 stringify!(_codecvt)
4193 )
4194 );
4195 }
4196 test_field__codecvt();
4197 fn test_field__wide_data() {
4198 assert_eq!(
4199 unsafe {
4200 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4201 let ptr = uninit.as_ptr();
4202 ::std::ptr::addr_of!((*ptr)._wide_data) as usize - ptr as usize
4203 },
4204 160usize,
4205 concat!(
4206 "Offset of field: ",
4207 stringify!(_IO_FILE),
4208 "::",
4209 stringify!(_wide_data)
4210 )
4211 );
4212 }
4213 test_field__wide_data();
4214 fn test_field__freeres_list() {
4215 assert_eq!(
4216 unsafe {
4217 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4218 let ptr = uninit.as_ptr();
4219 ::std::ptr::addr_of!((*ptr)._freeres_list) as usize - ptr as usize
4220 },
4221 168usize,
4222 concat!(
4223 "Offset of field: ",
4224 stringify!(_IO_FILE),
4225 "::",
4226 stringify!(_freeres_list)
4227 )
4228 );
4229 }
4230 test_field__freeres_list();
4231 fn test_field__freeres_buf() {
4232 assert_eq!(
4233 unsafe {
4234 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4235 let ptr = uninit.as_ptr();
4236 ::std::ptr::addr_of!((*ptr)._freeres_buf) as usize - ptr as usize
4237 },
4238 176usize,
4239 concat!(
4240 "Offset of field: ",
4241 stringify!(_IO_FILE),
4242 "::",
4243 stringify!(_freeres_buf)
4244 )
4245 );
4246 }
4247 test_field__freeres_buf();
4248 fn test_field___pad5() {
4249 assert_eq!(
4250 unsafe {
4251 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4252 let ptr = uninit.as_ptr();
4253 ::std::ptr::addr_of!((*ptr).__pad5) as usize - ptr as usize
4254 },
4255 184usize,
4256 concat!(
4257 "Offset of field: ",
4258 stringify!(_IO_FILE),
4259 "::",
4260 stringify!(__pad5)
4261 )
4262 );
4263 }
4264 test_field___pad5();
4265 fn test_field__mode() {
4266 assert_eq!(
4267 unsafe {
4268 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4269 let ptr = uninit.as_ptr();
4270 ::std::ptr::addr_of!((*ptr)._mode) as usize - ptr as usize
4271 },
4272 192usize,
4273 concat!(
4274 "Offset of field: ",
4275 stringify!(_IO_FILE),
4276 "::",
4277 stringify!(_mode)
4278 )
4279 );
4280 }
4281 test_field__mode();
4282 fn test_field__unused2() {
4283 assert_eq!(
4284 unsafe {
4285 let uninit = ::std::mem::MaybeUninit::<_IO_FILE>::uninit();
4286 let ptr = uninit.as_ptr();
4287 ::std::ptr::addr_of!((*ptr)._unused2) as usize - ptr as usize
4288 },
4289 196usize,
4290 concat!(
4291 "Offset of field: ",
4292 stringify!(_IO_FILE),
4293 "::",
4294 stringify!(_unused2)
4295 )
4296 );
4297 }
4298 test_field__unused2();
4299}
4300pub type fpos_t = __fpos_t;
4301extern "C" {
4302 pub static mut stdin: *mut FILE;
4303}
4304extern "C" {
4305 pub static mut stdout: *mut FILE;
4306}
4307extern "C" {
4308 pub static mut stderr: *mut FILE;
4309}
4310extern "C" {
4311 pub fn remove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4312}
4313extern "C" {
4314 pub fn rename(
4315 __old: *const ::std::os::raw::c_char,
4316 __new: *const ::std::os::raw::c_char,
4317 ) -> ::std::os::raw::c_int;
4318}
4319extern "C" {
4320 pub fn renameat(
4321 __oldfd: ::std::os::raw::c_int,
4322 __old: *const ::std::os::raw::c_char,
4323 __newfd: ::std::os::raw::c_int,
4324 __new: *const ::std::os::raw::c_char,
4325 ) -> ::std::os::raw::c_int;
4326}
4327extern "C" {
4328 pub fn fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
4329}
4330extern "C" {
4331 pub fn tmpfile() -> *mut FILE;
4332}
4333extern "C" {
4334 pub fn tmpnam(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
4335}
4336extern "C" {
4337 pub fn tmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
4338}
4339extern "C" {
4340 pub fn tempnam(
4341 __dir: *const ::std::os::raw::c_char,
4342 __pfx: *const ::std::os::raw::c_char,
4343 ) -> *mut ::std::os::raw::c_char;
4344}
4345extern "C" {
4346 pub fn fflush(__stream: *mut FILE) -> ::std::os::raw::c_int;
4347}
4348extern "C" {
4349 pub fn fflush_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
4350}
4351extern "C" {
4352 pub fn fopen(
4353 __filename: *const ::std::os::raw::c_char,
4354 __modes: *const ::std::os::raw::c_char,
4355 ) -> *mut FILE;
4356}
4357extern "C" {
4358 pub fn freopen(
4359 __filename: *const ::std::os::raw::c_char,
4360 __modes: *const ::std::os::raw::c_char,
4361 __stream: *mut FILE,
4362 ) -> *mut FILE;
4363}
4364extern "C" {
4365 pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
4366 -> *mut FILE;
4367}
4368extern "C" {
4369 pub fn fmemopen(
4370 __s: *mut ::std::os::raw::c_void,
4371 __len: size_t,
4372 __modes: *const ::std::os::raw::c_char,
4373 ) -> *mut FILE;
4374}
4375extern "C" {
4376 pub fn open_memstream(
4377 __bufloc: *mut *mut ::std::os::raw::c_char,
4378 __sizeloc: *mut size_t,
4379 ) -> *mut FILE;
4380}
4381extern "C" {
4382 pub fn setbuf(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char);
4383}
4384extern "C" {
4385 pub fn setvbuf(
4386 __stream: *mut FILE,
4387 __buf: *mut ::std::os::raw::c_char,
4388 __modes: ::std::os::raw::c_int,
4389 __n: size_t,
4390 ) -> ::std::os::raw::c_int;
4391}
4392extern "C" {
4393 pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: size_t);
4394}
4395extern "C" {
4396 pub fn setlinebuf(__stream: *mut FILE);
4397}
4398extern "C" {
4399 pub fn fprintf(
4400 __stream: *mut FILE,
4401 __format: *const ::std::os::raw::c_char,
4402 ...
4403 ) -> ::std::os::raw::c_int;
4404}
4405extern "C" {
4406 pub fn printf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
4407}
4408extern "C" {
4409 pub fn sprintf(
4410 __s: *mut ::std::os::raw::c_char,
4411 __format: *const ::std::os::raw::c_char,
4412 ...
4413 ) -> ::std::os::raw::c_int;
4414}
4415extern "C" {
4416 pub fn vfprintf(
4417 __s: *mut FILE,
4418 __format: *const ::std::os::raw::c_char,
4419 __arg: *mut __va_list_tag,
4420 ) -> ::std::os::raw::c_int;
4421}
4422extern "C" {
4423 pub fn vprintf(
4424 __format: *const ::std::os::raw::c_char,
4425 __arg: *mut __va_list_tag,
4426 ) -> ::std::os::raw::c_int;
4427}
4428extern "C" {
4429 pub fn vsprintf(
4430 __s: *mut ::std::os::raw::c_char,
4431 __format: *const ::std::os::raw::c_char,
4432 __arg: *mut __va_list_tag,
4433 ) -> ::std::os::raw::c_int;
4434}
4435extern "C" {
4436 pub fn snprintf(
4437 __s: *mut ::std::os::raw::c_char,
4438 __maxlen: ::std::os::raw::c_ulong,
4439 __format: *const ::std::os::raw::c_char,
4440 ...
4441 ) -> ::std::os::raw::c_int;
4442}
4443extern "C" {
4444 pub fn vsnprintf(
4445 __s: *mut ::std::os::raw::c_char,
4446 __maxlen: ::std::os::raw::c_ulong,
4447 __format: *const ::std::os::raw::c_char,
4448 __arg: *mut __va_list_tag,
4449 ) -> ::std::os::raw::c_int;
4450}
4451extern "C" {
4452 pub fn vdprintf(
4453 __fd: ::std::os::raw::c_int,
4454 __fmt: *const ::std::os::raw::c_char,
4455 __arg: *mut __va_list_tag,
4456 ) -> ::std::os::raw::c_int;
4457}
4458extern "C" {
4459 pub fn dprintf(
4460 __fd: ::std::os::raw::c_int,
4461 __fmt: *const ::std::os::raw::c_char,
4462 ...
4463 ) -> ::std::os::raw::c_int;
4464}
4465extern "C" {
4466 pub fn fscanf(
4467 __stream: *mut FILE,
4468 __format: *const ::std::os::raw::c_char,
4469 ...
4470 ) -> ::std::os::raw::c_int;
4471}
4472extern "C" {
4473 pub fn scanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
4474}
4475extern "C" {
4476 pub fn sscanf(
4477 __s: *const ::std::os::raw::c_char,
4478 __format: *const ::std::os::raw::c_char,
4479 ...
4480 ) -> ::std::os::raw::c_int;
4481}
4482extern "C" {
4483 #[link_name = "\u{1}__isoc99_fscanf"]
4484 pub fn fscanf1(
4485 __stream: *mut FILE,
4486 __format: *const ::std::os::raw::c_char,
4487 ...
4488 ) -> ::std::os::raw::c_int;
4489}
4490extern "C" {
4491 #[link_name = "\u{1}__isoc99_scanf"]
4492 pub fn scanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
4493}
4494extern "C" {
4495 #[link_name = "\u{1}__isoc99_sscanf"]
4496 pub fn sscanf1(
4497 __s: *const ::std::os::raw::c_char,
4498 __format: *const ::std::os::raw::c_char,
4499 ...
4500 ) -> ::std::os::raw::c_int;
4501}
4502extern "C" {
4503 pub fn vfscanf(
4504 __s: *mut FILE,
4505 __format: *const ::std::os::raw::c_char,
4506 __arg: *mut __va_list_tag,
4507 ) -> ::std::os::raw::c_int;
4508}
4509extern "C" {
4510 pub fn vscanf(
4511 __format: *const ::std::os::raw::c_char,
4512 __arg: *mut __va_list_tag,
4513 ) -> ::std::os::raw::c_int;
4514}
4515extern "C" {
4516 pub fn vsscanf(
4517 __s: *const ::std::os::raw::c_char,
4518 __format: *const ::std::os::raw::c_char,
4519 __arg: *mut __va_list_tag,
4520 ) -> ::std::os::raw::c_int;
4521}
4522extern "C" {
4523 #[link_name = "\u{1}__isoc99_vfscanf"]
4524 pub fn vfscanf1(
4525 __s: *mut FILE,
4526 __format: *const ::std::os::raw::c_char,
4527 __arg: *mut __va_list_tag,
4528 ) -> ::std::os::raw::c_int;
4529}
4530extern "C" {
4531 #[link_name = "\u{1}__isoc99_vscanf"]
4532 pub fn vscanf1(
4533 __format: *const ::std::os::raw::c_char,
4534 __arg: *mut __va_list_tag,
4535 ) -> ::std::os::raw::c_int;
4536}
4537extern "C" {
4538 #[link_name = "\u{1}__isoc99_vsscanf"]
4539 pub fn vsscanf1(
4540 __s: *const ::std::os::raw::c_char,
4541 __format: *const ::std::os::raw::c_char,
4542 __arg: *mut __va_list_tag,
4543 ) -> ::std::os::raw::c_int;
4544}
4545extern "C" {
4546 pub fn fgetc(__stream: *mut FILE) -> ::std::os::raw::c_int;
4547}
4548extern "C" {
4549 pub fn getc(__stream: *mut FILE) -> ::std::os::raw::c_int;
4550}
4551extern "C" {
4552 pub fn getchar() -> ::std::os::raw::c_int;
4553}
4554extern "C" {
4555 pub fn getc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
4556}
4557extern "C" {
4558 pub fn getchar_unlocked() -> ::std::os::raw::c_int;
4559}
4560extern "C" {
4561 pub fn fgetc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
4562}
4563extern "C" {
4564 pub fn fputc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
4565}
4566extern "C" {
4567 pub fn putc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
4568}
4569extern "C" {
4570 pub fn putchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
4571}
4572extern "C" {
4573 pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE)
4574 -> ::std::os::raw::c_int;
4575}
4576extern "C" {
4577 pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
4578}
4579extern "C" {
4580 pub fn putchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
4581}
4582extern "C" {
4583 pub fn getw(__stream: *mut FILE) -> ::std::os::raw::c_int;
4584}
4585extern "C" {
4586 pub fn putw(__w: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
4587}
4588extern "C" {
4589 pub fn fgets(
4590 __s: *mut ::std::os::raw::c_char,
4591 __n: ::std::os::raw::c_int,
4592 __stream: *mut FILE,
4593 ) -> *mut ::std::os::raw::c_char;
4594}
4595extern "C" {
4596 pub fn __getdelim(
4597 __lineptr: *mut *mut ::std::os::raw::c_char,
4598 __n: *mut size_t,
4599 __delimiter: ::std::os::raw::c_int,
4600 __stream: *mut FILE,
4601 ) -> __ssize_t;
4602}
4603extern "C" {
4604 pub fn getdelim(
4605 __lineptr: *mut *mut ::std::os::raw::c_char,
4606 __n: *mut size_t,
4607 __delimiter: ::std::os::raw::c_int,
4608 __stream: *mut FILE,
4609 ) -> __ssize_t;
4610}
4611extern "C" {
4612 pub fn getline(
4613 __lineptr: *mut *mut ::std::os::raw::c_char,
4614 __n: *mut size_t,
4615 __stream: *mut FILE,
4616 ) -> __ssize_t;
4617}
4618extern "C" {
4619 pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
4620}
4621extern "C" {
4622 pub fn puts(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4623}
4624extern "C" {
4625 pub fn ungetc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
4626}
4627extern "C" {
4628 pub fn fread(
4629 __ptr: *mut ::std::os::raw::c_void,
4630 __size: ::std::os::raw::c_ulong,
4631 __n: ::std::os::raw::c_ulong,
4632 __stream: *mut FILE,
4633 ) -> ::std::os::raw::c_ulong;
4634}
4635extern "C" {
4636 pub fn fwrite(
4637 __ptr: *const ::std::os::raw::c_void,
4638 __size: ::std::os::raw::c_ulong,
4639 __n: ::std::os::raw::c_ulong,
4640 __s: *mut FILE,
4641 ) -> ::std::os::raw::c_ulong;
4642}
4643extern "C" {
4644 pub fn fread_unlocked(
4645 __ptr: *mut ::std::os::raw::c_void,
4646 __size: size_t,
4647 __n: size_t,
4648 __stream: *mut FILE,
4649 ) -> size_t;
4650}
4651extern "C" {
4652 pub fn fwrite_unlocked(
4653 __ptr: *const ::std::os::raw::c_void,
4654 __size: size_t,
4655 __n: size_t,
4656 __stream: *mut FILE,
4657 ) -> size_t;
4658}
4659extern "C" {
4660 pub fn fseek(
4661 __stream: *mut FILE,
4662 __off: ::std::os::raw::c_long,
4663 __whence: ::std::os::raw::c_int,
4664 ) -> ::std::os::raw::c_int;
4665}
4666extern "C" {
4667 pub fn ftell(__stream: *mut FILE) -> ::std::os::raw::c_long;
4668}
4669extern "C" {
4670 pub fn rewind(__stream: *mut FILE);
4671}
4672extern "C" {
4673 pub fn fseeko(
4674 __stream: *mut FILE,
4675 __off: __off_t,
4676 __whence: ::std::os::raw::c_int,
4677 ) -> ::std::os::raw::c_int;
4678}
4679extern "C" {
4680 pub fn ftello(__stream: *mut FILE) -> __off_t;
4681}
4682extern "C" {
4683 pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int;
4684}
4685extern "C" {
4686 pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int;
4687}
4688extern "C" {
4689 pub fn clearerr(__stream: *mut FILE);
4690}
4691extern "C" {
4692 pub fn feof(__stream: *mut FILE) -> ::std::os::raw::c_int;
4693}
4694extern "C" {
4695 pub fn ferror(__stream: *mut FILE) -> ::std::os::raw::c_int;
4696}
4697extern "C" {
4698 pub fn clearerr_unlocked(__stream: *mut FILE);
4699}
4700extern "C" {
4701 pub fn feof_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
4702}
4703extern "C" {
4704 pub fn ferror_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
4705}
4706extern "C" {
4707 pub fn perror(__s: *const ::std::os::raw::c_char);
4708}
4709extern "C" {
4710 pub fn fileno(__stream: *mut FILE) -> ::std::os::raw::c_int;
4711}
4712extern "C" {
4713 pub fn fileno_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
4714}
4715extern "C" {
4716 pub fn pclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
4717}
4718extern "C" {
4719 pub fn popen(
4720 __command: *const ::std::os::raw::c_char,
4721 __modes: *const ::std::os::raw::c_char,
4722 ) -> *mut FILE;
4723}
4724extern "C" {
4725 pub fn ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
4726}
4727extern "C" {
4728 pub fn flockfile(__stream: *mut FILE);
4729}
4730extern "C" {
4731 pub fn ftrylockfile(__stream: *mut FILE) -> ::std::os::raw::c_int;
4732}
4733extern "C" {
4734 pub fn funlockfile(__stream: *mut FILE);
4735}
4736extern "C" {
4737 pub fn __uflow(arg1: *mut FILE) -> ::std::os::raw::c_int;
4738}
4739extern "C" {
4740 pub fn __overflow(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
4741}
4742pub const MONO_ERROR_FREE_STRINGS: _bindgen_ty_63 = 1;
4743pub const MONO_ERROR_INCOMPLETE: _bindgen_ty_63 = 2;
4744pub const MONO_ERROR_MEMPOOL_BOXED: _bindgen_ty_63 = 4;
4745pub type _bindgen_ty_63 = ::std::os::raw::c_uint;
4746pub const MONO_ERROR_NONE: _bindgen_ty_64 = 0;
4747pub const MONO_ERROR_MISSING_METHOD: _bindgen_ty_64 = 1;
4748pub const MONO_ERROR_MISSING_FIELD: _bindgen_ty_64 = 2;
4749pub const MONO_ERROR_TYPE_LOAD: _bindgen_ty_64 = 3;
4750pub const MONO_ERROR_FILE_NOT_FOUND: _bindgen_ty_64 = 4;
4751pub const MONO_ERROR_BAD_IMAGE: _bindgen_ty_64 = 5;
4752pub const MONO_ERROR_OUT_OF_MEMORY: _bindgen_ty_64 = 6;
4753pub const MONO_ERROR_ARGUMENT: _bindgen_ty_64 = 7;
4754pub const MONO_ERROR_ARGUMENT_NULL: _bindgen_ty_64 = 11;
4755pub const MONO_ERROR_ARGUMENT_OUT_OF_RANGE: _bindgen_ty_64 = 14;
4756pub const MONO_ERROR_NOT_VERIFIABLE: _bindgen_ty_64 = 8;
4757pub const MONO_ERROR_INVALID_PROGRAM: _bindgen_ty_64 = 12;
4758pub const MONO_ERROR_MEMBER_ACCESS: _bindgen_ty_64 = 13;
4759pub const MONO_ERROR_GENERIC: _bindgen_ty_64 = 9;
4760pub const MONO_ERROR_EXCEPTION_INSTANCE: _bindgen_ty_64 = 10;
4761pub const MONO_ERROR_CLEANUP_CALLED_SENTINEL: _bindgen_ty_64 = 65535;
4762pub type _bindgen_ty_64 = ::std::os::raw::c_uint;
4763#[repr(C)]
4764#[derive(Copy, Clone)]
4765pub union _MonoError {
4766 pub init: u32,
4767 pub __bindgen_anon_1: _MonoError__bindgen_ty_1,
4768}
4769#[repr(C)]
4770#[derive(Debug, Copy, Clone)]
4771pub struct _MonoError__bindgen_ty_1 {
4772 pub error_code: u16,
4773 pub private_flags: u16,
4774 pub hidden_1: [*mut ::std::os::raw::c_void; 12usize],
4775}
4776#[test]
4777fn bindgen_test_layout__MonoError__bindgen_ty_1() {
4778 assert_eq!(
4779 ::std::mem::size_of::<_MonoError__bindgen_ty_1>(),
4780 104usize,
4781 concat!("Size of: ", stringify!(_MonoError__bindgen_ty_1))
4782 );
4783 assert_eq!(
4784 ::std::mem::align_of::<_MonoError__bindgen_ty_1>(),
4785 8usize,
4786 concat!("Alignment of ", stringify!(_MonoError__bindgen_ty_1))
4787 );
4788 fn test_field_error_code() {
4789 assert_eq!(
4790 unsafe {
4791 let uninit = ::std::mem::MaybeUninit::<_MonoError__bindgen_ty_1>::uninit();
4792 let ptr = uninit.as_ptr();
4793 ::std::ptr::addr_of!((*ptr).error_code) as usize - ptr as usize
4794 },
4795 0usize,
4796 concat!(
4797 "Offset of field: ",
4798 stringify!(_MonoError__bindgen_ty_1),
4799 "::",
4800 stringify!(error_code)
4801 )
4802 );
4803 }
4804 test_field_error_code();
4805 fn test_field_private_flags() {
4806 assert_eq!(
4807 unsafe {
4808 let uninit = ::std::mem::MaybeUninit::<_MonoError__bindgen_ty_1>::uninit();
4809 let ptr = uninit.as_ptr();
4810 ::std::ptr::addr_of!((*ptr).private_flags) as usize - ptr as usize
4811 },
4812 2usize,
4813 concat!(
4814 "Offset of field: ",
4815 stringify!(_MonoError__bindgen_ty_1),
4816 "::",
4817 stringify!(private_flags)
4818 )
4819 );
4820 }
4821 test_field_private_flags();
4822 fn test_field_hidden_1() {
4823 assert_eq!(
4824 unsafe {
4825 let uninit = ::std::mem::MaybeUninit::<_MonoError__bindgen_ty_1>::uninit();
4826 let ptr = uninit.as_ptr();
4827 ::std::ptr::addr_of!((*ptr).hidden_1) as usize - ptr as usize
4828 },
4829 8usize,
4830 concat!(
4831 "Offset of field: ",
4832 stringify!(_MonoError__bindgen_ty_1),
4833 "::",
4834 stringify!(hidden_1)
4835 )
4836 );
4837 }
4838 test_field_hidden_1();
4839}
4840#[test]
4841fn bindgen_test_layout__MonoError() {
4842 assert_eq!(
4843 ::std::mem::size_of::<_MonoError>(),
4844 104usize,
4845 concat!("Size of: ", stringify!(_MonoError))
4846 );
4847 assert_eq!(
4848 ::std::mem::align_of::<_MonoError>(),
4849 8usize,
4850 concat!("Alignment of ", stringify!(_MonoError))
4851 );
4852 fn test_field_init() {
4853 assert_eq!(
4854 unsafe {
4855 let uninit = ::std::mem::MaybeUninit::<_MonoError>::uninit();
4856 let ptr = uninit.as_ptr();
4857 ::std::ptr::addr_of!((*ptr).init) as usize - ptr as usize
4858 },
4859 0usize,
4860 concat!(
4861 "Offset of field: ",
4862 stringify!(_MonoError),
4863 "::",
4864 stringify!(init)
4865 )
4866 );
4867 }
4868 test_field_init();
4869}
4870pub type MonoErrorExternal = _MonoError;
4871pub type MonoError = MonoErrorExternal;
4872#[repr(C)]
4873#[derive(Debug, Copy, Clone)]
4874pub struct _MonoErrorBoxed {
4875 _unused: [u8; 0],
4876}
4877pub type MonoErrorBoxed = _MonoErrorBoxed;
4878extern "C" {
4879 pub fn mono_error_init(error: *mut MonoError);
4880}
4881extern "C" {
4882 pub fn mono_error_init_flags(error: *mut MonoError, flags: ::std::os::raw::c_ushort);
4883}
4884extern "C" {
4885 pub fn mono_error_cleanup(error: *mut MonoError);
4886}
4887extern "C" {
4888 pub fn mono_error_ok(error: *mut MonoError) -> mono_bool;
4889}
4890extern "C" {
4891 pub fn mono_error_get_error_code(error: *mut MonoError) -> ::std::os::raw::c_ushort;
4892}
4893extern "C" {
4894 pub fn mono_error_get_message(error: *mut MonoError) -> *const ::std::os::raw::c_char;
4895}
4896#[repr(C)]
4897#[derive(Debug, Copy, Clone)]
4898pub struct _MonoAssembly {
4899 _unused: [u8; 0],
4900}
4901pub type MonoAssembly = _MonoAssembly;
4902#[repr(C)]
4903#[derive(Debug, Copy, Clone)]
4904pub struct _MonoAssemblyName {
4905 _unused: [u8; 0],
4906}
4907pub type MonoAssemblyName = _MonoAssemblyName;
4908#[repr(C)]
4909#[derive(Debug, Copy, Clone)]
4910pub struct _MonoTableInfo {
4911 _unused: [u8; 0],
4912}
4913pub type MonoTableInfo = _MonoTableInfo;
4914pub const MonoImageOpenStatus_MONO_IMAGE_OK: MonoImageOpenStatus = 0;
4915pub const MonoImageOpenStatus_MONO_IMAGE_ERROR_ERRNO: MonoImageOpenStatus = 1;
4916pub const MonoImageOpenStatus_MONO_IMAGE_MISSING_ASSEMBLYREF: MonoImageOpenStatus = 2;
4917pub const MonoImageOpenStatus_MONO_IMAGE_IMAGE_INVALID: MonoImageOpenStatus = 3;
4918pub type MonoImageOpenStatus = ::std::os::raw::c_uint;
4919extern "C" {
4920 pub fn mono_images_init();
4921}
4922extern "C" {
4923 pub fn mono_images_cleanup();
4924}
4925extern "C" {
4926 pub fn mono_image_open(
4927 fname: *const ::std::os::raw::c_char,
4928 status: *mut MonoImageOpenStatus,
4929 ) -> *mut MonoImage;
4930}
4931extern "C" {
4932 pub fn mono_image_open_full(
4933 fname: *const ::std::os::raw::c_char,
4934 status: *mut MonoImageOpenStatus,
4935 refonly: mono_bool,
4936 ) -> *mut MonoImage;
4937}
4938extern "C" {
4939 pub fn mono_pe_file_open(
4940 fname: *const ::std::os::raw::c_char,
4941 status: *mut MonoImageOpenStatus,
4942 ) -> *mut MonoImage;
4943}
4944extern "C" {
4945 pub fn mono_image_open_from_data(
4946 data: *mut ::std::os::raw::c_char,
4947 data_len: u32,
4948 need_copy: mono_bool,
4949 status: *mut MonoImageOpenStatus,
4950 ) -> *mut MonoImage;
4951}
4952extern "C" {
4953 pub fn mono_image_open_from_data_full(
4954 data: *mut ::std::os::raw::c_char,
4955 data_len: u32,
4956 need_copy: mono_bool,
4957 status: *mut MonoImageOpenStatus,
4958 refonly: mono_bool,
4959 ) -> *mut MonoImage;
4960}
4961extern "C" {
4962 pub fn mono_image_open_from_data_with_name(
4963 data: *mut ::std::os::raw::c_char,
4964 data_len: u32,
4965 need_copy: mono_bool,
4966 status: *mut MonoImageOpenStatus,
4967 refonly: mono_bool,
4968 name: *const ::std::os::raw::c_char,
4969 ) -> *mut MonoImage;
4970}
4971extern "C" {
4972 pub fn mono_image_fixup_vtable(image: *mut MonoImage);
4973}
4974extern "C" {
4975 pub fn mono_image_loaded(name: *const ::std::os::raw::c_char) -> *mut MonoImage;
4976}
4977extern "C" {
4978 pub fn mono_image_loaded_full(
4979 name: *const ::std::os::raw::c_char,
4980 refonly: mono_bool,
4981 ) -> *mut MonoImage;
4982}
4983extern "C" {
4984 pub fn mono_image_loaded_by_guid(guid: *const ::std::os::raw::c_char) -> *mut MonoImage;
4985}
4986extern "C" {
4987 pub fn mono_image_loaded_by_guid_full(
4988 guid: *const ::std::os::raw::c_char,
4989 refonly: mono_bool,
4990 ) -> *mut MonoImage;
4991}
4992extern "C" {
4993 pub fn mono_image_init(image: *mut MonoImage);
4994}
4995extern "C" {
4996 pub fn mono_image_close(image: *mut MonoImage);
4997}
4998extern "C" {
4999 pub fn mono_image_addref(image: *mut MonoImage);
5000}
5001extern "C" {
5002 pub fn mono_image_strerror(status: MonoImageOpenStatus) -> *const ::std::os::raw::c_char;
5003}
5004extern "C" {
5005 pub fn mono_image_ensure_section(
5006 image: *mut MonoImage,
5007 section: *const ::std::os::raw::c_char,
5008 ) -> ::std::os::raw::c_int;
5009}
5010extern "C" {
5011 pub fn mono_image_ensure_section_idx(
5012 image: *mut MonoImage,
5013 section: ::std::os::raw::c_int,
5014 ) -> ::std::os::raw::c_int;
5015}
5016extern "C" {
5017 pub fn mono_image_get_entry_point(image: *mut MonoImage) -> u32;
5018}
5019extern "C" {
5020 pub fn mono_image_get_resource(
5021 image: *mut MonoImage,
5022 offset: u32,
5023 size: *mut u32,
5024 ) -> *const ::std::os::raw::c_char;
5025}
5026extern "C" {
5027 pub fn mono_image_load_file_for_image(
5028 image: *mut MonoImage,
5029 fileidx: ::std::os::raw::c_int,
5030 ) -> *mut MonoImage;
5031}
5032extern "C" {
5033 pub fn mono_image_load_module(
5034 image: *mut MonoImage,
5035 idx: ::std::os::raw::c_int,
5036 ) -> *mut MonoImage;
5037}
5038extern "C" {
5039 pub fn mono_image_get_name(image: *mut MonoImage) -> *const ::std::os::raw::c_char;
5040}
5041extern "C" {
5042 pub fn mono_image_get_filename(image: *mut MonoImage) -> *const ::std::os::raw::c_char;
5043}
5044extern "C" {
5045 pub fn mono_image_get_guid(image: *mut MonoImage) -> *const ::std::os::raw::c_char;
5046}
5047extern "C" {
5048 pub fn mono_image_get_assembly(image: *mut MonoImage) -> *mut MonoAssembly;
5049}
5050extern "C" {
5051 pub fn mono_image_is_dynamic(image: *mut MonoImage) -> mono_bool;
5052}
5053extern "C" {
5054 pub fn mono_image_rva_map(image: *mut MonoImage, rva: u32) -> *mut ::std::os::raw::c_char;
5055}
5056extern "C" {
5057 pub fn mono_image_get_table_info(
5058 image: *mut MonoImage,
5059 table_id: ::std::os::raw::c_int,
5060 ) -> *const MonoTableInfo;
5061}
5062extern "C" {
5063 pub fn mono_image_get_table_rows(
5064 image: *mut MonoImage,
5065 table_id: ::std::os::raw::c_int,
5066 ) -> ::std::os::raw::c_int;
5067}
5068extern "C" {
5069 pub fn mono_table_info_get_rows(table: *const MonoTableInfo) -> ::std::os::raw::c_int;
5070}
5071extern "C" {
5072 pub fn mono_image_lookup_resource(
5073 image: *mut MonoImage,
5074 res_id: u32,
5075 lang_id: u32,
5076 name: *mut mono_unichar2,
5077 ) -> *mut ::std::os::raw::c_void;
5078}
5079extern "C" {
5080 pub fn mono_image_get_public_key(
5081 image: *mut MonoImage,
5082 size: *mut u32,
5083 ) -> *const ::std::os::raw::c_char;
5084}
5085extern "C" {
5086 pub fn mono_image_get_strong_name(
5087 image: *mut MonoImage,
5088 size: *mut u32,
5089 ) -> *const ::std::os::raw::c_char;
5090}
5091extern "C" {
5092 pub fn mono_image_strong_name_position(image: *mut MonoImage, size: *mut u32) -> u32;
5093}
5094extern "C" {
5095 pub fn mono_image_add_to_name_cache(
5096 image: *mut MonoImage,
5097 nspace: *const ::std::os::raw::c_char,
5098 name: *const ::std::os::raw::c_char,
5099 idx: u32,
5100 );
5101}
5102extern "C" {
5103 pub fn mono_image_has_authenticode_entry(image: *mut MonoImage) -> mono_bool;
5104}
5105pub const MonoExceptionEnum_MONO_EXCEPTION_CLAUSE_NONE: MonoExceptionEnum = 0;
5106pub const MonoExceptionEnum_MONO_EXCEPTION_CLAUSE_FILTER: MonoExceptionEnum = 1;
5107pub const MonoExceptionEnum_MONO_EXCEPTION_CLAUSE_FINALLY: MonoExceptionEnum = 2;
5108pub const MonoExceptionEnum_MONO_EXCEPTION_CLAUSE_FAULT: MonoExceptionEnum = 4;
5109pub type MonoExceptionEnum = ::std::os::raw::c_uint;
5110pub const MonoCallConvention_MONO_CALL_DEFAULT: MonoCallConvention = 0;
5111pub const MonoCallConvention_MONO_CALL_C: MonoCallConvention = 1;
5112pub const MonoCallConvention_MONO_CALL_STDCALL: MonoCallConvention = 2;
5113pub const MonoCallConvention_MONO_CALL_THISCALL: MonoCallConvention = 3;
5114pub const MonoCallConvention_MONO_CALL_FASTCALL: MonoCallConvention = 4;
5115pub const MonoCallConvention_MONO_CALL_VARARG: MonoCallConvention = 5;
5116pub type MonoCallConvention = ::std::os::raw::c_uint;
5117pub const MonoMarshalNative_MONO_NATIVE_BOOLEAN: MonoMarshalNative = 2;
5118pub const MonoMarshalNative_MONO_NATIVE_I1: MonoMarshalNative = 3;
5119pub const MonoMarshalNative_MONO_NATIVE_U1: MonoMarshalNative = 4;
5120pub const MonoMarshalNative_MONO_NATIVE_I2: MonoMarshalNative = 5;
5121pub const MonoMarshalNative_MONO_NATIVE_U2: MonoMarshalNative = 6;
5122pub const MonoMarshalNative_MONO_NATIVE_I4: MonoMarshalNative = 7;
5123pub const MonoMarshalNative_MONO_NATIVE_U4: MonoMarshalNative = 8;
5124pub const MonoMarshalNative_MONO_NATIVE_I8: MonoMarshalNative = 9;
5125pub const MonoMarshalNative_MONO_NATIVE_U8: MonoMarshalNative = 10;
5126pub const MonoMarshalNative_MONO_NATIVE_R4: MonoMarshalNative = 11;
5127pub const MonoMarshalNative_MONO_NATIVE_R8: MonoMarshalNative = 12;
5128pub const MonoMarshalNative_MONO_NATIVE_CURRENCY: MonoMarshalNative = 15;
5129pub const MonoMarshalNative_MONO_NATIVE_BSTR: MonoMarshalNative = 19;
5130pub const MonoMarshalNative_MONO_NATIVE_LPSTR: MonoMarshalNative = 20;
5131pub const MonoMarshalNative_MONO_NATIVE_LPWSTR: MonoMarshalNative = 21;
5132pub const MonoMarshalNative_MONO_NATIVE_LPTSTR: MonoMarshalNative = 22;
5133pub const MonoMarshalNative_MONO_NATIVE_BYVALTSTR: MonoMarshalNative = 23;
5134pub const MonoMarshalNative_MONO_NATIVE_IUNKNOWN: MonoMarshalNative = 25;
5135pub const MonoMarshalNative_MONO_NATIVE_IDISPATCH: MonoMarshalNative = 26;
5136pub const MonoMarshalNative_MONO_NATIVE_STRUCT: MonoMarshalNative = 27;
5137pub const MonoMarshalNative_MONO_NATIVE_INTERFACE: MonoMarshalNative = 28;
5138pub const MonoMarshalNative_MONO_NATIVE_SAFEARRAY: MonoMarshalNative = 29;
5139pub const MonoMarshalNative_MONO_NATIVE_BYVALARRAY: MonoMarshalNative = 30;
5140pub const MonoMarshalNative_MONO_NATIVE_INT: MonoMarshalNative = 31;
5141pub const MonoMarshalNative_MONO_NATIVE_UINT: MonoMarshalNative = 32;
5142pub const MonoMarshalNative_MONO_NATIVE_VBBYREFSTR: MonoMarshalNative = 34;
5143pub const MonoMarshalNative_MONO_NATIVE_ANSIBSTR: MonoMarshalNative = 35;
5144pub const MonoMarshalNative_MONO_NATIVE_TBSTR: MonoMarshalNative = 36;
5145pub const MonoMarshalNative_MONO_NATIVE_VARIANTBOOL: MonoMarshalNative = 37;
5146pub const MonoMarshalNative_MONO_NATIVE_FUNC: MonoMarshalNative = 38;
5147pub const MonoMarshalNative_MONO_NATIVE_ASANY: MonoMarshalNative = 40;
5148pub const MonoMarshalNative_MONO_NATIVE_LPARRAY: MonoMarshalNative = 42;
5149pub const MonoMarshalNative_MONO_NATIVE_LPSTRUCT: MonoMarshalNative = 43;
5150pub const MonoMarshalNative_MONO_NATIVE_CUSTOM: MonoMarshalNative = 44;
5151pub const MonoMarshalNative_MONO_NATIVE_ERROR: MonoMarshalNative = 45;
5152pub const MonoMarshalNative_MONO_NATIVE_UTF8STR: MonoMarshalNative = 48;
5153pub const MonoMarshalNative_MONO_NATIVE_MAX: MonoMarshalNative = 80;
5154pub type MonoMarshalNative = ::std::os::raw::c_uint;
5155pub const MonoMarshalVariant_MONO_VARIANT_EMPTY: MonoMarshalVariant = 0;
5156pub const MonoMarshalVariant_MONO_VARIANT_NULL: MonoMarshalVariant = 1;
5157pub const MonoMarshalVariant_MONO_VARIANT_I2: MonoMarshalVariant = 2;
5158pub const MonoMarshalVariant_MONO_VARIANT_I4: MonoMarshalVariant = 3;
5159pub const MonoMarshalVariant_MONO_VARIANT_R4: MonoMarshalVariant = 4;
5160pub const MonoMarshalVariant_MONO_VARIANT_R8: MonoMarshalVariant = 5;
5161pub const MonoMarshalVariant_MONO_VARIANT_CY: MonoMarshalVariant = 6;
5162pub const MonoMarshalVariant_MONO_VARIANT_DATE: MonoMarshalVariant = 7;
5163pub const MonoMarshalVariant_MONO_VARIANT_BSTR: MonoMarshalVariant = 8;
5164pub const MonoMarshalVariant_MONO_VARIANT_DISPATCH: MonoMarshalVariant = 9;
5165pub const MonoMarshalVariant_MONO_VARIANT_ERROR: MonoMarshalVariant = 10;
5166pub const MonoMarshalVariant_MONO_VARIANT_BOOL: MonoMarshalVariant = 11;
5167pub const MonoMarshalVariant_MONO_VARIANT_VARIANT: MonoMarshalVariant = 12;
5168pub const MonoMarshalVariant_MONO_VARIANT_UNKNOWN: MonoMarshalVariant = 13;
5169pub const MonoMarshalVariant_MONO_VARIANT_DECIMAL: MonoMarshalVariant = 14;
5170pub const MonoMarshalVariant_MONO_VARIANT_I1: MonoMarshalVariant = 16;
5171pub const MonoMarshalVariant_MONO_VARIANT_UI1: MonoMarshalVariant = 17;
5172pub const MonoMarshalVariant_MONO_VARIANT_UI2: MonoMarshalVariant = 18;
5173pub const MonoMarshalVariant_MONO_VARIANT_UI4: MonoMarshalVariant = 19;
5174pub const MonoMarshalVariant_MONO_VARIANT_I8: MonoMarshalVariant = 20;
5175pub const MonoMarshalVariant_MONO_VARIANT_UI8: MonoMarshalVariant = 21;
5176pub const MonoMarshalVariant_MONO_VARIANT_INT: MonoMarshalVariant = 22;
5177pub const MonoMarshalVariant_MONO_VARIANT_UINT: MonoMarshalVariant = 23;
5178pub const MonoMarshalVariant_MONO_VARIANT_VOID: MonoMarshalVariant = 24;
5179pub const MonoMarshalVariant_MONO_VARIANT_HRESULT: MonoMarshalVariant = 25;
5180pub const MonoMarshalVariant_MONO_VARIANT_PTR: MonoMarshalVariant = 26;
5181pub const MonoMarshalVariant_MONO_VARIANT_SAFEARRAY: MonoMarshalVariant = 27;
5182pub const MonoMarshalVariant_MONO_VARIANT_CARRAY: MonoMarshalVariant = 28;
5183pub const MonoMarshalVariant_MONO_VARIANT_USERDEFINED: MonoMarshalVariant = 29;
5184pub const MonoMarshalVariant_MONO_VARIANT_LPSTR: MonoMarshalVariant = 30;
5185pub const MonoMarshalVariant_MONO_VARIANT_LPWSTR: MonoMarshalVariant = 31;
5186pub const MonoMarshalVariant_MONO_VARIANT_RECORD: MonoMarshalVariant = 36;
5187pub const MonoMarshalVariant_MONO_VARIANT_FILETIME: MonoMarshalVariant = 64;
5188pub const MonoMarshalVariant_MONO_VARIANT_BLOB: MonoMarshalVariant = 65;
5189pub const MonoMarshalVariant_MONO_VARIANT_STREAM: MonoMarshalVariant = 66;
5190pub const MonoMarshalVariant_MONO_VARIANT_STORAGE: MonoMarshalVariant = 67;
5191pub const MonoMarshalVariant_MONO_VARIANT_STREAMED_OBJECT: MonoMarshalVariant = 68;
5192pub const MonoMarshalVariant_MONO_VARIANT_STORED_OBJECT: MonoMarshalVariant = 69;
5193pub const MonoMarshalVariant_MONO_VARIANT_BLOB_OBJECT: MonoMarshalVariant = 70;
5194pub const MonoMarshalVariant_MONO_VARIANT_CF: MonoMarshalVariant = 71;
5195pub const MonoMarshalVariant_MONO_VARIANT_CLSID: MonoMarshalVariant = 72;
5196pub const MonoMarshalVariant_MONO_VARIANT_VECTOR: MonoMarshalVariant = 4096;
5197pub const MonoMarshalVariant_MONO_VARIANT_ARRAY: MonoMarshalVariant = 8192;
5198pub const MonoMarshalVariant_MONO_VARIANT_BYREF: MonoMarshalVariant = 16384;
5199pub type MonoMarshalVariant = ::std::os::raw::c_uint;
5200pub const MonoMarshalConv_MONO_MARSHAL_CONV_NONE: MonoMarshalConv = 0;
5201pub const MonoMarshalConv_MONO_MARSHAL_CONV_BOOL_VARIANTBOOL: MonoMarshalConv = 1;
5202pub const MonoMarshalConv_MONO_MARSHAL_CONV_BOOL_I4: MonoMarshalConv = 2;
5203pub const MonoMarshalConv_MONO_MARSHAL_CONV_STR_BSTR: MonoMarshalConv = 3;
5204pub const MonoMarshalConv_MONO_MARSHAL_CONV_STR_LPSTR: MonoMarshalConv = 4;
5205pub const MonoMarshalConv_MONO_MARSHAL_CONV_LPSTR_STR: MonoMarshalConv = 5;
5206pub const MonoMarshalConv_MONO_MARSHAL_CONV_LPTSTR_STR: MonoMarshalConv = 6;
5207pub const MonoMarshalConv_MONO_MARSHAL_CONV_STR_LPWSTR: MonoMarshalConv = 7;
5208pub const MonoMarshalConv_MONO_MARSHAL_CONV_LPWSTR_STR: MonoMarshalConv = 8;
5209pub const MonoMarshalConv_MONO_MARSHAL_CONV_STR_LPTSTR: MonoMarshalConv = 9;
5210pub const MonoMarshalConv_MONO_MARSHAL_CONV_STR_ANSIBSTR: MonoMarshalConv = 10;
5211pub const MonoMarshalConv_MONO_MARSHAL_CONV_STR_TBSTR: MonoMarshalConv = 11;
5212pub const MonoMarshalConv_MONO_MARSHAL_CONV_STR_BYVALSTR: MonoMarshalConv = 12;
5213pub const MonoMarshalConv_MONO_MARSHAL_CONV_STR_BYVALWSTR: MonoMarshalConv = 13;
5214pub const MonoMarshalConv_MONO_MARSHAL_CONV_SB_LPSTR: MonoMarshalConv = 14;
5215pub const MonoMarshalConv_MONO_MARSHAL_CONV_SB_LPTSTR: MonoMarshalConv = 15;
5216pub const MonoMarshalConv_MONO_MARSHAL_CONV_SB_LPWSTR: MonoMarshalConv = 16;
5217pub const MonoMarshalConv_MONO_MARSHAL_CONV_LPSTR_SB: MonoMarshalConv = 17;
5218pub const MonoMarshalConv_MONO_MARSHAL_CONV_LPTSTR_SB: MonoMarshalConv = 18;
5219pub const MonoMarshalConv_MONO_MARSHAL_CONV_LPWSTR_SB: MonoMarshalConv = 19;
5220pub const MonoMarshalConv_MONO_MARSHAL_CONV_ARRAY_BYVALARRAY: MonoMarshalConv = 20;
5221pub const MonoMarshalConv_MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY: MonoMarshalConv = 21;
5222pub const MonoMarshalConv_MONO_MARSHAL_CONV_ARRAY_SAVEARRAY: MonoMarshalConv = 22;
5223pub const MonoMarshalConv_MONO_MARSHAL_CONV_ARRAY_LPARRAY: MonoMarshalConv = 23;
5224pub const MonoMarshalConv_MONO_MARSHAL_FREE_LPARRAY: MonoMarshalConv = 24;
5225pub const MonoMarshalConv_MONO_MARSHAL_CONV_OBJECT_INTERFACE: MonoMarshalConv = 25;
5226pub const MonoMarshalConv_MONO_MARSHAL_CONV_OBJECT_IDISPATCH: MonoMarshalConv = 26;
5227pub const MonoMarshalConv_MONO_MARSHAL_CONV_OBJECT_IUNKNOWN: MonoMarshalConv = 27;
5228pub const MonoMarshalConv_MONO_MARSHAL_CONV_OBJECT_STRUCT: MonoMarshalConv = 28;
5229pub const MonoMarshalConv_MONO_MARSHAL_CONV_DEL_FTN: MonoMarshalConv = 29;
5230pub const MonoMarshalConv_MONO_MARSHAL_CONV_FTN_DEL: MonoMarshalConv = 30;
5231pub const MonoMarshalConv_MONO_MARSHAL_FREE_ARRAY: MonoMarshalConv = 31;
5232pub const MonoMarshalConv_MONO_MARSHAL_CONV_BSTR_STR: MonoMarshalConv = 32;
5233pub const MonoMarshalConv_MONO_MARSHAL_CONV_SAFEHANDLE: MonoMarshalConv = 33;
5234pub const MonoMarshalConv_MONO_MARSHAL_CONV_HANDLEREF: MonoMarshalConv = 34;
5235pub const MonoMarshalConv_MONO_MARSHAL_CONV_STR_UTF8STR: MonoMarshalConv = 35;
5236pub const MonoMarshalConv_MONO_MARSHAL_CONV_SB_UTF8STR: MonoMarshalConv = 36;
5237pub const MonoMarshalConv_MONO_MARSHAL_CONV_UTF8STR_STR: MonoMarshalConv = 37;
5238pub const MonoMarshalConv_MONO_MARSHAL_CONV_UTF8STR_SB: MonoMarshalConv = 38;
5239pub const MonoMarshalConv_MONO_MARSHAL_CONV_FIXED_BUFFER: MonoMarshalConv = 39;
5240pub type MonoMarshalConv = ::std::os::raw::c_uint;
5241#[repr(C)]
5242#[derive(Copy, Clone)]
5243pub struct MonoMarshalSpec {
5244 pub native: MonoMarshalNative,
5245 pub data: MonoMarshalSpec__bindgen_ty_1,
5246}
5247#[repr(C)]
5248#[derive(Copy, Clone)]
5249pub union MonoMarshalSpec__bindgen_ty_1 {
5250 pub array_data: MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1,
5251 pub custom_data: MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2,
5252 pub safearray_data: MonoMarshalSpec__bindgen_ty_1__bindgen_ty_3,
5253}
5254#[repr(C)]
5255#[derive(Debug, Copy, Clone)]
5256pub struct MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1 {
5257 pub elem_type: MonoMarshalNative,
5258 pub num_elem: i32,
5259 pub param_num: i16,
5260 pub elem_mult: i16,
5261}
5262#[test]
5263fn bindgen_test_layout_MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1() {
5264 assert_eq!(
5265 ::std::mem::size_of::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1>(),
5266 12usize,
5267 concat!(
5268 "Size of: ",
5269 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1)
5270 )
5271 );
5272 assert_eq!(
5273 ::std::mem::align_of::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1>(),
5274 4usize,
5275 concat!(
5276 "Alignment of ",
5277 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1)
5278 )
5279 );
5280 fn test_field_elem_type() {
5281 assert_eq!(
5282 unsafe {
5283 let uninit =
5284 ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1>::uninit(
5285 );
5286 let ptr = uninit.as_ptr();
5287 ::std::ptr::addr_of!((*ptr).elem_type) as usize - ptr as usize
5288 },
5289 0usize,
5290 concat!(
5291 "Offset of field: ",
5292 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1),
5293 "::",
5294 stringify!(elem_type)
5295 )
5296 );
5297 }
5298 test_field_elem_type();
5299 fn test_field_num_elem() {
5300 assert_eq!(
5301 unsafe {
5302 let uninit =
5303 ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1>::uninit(
5304 );
5305 let ptr = uninit.as_ptr();
5306 ::std::ptr::addr_of!((*ptr).num_elem) as usize - ptr as usize
5307 },
5308 4usize,
5309 concat!(
5310 "Offset of field: ",
5311 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1),
5312 "::",
5313 stringify!(num_elem)
5314 )
5315 );
5316 }
5317 test_field_num_elem();
5318 fn test_field_param_num() {
5319 assert_eq!(
5320 unsafe {
5321 let uninit =
5322 ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1>::uninit(
5323 );
5324 let ptr = uninit.as_ptr();
5325 ::std::ptr::addr_of!((*ptr).param_num) as usize - ptr as usize
5326 },
5327 8usize,
5328 concat!(
5329 "Offset of field: ",
5330 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1),
5331 "::",
5332 stringify!(param_num)
5333 )
5334 );
5335 }
5336 test_field_param_num();
5337 fn test_field_elem_mult() {
5338 assert_eq!(
5339 unsafe {
5340 let uninit =
5341 ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1>::uninit(
5342 );
5343 let ptr = uninit.as_ptr();
5344 ::std::ptr::addr_of!((*ptr).elem_mult) as usize - ptr as usize
5345 },
5346 10usize,
5347 concat!(
5348 "Offset of field: ",
5349 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_1),
5350 "::",
5351 stringify!(elem_mult)
5352 )
5353 );
5354 }
5355 test_field_elem_mult();
5356}
5357#[repr(C)]
5358#[derive(Debug, Copy, Clone)]
5359pub struct MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2 {
5360 pub custom_name: *mut ::std::os::raw::c_char,
5361 pub cookie: *mut ::std::os::raw::c_char,
5362 pub image: *mut MonoImage,
5363}
5364#[test]
5365fn bindgen_test_layout_MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2() {
5366 assert_eq!(
5367 ::std::mem::size_of::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2>(),
5368 24usize,
5369 concat!(
5370 "Size of: ",
5371 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2)
5372 )
5373 );
5374 assert_eq!(
5375 ::std::mem::align_of::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2>(),
5376 8usize,
5377 concat!(
5378 "Alignment of ",
5379 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2)
5380 )
5381 );
5382 fn test_field_custom_name() {
5383 assert_eq!(
5384 unsafe {
5385 let uninit =
5386 ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2>::uninit(
5387 );
5388 let ptr = uninit.as_ptr();
5389 ::std::ptr::addr_of!((*ptr).custom_name) as usize - ptr as usize
5390 },
5391 0usize,
5392 concat!(
5393 "Offset of field: ",
5394 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2),
5395 "::",
5396 stringify!(custom_name)
5397 )
5398 );
5399 }
5400 test_field_custom_name();
5401 fn test_field_cookie() {
5402 assert_eq!(
5403 unsafe {
5404 let uninit =
5405 ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2>::uninit(
5406 );
5407 let ptr = uninit.as_ptr();
5408 ::std::ptr::addr_of!((*ptr).cookie) as usize - ptr as usize
5409 },
5410 8usize,
5411 concat!(
5412 "Offset of field: ",
5413 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2),
5414 "::",
5415 stringify!(cookie)
5416 )
5417 );
5418 }
5419 test_field_cookie();
5420 fn test_field_image() {
5421 assert_eq!(
5422 unsafe {
5423 let uninit =
5424 ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2>::uninit(
5425 );
5426 let ptr = uninit.as_ptr();
5427 ::std::ptr::addr_of!((*ptr).image) as usize - ptr as usize
5428 },
5429 16usize,
5430 concat!(
5431 "Offset of field: ",
5432 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_2),
5433 "::",
5434 stringify!(image)
5435 )
5436 );
5437 }
5438 test_field_image();
5439}
5440#[repr(C)]
5441#[derive(Debug, Copy, Clone)]
5442pub struct MonoMarshalSpec__bindgen_ty_1__bindgen_ty_3 {
5443 pub elem_type: MonoMarshalVariant,
5444 pub num_elem: i32,
5445}
5446#[test]
5447fn bindgen_test_layout_MonoMarshalSpec__bindgen_ty_1__bindgen_ty_3() {
5448 assert_eq!(
5449 ::std::mem::size_of::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_3>(),
5450 8usize,
5451 concat!(
5452 "Size of: ",
5453 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_3)
5454 )
5455 );
5456 assert_eq!(
5457 ::std::mem::align_of::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_3>(),
5458 4usize,
5459 concat!(
5460 "Alignment of ",
5461 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_3)
5462 )
5463 );
5464 fn test_field_elem_type() {
5465 assert_eq!(
5466 unsafe {
5467 let uninit =
5468 ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_3>::uninit(
5469 );
5470 let ptr = uninit.as_ptr();
5471 ::std::ptr::addr_of!((*ptr).elem_type) as usize - ptr as usize
5472 },
5473 0usize,
5474 concat!(
5475 "Offset of field: ",
5476 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_3),
5477 "::",
5478 stringify!(elem_type)
5479 )
5480 );
5481 }
5482 test_field_elem_type();
5483 fn test_field_num_elem() {
5484 assert_eq!(
5485 unsafe {
5486 let uninit =
5487 ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1__bindgen_ty_3>::uninit(
5488 );
5489 let ptr = uninit.as_ptr();
5490 ::std::ptr::addr_of!((*ptr).num_elem) as usize - ptr as usize
5491 },
5492 4usize,
5493 concat!(
5494 "Offset of field: ",
5495 stringify!(MonoMarshalSpec__bindgen_ty_1__bindgen_ty_3),
5496 "::",
5497 stringify!(num_elem)
5498 )
5499 );
5500 }
5501 test_field_num_elem();
5502}
5503#[test]
5504fn bindgen_test_layout_MonoMarshalSpec__bindgen_ty_1() {
5505 assert_eq!(
5506 ::std::mem::size_of::<MonoMarshalSpec__bindgen_ty_1>(),
5507 24usize,
5508 concat!("Size of: ", stringify!(MonoMarshalSpec__bindgen_ty_1))
5509 );
5510 assert_eq!(
5511 ::std::mem::align_of::<MonoMarshalSpec__bindgen_ty_1>(),
5512 8usize,
5513 concat!("Alignment of ", stringify!(MonoMarshalSpec__bindgen_ty_1))
5514 );
5515 fn test_field_array_data() {
5516 assert_eq!(
5517 unsafe {
5518 let uninit = ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1>::uninit();
5519 let ptr = uninit.as_ptr();
5520 ::std::ptr::addr_of!((*ptr).array_data) as usize - ptr as usize
5521 },
5522 0usize,
5523 concat!(
5524 "Offset of field: ",
5525 stringify!(MonoMarshalSpec__bindgen_ty_1),
5526 "::",
5527 stringify!(array_data)
5528 )
5529 );
5530 }
5531 test_field_array_data();
5532 fn test_field_custom_data() {
5533 assert_eq!(
5534 unsafe {
5535 let uninit = ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1>::uninit();
5536 let ptr = uninit.as_ptr();
5537 ::std::ptr::addr_of!((*ptr).custom_data) as usize - ptr as usize
5538 },
5539 0usize,
5540 concat!(
5541 "Offset of field: ",
5542 stringify!(MonoMarshalSpec__bindgen_ty_1),
5543 "::",
5544 stringify!(custom_data)
5545 )
5546 );
5547 }
5548 test_field_custom_data();
5549 fn test_field_safearray_data() {
5550 assert_eq!(
5551 unsafe {
5552 let uninit = ::std::mem::MaybeUninit::<MonoMarshalSpec__bindgen_ty_1>::uninit();
5553 let ptr = uninit.as_ptr();
5554 ::std::ptr::addr_of!((*ptr).safearray_data) as usize - ptr as usize
5555 },
5556 0usize,
5557 concat!(
5558 "Offset of field: ",
5559 stringify!(MonoMarshalSpec__bindgen_ty_1),
5560 "::",
5561 stringify!(safearray_data)
5562 )
5563 );
5564 }
5565 test_field_safearray_data();
5566}
5567#[test]
5568fn bindgen_test_layout_MonoMarshalSpec() {
5569 assert_eq!(
5570 ::std::mem::size_of::<MonoMarshalSpec>(),
5571 32usize,
5572 concat!("Size of: ", stringify!(MonoMarshalSpec))
5573 );
5574 assert_eq!(
5575 ::std::mem::align_of::<MonoMarshalSpec>(),
5576 8usize,
5577 concat!("Alignment of ", stringify!(MonoMarshalSpec))
5578 );
5579 fn test_field_native() {
5580 assert_eq!(
5581 unsafe {
5582 let uninit = ::std::mem::MaybeUninit::<MonoMarshalSpec>::uninit();
5583 let ptr = uninit.as_ptr();
5584 ::std::ptr::addr_of!((*ptr).native) as usize - ptr as usize
5585 },
5586 0usize,
5587 concat!(
5588 "Offset of field: ",
5589 stringify!(MonoMarshalSpec),
5590 "::",
5591 stringify!(native)
5592 )
5593 );
5594 }
5595 test_field_native();
5596 fn test_field_data() {
5597 assert_eq!(
5598 unsafe {
5599 let uninit = ::std::mem::MaybeUninit::<MonoMarshalSpec>::uninit();
5600 let ptr = uninit.as_ptr();
5601 ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize
5602 },
5603 8usize,
5604 concat!(
5605 "Offset of field: ",
5606 stringify!(MonoMarshalSpec),
5607 "::",
5608 stringify!(data)
5609 )
5610 );
5611 }
5612 test_field_data();
5613}
5614extern "C" {
5615 pub fn mono_metadata_init();
5616}
5617extern "C" {
5618 pub fn mono_metadata_decode_row(
5619 t: *const MonoTableInfo,
5620 idx: ::std::os::raw::c_int,
5621 res: *mut u32,
5622 res_size: ::std::os::raw::c_int,
5623 );
5624}
5625extern "C" {
5626 pub fn mono_metadata_decode_row_col(
5627 t: *const MonoTableInfo,
5628 idx: ::std::os::raw::c_int,
5629 col: ::std::os::raw::c_uint,
5630 ) -> u32;
5631}
5632extern "C" {
5633 pub fn mono_metadata_compute_size(
5634 meta: *mut MonoImage,
5635 tableindex: ::std::os::raw::c_int,
5636 result_bitfield: *mut u32,
5637 ) -> ::std::os::raw::c_int;
5638}
5639extern "C" {
5640 pub fn mono_metadata_locate(
5641 meta: *mut MonoImage,
5642 table: ::std::os::raw::c_int,
5643 idx: ::std::os::raw::c_int,
5644 ) -> *const ::std::os::raw::c_char;
5645}
5646extern "C" {
5647 pub fn mono_metadata_locate_token(
5648 meta: *mut MonoImage,
5649 token: u32,
5650 ) -> *const ::std::os::raw::c_char;
5651}
5652extern "C" {
5653 pub fn mono_metadata_string_heap(
5654 meta: *mut MonoImage,
5655 table_index: u32,
5656 ) -> *const ::std::os::raw::c_char;
5657}
5658extern "C" {
5659 pub fn mono_metadata_blob_heap(
5660 meta: *mut MonoImage,
5661 table_index: u32,
5662 ) -> *const ::std::os::raw::c_char;
5663}
5664extern "C" {
5665 pub fn mono_metadata_user_string(
5666 meta: *mut MonoImage,
5667 table_index: u32,
5668 ) -> *const ::std::os::raw::c_char;
5669}
5670extern "C" {
5671 pub fn mono_metadata_guid_heap(
5672 meta: *mut MonoImage,
5673 table_index: u32,
5674 ) -> *const ::std::os::raw::c_char;
5675}
5676extern "C" {
5677 pub fn mono_metadata_typedef_from_field(meta: *mut MonoImage, table_index: u32) -> u32;
5678}
5679extern "C" {
5680 pub fn mono_metadata_typedef_from_method(meta: *mut MonoImage, table_index: u32) -> u32;
5681}
5682extern "C" {
5683 pub fn mono_metadata_nested_in_typedef(meta: *mut MonoImage, table_index: u32) -> u32;
5684}
5685extern "C" {
5686 pub fn mono_metadata_nesting_typedef(
5687 meta: *mut MonoImage,
5688 table_index: u32,
5689 start_index: u32,
5690 ) -> u32;
5691}
5692extern "C" {
5693 pub fn mono_metadata_interfaces_from_typedef(
5694 meta: *mut MonoImage,
5695 table_index: u32,
5696 count: *mut ::std::os::raw::c_uint,
5697 ) -> *mut *mut MonoClass;
5698}
5699extern "C" {
5700 pub fn mono_metadata_events_from_typedef(
5701 meta: *mut MonoImage,
5702 table_index: u32,
5703 end_idx: *mut ::std::os::raw::c_uint,
5704 ) -> u32;
5705}
5706extern "C" {
5707 pub fn mono_metadata_methods_from_event(
5708 meta: *mut MonoImage,
5709 table_index: u32,
5710 end: *mut ::std::os::raw::c_uint,
5711 ) -> u32;
5712}
5713extern "C" {
5714 pub fn mono_metadata_properties_from_typedef(
5715 meta: *mut MonoImage,
5716 table_index: u32,
5717 end: *mut ::std::os::raw::c_uint,
5718 ) -> u32;
5719}
5720extern "C" {
5721 pub fn mono_metadata_methods_from_property(
5722 meta: *mut MonoImage,
5723 table_index: u32,
5724 end: *mut ::std::os::raw::c_uint,
5725 ) -> u32;
5726}
5727extern "C" {
5728 pub fn mono_metadata_packing_from_typedef(
5729 meta: *mut MonoImage,
5730 table_index: u32,
5731 packing: *mut u32,
5732 size: *mut u32,
5733 ) -> u32;
5734}
5735extern "C" {
5736 pub fn mono_metadata_get_marshal_info(
5737 meta: *mut MonoImage,
5738 idx: u32,
5739 is_field: mono_bool,
5740 ) -> *const ::std::os::raw::c_char;
5741}
5742extern "C" {
5743 pub fn mono_metadata_custom_attrs_from_index(meta: *mut MonoImage, cattr_index: u32) -> u32;
5744}
5745extern "C" {
5746 pub fn mono_metadata_parse_marshal_spec(
5747 image: *mut MonoImage,
5748 ptr: *const ::std::os::raw::c_char,
5749 ) -> *mut MonoMarshalSpec;
5750}
5751extern "C" {
5752 pub fn mono_metadata_free_marshal_spec(spec: *mut MonoMarshalSpec);
5753}
5754extern "C" {
5755 pub fn mono_metadata_implmap_from_method(meta: *mut MonoImage, method_idx: u32) -> u32;
5756}
5757extern "C" {
5758 pub fn mono_metadata_field_info(
5759 meta: *mut MonoImage,
5760 table_index: u32,
5761 offset: *mut u32,
5762 rva: *mut u32,
5763 marshal_spec: *mut *mut MonoMarshalSpec,
5764 );
5765}
5766extern "C" {
5767 pub fn mono_metadata_get_constant_index(meta: *mut MonoImage, token: u32, hint: u32) -> u32;
5768}
5769extern "C" {
5770 pub fn mono_metadata_decode_value(
5771 ptr: *const ::std::os::raw::c_char,
5772 rptr: *mut *const ::std::os::raw::c_char,
5773 ) -> u32;
5774}
5775extern "C" {
5776 pub fn mono_metadata_decode_signed_value(
5777 ptr: *const ::std::os::raw::c_char,
5778 rptr: *mut *const ::std::os::raw::c_char,
5779 ) -> i32;
5780}
5781extern "C" {
5782 pub fn mono_metadata_decode_blob_size(
5783 ptr: *const ::std::os::raw::c_char,
5784 rptr: *mut *const ::std::os::raw::c_char,
5785 ) -> u32;
5786}
5787extern "C" {
5788 pub fn mono_metadata_encode_value(
5789 value: u32,
5790 bug: *mut ::std::os::raw::c_char,
5791 endbuf: *mut *mut ::std::os::raw::c_char,
5792 );
5793}
5794#[repr(C)]
5795#[derive(Copy, Clone)]
5796pub struct MonoExceptionClause {
5797 pub flags: u32,
5798 pub try_offset: u32,
5799 pub try_len: u32,
5800 pub handler_offset: u32,
5801 pub handler_len: u32,
5802 pub data: MonoExceptionClause__bindgen_ty_1,
5803}
5804#[repr(C)]
5805#[derive(Copy, Clone)]
5806pub union MonoExceptionClause__bindgen_ty_1 {
5807 pub filter_offset: u32,
5808 pub catch_class: *mut MonoClass,
5809}
5810#[test]
5811fn bindgen_test_layout_MonoExceptionClause__bindgen_ty_1() {
5812 assert_eq!(
5813 ::std::mem::size_of::<MonoExceptionClause__bindgen_ty_1>(),
5814 8usize,
5815 concat!("Size of: ", stringify!(MonoExceptionClause__bindgen_ty_1))
5816 );
5817 assert_eq!(
5818 ::std::mem::align_of::<MonoExceptionClause__bindgen_ty_1>(),
5819 8usize,
5820 concat!(
5821 "Alignment of ",
5822 stringify!(MonoExceptionClause__bindgen_ty_1)
5823 )
5824 );
5825 fn test_field_filter_offset() {
5826 assert_eq!(
5827 unsafe {
5828 let uninit = ::std::mem::MaybeUninit::<MonoExceptionClause__bindgen_ty_1>::uninit();
5829 let ptr = uninit.as_ptr();
5830 ::std::ptr::addr_of!((*ptr).filter_offset) as usize - ptr as usize
5831 },
5832 0usize,
5833 concat!(
5834 "Offset of field: ",
5835 stringify!(MonoExceptionClause__bindgen_ty_1),
5836 "::",
5837 stringify!(filter_offset)
5838 )
5839 );
5840 }
5841 test_field_filter_offset();
5842 fn test_field_catch_class() {
5843 assert_eq!(
5844 unsafe {
5845 let uninit = ::std::mem::MaybeUninit::<MonoExceptionClause__bindgen_ty_1>::uninit();
5846 let ptr = uninit.as_ptr();
5847 ::std::ptr::addr_of!((*ptr).catch_class) as usize - ptr as usize
5848 },
5849 0usize,
5850 concat!(
5851 "Offset of field: ",
5852 stringify!(MonoExceptionClause__bindgen_ty_1),
5853 "::",
5854 stringify!(catch_class)
5855 )
5856 );
5857 }
5858 test_field_catch_class();
5859}
5860#[test]
5861fn bindgen_test_layout_MonoExceptionClause() {
5862 assert_eq!(
5863 ::std::mem::size_of::<MonoExceptionClause>(),
5864 32usize,
5865 concat!("Size of: ", stringify!(MonoExceptionClause))
5866 );
5867 assert_eq!(
5868 ::std::mem::align_of::<MonoExceptionClause>(),
5869 8usize,
5870 concat!("Alignment of ", stringify!(MonoExceptionClause))
5871 );
5872 fn test_field_flags() {
5873 assert_eq!(
5874 unsafe {
5875 let uninit = ::std::mem::MaybeUninit::<MonoExceptionClause>::uninit();
5876 let ptr = uninit.as_ptr();
5877 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
5878 },
5879 0usize,
5880 concat!(
5881 "Offset of field: ",
5882 stringify!(MonoExceptionClause),
5883 "::",
5884 stringify!(flags)
5885 )
5886 );
5887 }
5888 test_field_flags();
5889 fn test_field_try_offset() {
5890 assert_eq!(
5891 unsafe {
5892 let uninit = ::std::mem::MaybeUninit::<MonoExceptionClause>::uninit();
5893 let ptr = uninit.as_ptr();
5894 ::std::ptr::addr_of!((*ptr).try_offset) as usize - ptr as usize
5895 },
5896 4usize,
5897 concat!(
5898 "Offset of field: ",
5899 stringify!(MonoExceptionClause),
5900 "::",
5901 stringify!(try_offset)
5902 )
5903 );
5904 }
5905 test_field_try_offset();
5906 fn test_field_try_len() {
5907 assert_eq!(
5908 unsafe {
5909 let uninit = ::std::mem::MaybeUninit::<MonoExceptionClause>::uninit();
5910 let ptr = uninit.as_ptr();
5911 ::std::ptr::addr_of!((*ptr).try_len) as usize - ptr as usize
5912 },
5913 8usize,
5914 concat!(
5915 "Offset of field: ",
5916 stringify!(MonoExceptionClause),
5917 "::",
5918 stringify!(try_len)
5919 )
5920 );
5921 }
5922 test_field_try_len();
5923 fn test_field_handler_offset() {
5924 assert_eq!(
5925 unsafe {
5926 let uninit = ::std::mem::MaybeUninit::<MonoExceptionClause>::uninit();
5927 let ptr = uninit.as_ptr();
5928 ::std::ptr::addr_of!((*ptr).handler_offset) as usize - ptr as usize
5929 },
5930 12usize,
5931 concat!(
5932 "Offset of field: ",
5933 stringify!(MonoExceptionClause),
5934 "::",
5935 stringify!(handler_offset)
5936 )
5937 );
5938 }
5939 test_field_handler_offset();
5940 fn test_field_handler_len() {
5941 assert_eq!(
5942 unsafe {
5943 let uninit = ::std::mem::MaybeUninit::<MonoExceptionClause>::uninit();
5944 let ptr = uninit.as_ptr();
5945 ::std::ptr::addr_of!((*ptr).handler_len) as usize - ptr as usize
5946 },
5947 16usize,
5948 concat!(
5949 "Offset of field: ",
5950 stringify!(MonoExceptionClause),
5951 "::",
5952 stringify!(handler_len)
5953 )
5954 );
5955 }
5956 test_field_handler_len();
5957 fn test_field_data() {
5958 assert_eq!(
5959 unsafe {
5960 let uninit = ::std::mem::MaybeUninit::<MonoExceptionClause>::uninit();
5961 let ptr = uninit.as_ptr();
5962 ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize
5963 },
5964 24usize,
5965 concat!(
5966 "Offset of field: ",
5967 stringify!(MonoExceptionClause),
5968 "::",
5969 stringify!(data)
5970 )
5971 );
5972 }
5973 test_field_data();
5974}
5975#[repr(C)]
5976#[derive(Debug, Copy, Clone)]
5977pub struct _MonoType {
5978 _unused: [u8; 0],
5979}
5980pub type MonoType = _MonoType;
5981#[repr(C)]
5982#[derive(Debug, Copy, Clone)]
5983pub struct _MonoGenericInst {
5984 _unused: [u8; 0],
5985}
5986pub type MonoGenericInst = _MonoGenericInst;
5987#[repr(C)]
5988#[derive(Debug, Copy, Clone)]
5989pub struct _MonoGenericClass {
5990 _unused: [u8; 0],
5991}
5992pub type MonoGenericClass = _MonoGenericClass;
5993#[repr(C)]
5994#[derive(Debug, Copy, Clone)]
5995pub struct _MonoGenericContext {
5996 _unused: [u8; 0],
5997}
5998pub type MonoGenericContext = _MonoGenericContext;
5999#[repr(C)]
6000#[derive(Debug, Copy, Clone)]
6001pub struct _MonoGenericContainer {
6002 _unused: [u8; 0],
6003}
6004pub type MonoGenericContainer = _MonoGenericContainer;
6005#[repr(C)]
6006#[derive(Debug, Copy, Clone)]
6007pub struct _MonoGenericParam {
6008 _unused: [u8; 0],
6009}
6010pub type MonoGenericParam = _MonoGenericParam;
6011pub type MonoArrayType = _MonoArrayType;
6012#[repr(C)]
6013#[derive(Debug, Copy, Clone)]
6014pub struct _MonoMethodSignature {
6015 _unused: [u8; 0],
6016}
6017pub type MonoMethodSignature = _MonoMethodSignature;
6018#[repr(C)]
6019#[derive(Debug, Copy, Clone)]
6020pub struct invalid_name {
6021 _unused: [u8; 0],
6022}
6023pub type MonoGenericMethod = invalid_name;
6024#[repr(C)]
6025#[repr(align(4))]
6026#[derive(Debug, Copy, Clone)]
6027pub struct MonoCustomMod {
6028 pub _bitfield_align_1: [u32; 0],
6029 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6030}
6031#[test]
6032fn bindgen_test_layout_MonoCustomMod() {
6033 assert_eq!(
6034 ::std::mem::size_of::<MonoCustomMod>(),
6035 4usize,
6036 concat!("Size of: ", stringify!(MonoCustomMod))
6037 );
6038 assert_eq!(
6039 ::std::mem::align_of::<MonoCustomMod>(),
6040 4usize,
6041 concat!("Alignment of ", stringify!(MonoCustomMod))
6042 );
6043}
6044impl MonoCustomMod {
6045 #[inline]
6046 pub fn required(&self) -> ::std::os::raw::c_uint {
6047 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6048 }
6049 #[inline]
6050 pub fn set_required(&mut self, val: ::std::os::raw::c_uint) {
6051 unsafe {
6052 let val: u32 = ::std::mem::transmute(val);
6053 self._bitfield_1.set(0usize, 1u8, val as u64)
6054 }
6055 }
6056 #[inline]
6057 pub fn token(&self) -> ::std::os::raw::c_uint {
6058 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
6059 }
6060 #[inline]
6061 pub fn set_token(&mut self, val: ::std::os::raw::c_uint) {
6062 unsafe {
6063 let val: u32 = ::std::mem::transmute(val);
6064 self._bitfield_1.set(1usize, 31u8, val as u64)
6065 }
6066 }
6067 #[inline]
6068 pub fn new_bitfield_1(
6069 required: ::std::os::raw::c_uint,
6070 token: ::std::os::raw::c_uint,
6071 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6072 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6073 __bindgen_bitfield_unit.set(0usize, 1u8, {
6074 let required: u32 = unsafe { ::std::mem::transmute(required) };
6075 required as u64
6076 });
6077 __bindgen_bitfield_unit.set(1usize, 31u8, {
6078 let token: u32 = unsafe { ::std::mem::transmute(token) };
6079 token as u64
6080 });
6081 __bindgen_bitfield_unit
6082 }
6083}
6084#[repr(C)]
6085#[derive(Debug, Copy, Clone)]
6086pub struct _MonoCustomModContainer {
6087 pub count: u8,
6088 pub image: *mut MonoImage,
6089 pub modifiers: [MonoCustomMod; 1usize],
6090}
6091#[test]
6092fn bindgen_test_layout__MonoCustomModContainer() {
6093 assert_eq!(
6094 ::std::mem::size_of::<_MonoCustomModContainer>(),
6095 24usize,
6096 concat!("Size of: ", stringify!(_MonoCustomModContainer))
6097 );
6098 assert_eq!(
6099 ::std::mem::align_of::<_MonoCustomModContainer>(),
6100 8usize,
6101 concat!("Alignment of ", stringify!(_MonoCustomModContainer))
6102 );
6103 fn test_field_count() {
6104 assert_eq!(
6105 unsafe {
6106 let uninit = ::std::mem::MaybeUninit::<_MonoCustomModContainer>::uninit();
6107 let ptr = uninit.as_ptr();
6108 ::std::ptr::addr_of!((*ptr).count) as usize - ptr as usize
6109 },
6110 0usize,
6111 concat!(
6112 "Offset of field: ",
6113 stringify!(_MonoCustomModContainer),
6114 "::",
6115 stringify!(count)
6116 )
6117 );
6118 }
6119 test_field_count();
6120 fn test_field_image() {
6121 assert_eq!(
6122 unsafe {
6123 let uninit = ::std::mem::MaybeUninit::<_MonoCustomModContainer>::uninit();
6124 let ptr = uninit.as_ptr();
6125 ::std::ptr::addr_of!((*ptr).image) as usize - ptr as usize
6126 },
6127 8usize,
6128 concat!(
6129 "Offset of field: ",
6130 stringify!(_MonoCustomModContainer),
6131 "::",
6132 stringify!(image)
6133 )
6134 );
6135 }
6136 test_field_image();
6137 fn test_field_modifiers() {
6138 assert_eq!(
6139 unsafe {
6140 let uninit = ::std::mem::MaybeUninit::<_MonoCustomModContainer>::uninit();
6141 let ptr = uninit.as_ptr();
6142 ::std::ptr::addr_of!((*ptr).modifiers) as usize - ptr as usize
6143 },
6144 16usize,
6145 concat!(
6146 "Offset of field: ",
6147 stringify!(_MonoCustomModContainer),
6148 "::",
6149 stringify!(modifiers)
6150 )
6151 );
6152 }
6153 test_field_modifiers();
6154}
6155pub type MonoCustomModContainer = _MonoCustomModContainer;
6156#[repr(C)]
6157#[derive(Debug, Copy, Clone)]
6158pub struct _MonoArrayType {
6159 pub eklass: *mut MonoClass,
6160 pub rank: u8,
6161 pub numsizes: u8,
6162 pub numlobounds: u8,
6163 pub sizes: *mut ::std::os::raw::c_int,
6164 pub lobounds: *mut ::std::os::raw::c_int,
6165}
6166#[test]
6167fn bindgen_test_layout__MonoArrayType() {
6168 assert_eq!(
6169 ::std::mem::size_of::<_MonoArrayType>(),
6170 32usize,
6171 concat!("Size of: ", stringify!(_MonoArrayType))
6172 );
6173 assert_eq!(
6174 ::std::mem::align_of::<_MonoArrayType>(),
6175 8usize,
6176 concat!("Alignment of ", stringify!(_MonoArrayType))
6177 );
6178 fn test_field_eklass() {
6179 assert_eq!(
6180 unsafe {
6181 let uninit = ::std::mem::MaybeUninit::<_MonoArrayType>::uninit();
6182 let ptr = uninit.as_ptr();
6183 ::std::ptr::addr_of!((*ptr).eklass) as usize - ptr as usize
6184 },
6185 0usize,
6186 concat!(
6187 "Offset of field: ",
6188 stringify!(_MonoArrayType),
6189 "::",
6190 stringify!(eklass)
6191 )
6192 );
6193 }
6194 test_field_eklass();
6195 fn test_field_rank() {
6196 assert_eq!(
6197 unsafe {
6198 let uninit = ::std::mem::MaybeUninit::<_MonoArrayType>::uninit();
6199 let ptr = uninit.as_ptr();
6200 ::std::ptr::addr_of!((*ptr).rank) as usize - ptr as usize
6201 },
6202 8usize,
6203 concat!(
6204 "Offset of field: ",
6205 stringify!(_MonoArrayType),
6206 "::",
6207 stringify!(rank)
6208 )
6209 );
6210 }
6211 test_field_rank();
6212 fn test_field_numsizes() {
6213 assert_eq!(
6214 unsafe {
6215 let uninit = ::std::mem::MaybeUninit::<_MonoArrayType>::uninit();
6216 let ptr = uninit.as_ptr();
6217 ::std::ptr::addr_of!((*ptr).numsizes) as usize - ptr as usize
6218 },
6219 9usize,
6220 concat!(
6221 "Offset of field: ",
6222 stringify!(_MonoArrayType),
6223 "::",
6224 stringify!(numsizes)
6225 )
6226 );
6227 }
6228 test_field_numsizes();
6229 fn test_field_numlobounds() {
6230 assert_eq!(
6231 unsafe {
6232 let uninit = ::std::mem::MaybeUninit::<_MonoArrayType>::uninit();
6233 let ptr = uninit.as_ptr();
6234 ::std::ptr::addr_of!((*ptr).numlobounds) as usize - ptr as usize
6235 },
6236 10usize,
6237 concat!(
6238 "Offset of field: ",
6239 stringify!(_MonoArrayType),
6240 "::",
6241 stringify!(numlobounds)
6242 )
6243 );
6244 }
6245 test_field_numlobounds();
6246 fn test_field_sizes() {
6247 assert_eq!(
6248 unsafe {
6249 let uninit = ::std::mem::MaybeUninit::<_MonoArrayType>::uninit();
6250 let ptr = uninit.as_ptr();
6251 ::std::ptr::addr_of!((*ptr).sizes) as usize - ptr as usize
6252 },
6253 16usize,
6254 concat!(
6255 "Offset of field: ",
6256 stringify!(_MonoArrayType),
6257 "::",
6258 stringify!(sizes)
6259 )
6260 );
6261 }
6262 test_field_sizes();
6263 fn test_field_lobounds() {
6264 assert_eq!(
6265 unsafe {
6266 let uninit = ::std::mem::MaybeUninit::<_MonoArrayType>::uninit();
6267 let ptr = uninit.as_ptr();
6268 ::std::ptr::addr_of!((*ptr).lobounds) as usize - ptr as usize
6269 },
6270 24usize,
6271 concat!(
6272 "Offset of field: ",
6273 stringify!(_MonoArrayType),
6274 "::",
6275 stringify!(lobounds)
6276 )
6277 );
6278 }
6279 test_field_lobounds();
6280}
6281#[repr(C)]
6282#[derive(Debug, Copy, Clone)]
6283pub struct _MonoMethodHeader {
6284 _unused: [u8; 0],
6285}
6286pub type MonoMethodHeader = _MonoMethodHeader;
6287pub const MonoParseTypeMode_MONO_PARSE_TYPE: MonoParseTypeMode = 0;
6288pub const MonoParseTypeMode_MONO_PARSE_MOD_TYPE: MonoParseTypeMode = 1;
6289pub const MonoParseTypeMode_MONO_PARSE_LOCAL: MonoParseTypeMode = 2;
6290pub const MonoParseTypeMode_MONO_PARSE_PARAM: MonoParseTypeMode = 3;
6291pub const MonoParseTypeMode_MONO_PARSE_RET: MonoParseTypeMode = 4;
6292pub const MonoParseTypeMode_MONO_PARSE_FIELD: MonoParseTypeMode = 5;
6293pub type MonoParseTypeMode = ::std::os::raw::c_uint;
6294extern "C" {
6295 pub fn mono_type_is_byref(type_: *mut MonoType) -> mono_bool;
6296}
6297extern "C" {
6298 pub fn mono_type_get_type(type_: *mut MonoType) -> ::std::os::raw::c_int;
6299}
6300extern "C" {
6301 pub fn mono_type_get_signature(type_: *mut MonoType) -> *mut MonoMethodSignature;
6302}
6303extern "C" {
6304 pub fn mono_type_get_class(type_: *mut MonoType) -> *mut MonoClass;
6305}
6306extern "C" {
6307 pub fn mono_type_get_array_type(type_: *mut MonoType) -> *mut MonoArrayType;
6308}
6309extern "C" {
6310 pub fn mono_type_get_ptr_type(type_: *mut MonoType) -> *mut MonoType;
6311}
6312extern "C" {
6313 pub fn mono_type_get_modifiers(
6314 type_: *mut MonoType,
6315 is_required: *mut mono_bool,
6316 iter: *mut *mut ::std::os::raw::c_void,
6317 ) -> *mut MonoClass;
6318}
6319extern "C" {
6320 pub fn mono_type_is_struct(type_: *mut MonoType) -> mono_bool;
6321}
6322extern "C" {
6323 pub fn mono_type_is_void(type_: *mut MonoType) -> mono_bool;
6324}
6325extern "C" {
6326 pub fn mono_type_is_pointer(type_: *mut MonoType) -> mono_bool;
6327}
6328extern "C" {
6329 pub fn mono_type_is_reference(type_: *mut MonoType) -> mono_bool;
6330}
6331extern "C" {
6332 pub fn mono_type_is_generic_parameter(type_: *mut MonoType) -> mono_bool;
6333}
6334extern "C" {
6335 pub fn mono_signature_get_return_type(sig: *mut MonoMethodSignature) -> *mut MonoType;
6336}
6337extern "C" {
6338 pub fn mono_signature_get_params(
6339 sig: *mut MonoMethodSignature,
6340 iter: *mut *mut ::std::os::raw::c_void,
6341 ) -> *mut MonoType;
6342}
6343extern "C" {
6344 pub fn mono_signature_get_param_count(sig: *mut MonoMethodSignature) -> u32;
6345}
6346extern "C" {
6347 pub fn mono_signature_get_call_conv(sig: *mut MonoMethodSignature) -> u32;
6348}
6349extern "C" {
6350 pub fn mono_signature_vararg_start(sig: *mut MonoMethodSignature) -> ::std::os::raw::c_int;
6351}
6352extern "C" {
6353 pub fn mono_signature_is_instance(sig: *mut MonoMethodSignature) -> mono_bool;
6354}
6355extern "C" {
6356 pub fn mono_signature_explicit_this(sig: *mut MonoMethodSignature) -> mono_bool;
6357}
6358extern "C" {
6359 pub fn mono_signature_param_is_out(
6360 sig: *mut MonoMethodSignature,
6361 param_num: ::std::os::raw::c_int,
6362 ) -> mono_bool;
6363}
6364extern "C" {
6365 pub fn mono_metadata_parse_typedef_or_ref(
6366 m: *mut MonoImage,
6367 ptr: *const ::std::os::raw::c_char,
6368 rptr: *mut *const ::std::os::raw::c_char,
6369 ) -> u32;
6370}
6371extern "C" {
6372 pub fn mono_metadata_parse_custom_mod(
6373 m: *mut MonoImage,
6374 dest: *mut MonoCustomMod,
6375 ptr: *const ::std::os::raw::c_char,
6376 rptr: *mut *const ::std::os::raw::c_char,
6377 ) -> ::std::os::raw::c_int;
6378}
6379extern "C" {
6380 pub fn mono_metadata_parse_array(
6381 m: *mut MonoImage,
6382 ptr: *const ::std::os::raw::c_char,
6383 rptr: *mut *const ::std::os::raw::c_char,
6384 ) -> *mut MonoArrayType;
6385}
6386extern "C" {
6387 pub fn mono_metadata_free_array(array: *mut MonoArrayType);
6388}
6389extern "C" {
6390 pub fn mono_metadata_parse_type(
6391 m: *mut MonoImage,
6392 mode: MonoParseTypeMode,
6393 opt_attrs: ::std::os::raw::c_short,
6394 ptr: *const ::std::os::raw::c_char,
6395 rptr: *mut *const ::std::os::raw::c_char,
6396 ) -> *mut MonoType;
6397}
6398extern "C" {
6399 pub fn mono_metadata_parse_param(
6400 m: *mut MonoImage,
6401 ptr: *const ::std::os::raw::c_char,
6402 rptr: *mut *const ::std::os::raw::c_char,
6403 ) -> *mut MonoType;
6404}
6405extern "C" {
6406 pub fn mono_metadata_parse_field_type(
6407 m: *mut MonoImage,
6408 field_flags: ::std::os::raw::c_short,
6409 ptr: *const ::std::os::raw::c_char,
6410 rptr: *mut *const ::std::os::raw::c_char,
6411 ) -> *mut MonoType;
6412}
6413extern "C" {
6414 pub fn mono_type_create_from_typespec(image: *mut MonoImage, type_spec: u32) -> *mut MonoType;
6415}
6416extern "C" {
6417 pub fn mono_metadata_free_type(type_: *mut MonoType);
6418}
6419extern "C" {
6420 pub fn mono_type_size(
6421 type_: *mut MonoType,
6422 alignment: *mut ::std::os::raw::c_int,
6423 ) -> ::std::os::raw::c_int;
6424}
6425extern "C" {
6426 pub fn mono_type_stack_size(
6427 type_: *mut MonoType,
6428 alignment: *mut ::std::os::raw::c_int,
6429 ) -> ::std::os::raw::c_int;
6430}
6431extern "C" {
6432 pub fn mono_type_generic_inst_is_valuetype(type_: *mut MonoType) -> mono_bool;
6433}
6434extern "C" {
6435 pub fn mono_metadata_generic_class_is_valuetype(gclass: *mut MonoGenericClass) -> mono_bool;
6436}
6437extern "C" {
6438 pub fn mono_metadata_type_hash(t1: *mut MonoType) -> ::std::os::raw::c_uint;
6439}
6440extern "C" {
6441 pub fn mono_metadata_type_equal(t1: *mut MonoType, t2: *mut MonoType) -> mono_bool;
6442}
6443extern "C" {
6444 pub fn mono_metadata_signature_alloc(
6445 image: *mut MonoImage,
6446 nparams: u32,
6447 ) -> *mut MonoMethodSignature;
6448}
6449extern "C" {
6450 pub fn mono_metadata_signature_dup(sig: *mut MonoMethodSignature) -> *mut MonoMethodSignature;
6451}
6452extern "C" {
6453 pub fn mono_metadata_parse_signature(
6454 image: *mut MonoImage,
6455 token: u32,
6456 ) -> *mut MonoMethodSignature;
6457}
6458extern "C" {
6459 pub fn mono_metadata_parse_method_signature(
6460 m: *mut MonoImage,
6461 def: ::std::os::raw::c_int,
6462 ptr: *const ::std::os::raw::c_char,
6463 rptr: *mut *const ::std::os::raw::c_char,
6464 ) -> *mut MonoMethodSignature;
6465}
6466extern "C" {
6467 pub fn mono_metadata_free_method_signature(method: *mut MonoMethodSignature);
6468}
6469extern "C" {
6470 pub fn mono_metadata_signature_equal(
6471 sig1: *mut MonoMethodSignature,
6472 sig2: *mut MonoMethodSignature,
6473 ) -> mono_bool;
6474}
6475extern "C" {
6476 pub fn mono_signature_hash(sig: *mut MonoMethodSignature) -> ::std::os::raw::c_uint;
6477}
6478extern "C" {
6479 pub fn mono_metadata_parse_mh(
6480 m: *mut MonoImage,
6481 ptr: *const ::std::os::raw::c_char,
6482 ) -> *mut MonoMethodHeader;
6483}
6484extern "C" {
6485 pub fn mono_metadata_free_mh(mh: *mut MonoMethodHeader);
6486}
6487extern "C" {
6488 pub fn mono_method_header_get_code(
6489 header: *mut MonoMethodHeader,
6490 code_size: *mut u32,
6491 max_stack: *mut u32,
6492 ) -> *const ::std::os::raw::c_uchar;
6493}
6494extern "C" {
6495 pub fn mono_method_header_get_locals(
6496 header: *mut MonoMethodHeader,
6497 num_locals: *mut u32,
6498 init_locals: *mut mono_bool,
6499 ) -> *mut *mut MonoType;
6500}
6501extern "C" {
6502 pub fn mono_method_header_get_num_clauses(
6503 header: *mut MonoMethodHeader,
6504 ) -> ::std::os::raw::c_int;
6505}
6506extern "C" {
6507 pub fn mono_method_header_get_clauses(
6508 header: *mut MonoMethodHeader,
6509 method: *mut MonoMethod,
6510 iter: *mut *mut ::std::os::raw::c_void,
6511 clause: *mut MonoExceptionClause,
6512 ) -> ::std::os::raw::c_int;
6513}
6514extern "C" {
6515 pub fn mono_type_to_unmanaged(
6516 type_: *mut MonoType,
6517 mspec: *mut MonoMarshalSpec,
6518 as_field: mono_bool,
6519 unicode: mono_bool,
6520 conv: *mut MonoMarshalConv,
6521 ) -> u32;
6522}
6523extern "C" {
6524 pub fn mono_metadata_token_from_dor(dor_index: u32) -> u32;
6525}
6526extern "C" {
6527 pub fn mono_guid_to_string(guid: *const u8) -> *mut ::std::os::raw::c_char;
6528}
6529extern "C" {
6530 pub fn mono_guid_to_string_minimal(guid: *const u8) -> *mut ::std::os::raw::c_char;
6531}
6532extern "C" {
6533 pub fn mono_metadata_declsec_from_index(meta: *mut MonoImage, idx: u32) -> u32;
6534}
6535extern "C" {
6536 pub fn mono_metadata_translate_token_index(
6537 image: *mut MonoImage,
6538 table: ::std::os::raw::c_int,
6539 idx: u32,
6540 ) -> u32;
6541}
6542extern "C" {
6543 pub fn mono_metadata_decode_table_row(
6544 image: *mut MonoImage,
6545 table: ::std::os::raw::c_int,
6546 idx: ::std::os::raw::c_int,
6547 res: *mut u32,
6548 res_size: ::std::os::raw::c_int,
6549 );
6550}
6551extern "C" {
6552 pub fn mono_metadata_decode_table_row_col(
6553 image: *mut MonoImage,
6554 table: ::std::os::raw::c_int,
6555 idx: ::std::os::raw::c_int,
6556 col: ::std::os::raw::c_uint,
6557 ) -> u32;
6558}
6559pub type MonoStackWalk = ::std::option::Option<
6560 unsafe extern "C" fn(
6561 method: *mut MonoMethod,
6562 native_offset: i32,
6563 il_offset: i32,
6564 managed: mono_bool,
6565 data: *mut ::std::os::raw::c_void,
6566 ) -> mono_bool,
6567>;
6568extern "C" {
6569 pub fn mono_get_method(
6570 image: *mut MonoImage,
6571 token: u32,
6572 klass: *mut MonoClass,
6573 ) -> *mut MonoMethod;
6574}
6575extern "C" {
6576 pub fn mono_get_method_full(
6577 image: *mut MonoImage,
6578 token: u32,
6579 klass: *mut MonoClass,
6580 context: *mut MonoGenericContext,
6581 ) -> *mut MonoMethod;
6582}
6583extern "C" {
6584 pub fn mono_get_method_constrained(
6585 image: *mut MonoImage,
6586 token: u32,
6587 constrained_class: *mut MonoClass,
6588 context: *mut MonoGenericContext,
6589 cil_method: *mut *mut MonoMethod,
6590 ) -> *mut MonoMethod;
6591}
6592extern "C" {
6593 pub fn mono_free_method(method: *mut MonoMethod);
6594}
6595extern "C" {
6596 pub fn mono_method_get_signature_full(
6597 method: *mut MonoMethod,
6598 image: *mut MonoImage,
6599 token: u32,
6600 context: *mut MonoGenericContext,
6601 ) -> *mut MonoMethodSignature;
6602}
6603extern "C" {
6604 pub fn mono_method_get_signature(
6605 method: *mut MonoMethod,
6606 image: *mut MonoImage,
6607 token: u32,
6608 ) -> *mut MonoMethodSignature;
6609}
6610extern "C" {
6611 pub fn mono_method_signature(method: *mut MonoMethod) -> *mut MonoMethodSignature;
6612}
6613extern "C" {
6614 pub fn mono_method_get_header(method: *mut MonoMethod) -> *mut MonoMethodHeader;
6615}
6616extern "C" {
6617 pub fn mono_method_get_name(method: *mut MonoMethod) -> *const ::std::os::raw::c_char;
6618}
6619extern "C" {
6620 pub fn mono_method_get_class(method: *mut MonoMethod) -> *mut MonoClass;
6621}
6622extern "C" {
6623 pub fn mono_method_get_token(method: *mut MonoMethod) -> u32;
6624}
6625extern "C" {
6626 pub fn mono_method_get_flags(method: *mut MonoMethod, iflags: *mut u32) -> u32;
6627}
6628extern "C" {
6629 pub fn mono_method_get_index(method: *mut MonoMethod) -> u32;
6630}
6631extern "C" {
6632 pub fn mono_add_internal_call(
6633 name: *const ::std::os::raw::c_char,
6634 method: *const ::std::os::raw::c_void,
6635 );
6636}
6637extern "C" {
6638 pub fn mono_dangerous_add_raw_internal_call(
6639 name: *const ::std::os::raw::c_char,
6640 method: *const ::std::os::raw::c_void,
6641 );
6642}
6643extern "C" {
6644 pub fn mono_lookup_internal_call(method: *mut MonoMethod) -> *mut ::std::os::raw::c_void;
6645}
6646extern "C" {
6647 pub fn mono_lookup_icall_symbol(m: *mut MonoMethod) -> *const ::std::os::raw::c_char;
6648}
6649extern "C" {
6650 pub fn mono_dllmap_insert(
6651 assembly: *mut MonoImage,
6652 dll: *const ::std::os::raw::c_char,
6653 func: *const ::std::os::raw::c_char,
6654 tdll: *const ::std::os::raw::c_char,
6655 tfunc: *const ::std::os::raw::c_char,
6656 );
6657}
6658extern "C" {
6659 pub fn mono_lookup_pinvoke_call(
6660 method: *mut MonoMethod,
6661 exc_class: *mut *const ::std::os::raw::c_char,
6662 exc_arg: *mut *const ::std::os::raw::c_char,
6663 ) -> *mut ::std::os::raw::c_void;
6664}
6665extern "C" {
6666 pub fn mono_method_get_param_names(
6667 method: *mut MonoMethod,
6668 names: *mut *const ::std::os::raw::c_char,
6669 );
6670}
6671extern "C" {
6672 pub fn mono_method_get_param_token(method: *mut MonoMethod, idx: ::std::os::raw::c_int) -> u32;
6673}
6674extern "C" {
6675 pub fn mono_method_get_marshal_info(method: *mut MonoMethod, mspecs: *mut *mut MonoMarshalSpec);
6676}
6677extern "C" {
6678 pub fn mono_method_has_marshal_info(method: *mut MonoMethod) -> mono_bool;
6679}
6680extern "C" {
6681 pub fn mono_method_get_last_managed() -> *mut MonoMethod;
6682}
6683extern "C" {
6684 pub fn mono_stack_walk(func: MonoStackWalk, user_data: *mut ::std::os::raw::c_void);
6685}
6686extern "C" {
6687 pub fn mono_stack_walk_no_il(func: MonoStackWalk, user_data: *mut ::std::os::raw::c_void);
6688}
6689pub type MonoStackWalkAsyncSafe = ::std::option::Option<
6690 unsafe extern "C" fn(
6691 method: *mut MonoMethod,
6692 domain: *mut MonoDomain,
6693 base_address: *mut ::std::os::raw::c_void,
6694 offset: ::std::os::raw::c_int,
6695 data: *mut ::std::os::raw::c_void,
6696 ) -> mono_bool,
6697>;
6698extern "C" {
6699 pub fn mono_stack_walk_async_safe(
6700 func: MonoStackWalkAsyncSafe,
6701 initial_sig_context: *mut ::std::os::raw::c_void,
6702 user_data: *mut ::std::os::raw::c_void,
6703 );
6704}
6705extern "C" {
6706 pub fn mono_method_get_header_checked(
6707 method: *mut MonoMethod,
6708 error: *mut MonoError,
6709 ) -> *mut MonoMethodHeader;
6710}
6711#[repr(C)]
6712#[derive(Debug, Copy, Clone)]
6713pub struct MonoVTable {
6714 _unused: [u8; 0],
6715}
6716#[repr(C)]
6717#[derive(Debug, Copy, Clone)]
6718pub struct _MonoClassField {
6719 _unused: [u8; 0],
6720}
6721pub type MonoClassField = _MonoClassField;
6722#[repr(C)]
6723#[derive(Debug, Copy, Clone)]
6724pub struct _MonoProperty {
6725 _unused: [u8; 0],
6726}
6727pub type MonoProperty = _MonoProperty;
6728#[repr(C)]
6729#[derive(Debug, Copy, Clone)]
6730pub struct _MonoEvent {
6731 _unused: [u8; 0],
6732}
6733pub type MonoEvent = _MonoEvent;
6734pub const MonoTypeNameFormat_MONO_TYPE_NAME_FORMAT_IL: MonoTypeNameFormat = 0;
6735pub const MonoTypeNameFormat_MONO_TYPE_NAME_FORMAT_REFLECTION: MonoTypeNameFormat = 1;
6736pub const MonoTypeNameFormat_MONO_TYPE_NAME_FORMAT_FULL_NAME: MonoTypeNameFormat = 2;
6737pub const MonoTypeNameFormat_MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED: MonoTypeNameFormat = 3;
6738pub type MonoTypeNameFormat = ::std::os::raw::c_uint;
6739extern "C" {
6740 pub fn mono_class_get(image: *mut MonoImage, type_token: u32) -> *mut MonoClass;
6741}
6742extern "C" {
6743 pub fn mono_class_get_full(
6744 image: *mut MonoImage,
6745 type_token: u32,
6746 context: *mut MonoGenericContext,
6747 ) -> *mut MonoClass;
6748}
6749extern "C" {
6750 pub fn mono_class_init(klass: *mut MonoClass) -> mono_bool;
6751}
6752extern "C" {
6753 pub fn mono_class_vtable(domain: *mut MonoDomain, klass: *mut MonoClass) -> *mut MonoVTable;
6754}
6755extern "C" {
6756 pub fn mono_class_from_name(
6757 image: *mut MonoImage,
6758 name_space: *const ::std::os::raw::c_char,
6759 name: *const ::std::os::raw::c_char,
6760 ) -> *mut MonoClass;
6761}
6762extern "C" {
6763 pub fn mono_class_from_name_case(
6764 image: *mut MonoImage,
6765 name_space: *const ::std::os::raw::c_char,
6766 name: *const ::std::os::raw::c_char,
6767 ) -> *mut MonoClass;
6768}
6769extern "C" {
6770 pub fn mono_class_get_method_from_name_flags(
6771 klass: *mut MonoClass,
6772 name: *const ::std::os::raw::c_char,
6773 param_count: ::std::os::raw::c_int,
6774 flags: ::std::os::raw::c_int,
6775 ) -> *mut MonoMethod;
6776}
6777extern "C" {
6778 pub fn mono_class_from_typeref(image: *mut MonoImage, type_token: u32) -> *mut MonoClass;
6779}
6780extern "C" {
6781 pub fn mono_class_from_typeref_checked(
6782 image: *mut MonoImage,
6783 type_token: u32,
6784 error: *mut MonoError,
6785 ) -> *mut MonoClass;
6786}
6787extern "C" {
6788 pub fn mono_class_from_generic_parameter(
6789 param: *mut MonoGenericParam,
6790 image: *mut MonoImage,
6791 is_mvar: mono_bool,
6792 ) -> *mut MonoClass;
6793}
6794extern "C" {
6795 pub fn mono_class_inflate_generic_type(
6796 type_: *mut MonoType,
6797 context: *mut MonoGenericContext,
6798 ) -> *mut MonoType;
6799}
6800extern "C" {
6801 pub fn mono_class_inflate_generic_method(
6802 method: *mut MonoMethod,
6803 context: *mut MonoGenericContext,
6804 ) -> *mut MonoMethod;
6805}
6806extern "C" {
6807 pub fn mono_get_inflated_method(method: *mut MonoMethod) -> *mut MonoMethod;
6808}
6809extern "C" {
6810 pub fn mono_field_from_token(
6811 image: *mut MonoImage,
6812 token: u32,
6813 retklass: *mut *mut MonoClass,
6814 context: *mut MonoGenericContext,
6815 ) -> *mut MonoClassField;
6816}
6817extern "C" {
6818 pub fn mono_bounded_array_class_get(
6819 element_class: *mut MonoClass,
6820 rank: u32,
6821 bounded: mono_bool,
6822 ) -> *mut MonoClass;
6823}
6824extern "C" {
6825 pub fn mono_array_class_get(element_class: *mut MonoClass, rank: u32) -> *mut MonoClass;
6826}
6827extern "C" {
6828 pub fn mono_ptr_class_get(type_: *mut MonoType) -> *mut MonoClass;
6829}
6830extern "C" {
6831 pub fn mono_class_get_field(klass: *mut MonoClass, field_token: u32) -> *mut MonoClassField;
6832}
6833extern "C" {
6834 pub fn mono_class_get_field_from_name(
6835 klass: *mut MonoClass,
6836 name: *const ::std::os::raw::c_char,
6837 ) -> *mut MonoClassField;
6838}
6839extern "C" {
6840 pub fn mono_class_get_field_token(field: *mut MonoClassField) -> u32;
6841}
6842extern "C" {
6843 pub fn mono_class_get_event_token(event: *mut MonoEvent) -> u32;
6844}
6845extern "C" {
6846 pub fn mono_class_get_property_from_name(
6847 klass: *mut MonoClass,
6848 name: *const ::std::os::raw::c_char,
6849 ) -> *mut MonoProperty;
6850}
6851extern "C" {
6852 pub fn mono_class_get_property_token(prop: *mut MonoProperty) -> u32;
6853}
6854extern "C" {
6855 pub fn mono_array_element_size(ac: *mut MonoClass) -> i32;
6856}
6857extern "C" {
6858 pub fn mono_class_instance_size(klass: *mut MonoClass) -> i32;
6859}
6860extern "C" {
6861 pub fn mono_class_array_element_size(klass: *mut MonoClass) -> i32;
6862}
6863extern "C" {
6864 pub fn mono_class_data_size(klass: *mut MonoClass) -> i32;
6865}
6866extern "C" {
6867 pub fn mono_class_value_size(klass: *mut MonoClass, align: *mut u32) -> i32;
6868}
6869extern "C" {
6870 pub fn mono_class_min_align(klass: *mut MonoClass) -> i32;
6871}
6872extern "C" {
6873 pub fn mono_class_from_mono_type(type_: *mut MonoType) -> *mut MonoClass;
6874}
6875extern "C" {
6876 pub fn mono_class_is_subclass_of(
6877 klass: *mut MonoClass,
6878 klassc: *mut MonoClass,
6879 check_interfaces: mono_bool,
6880 ) -> mono_bool;
6881}
6882extern "C" {
6883 pub fn mono_class_is_assignable_from(
6884 klass: *mut MonoClass,
6885 oklass: *mut MonoClass,
6886 ) -> mono_bool;
6887}
6888extern "C" {
6889 pub fn mono_ldtoken(
6890 image: *mut MonoImage,
6891 token: u32,
6892 retclass: *mut *mut MonoClass,
6893 context: *mut MonoGenericContext,
6894 ) -> *mut ::std::os::raw::c_void;
6895}
6896extern "C" {
6897 pub fn mono_type_get_name_full(
6898 type_: *mut MonoType,
6899 format: MonoTypeNameFormat,
6900 ) -> *mut ::std::os::raw::c_char;
6901}
6902extern "C" {
6903 pub fn mono_type_get_name(type_: *mut MonoType) -> *mut ::std::os::raw::c_char;
6904}
6905extern "C" {
6906 pub fn mono_type_get_underlying_type(type_: *mut MonoType) -> *mut MonoType;
6907}
6908extern "C" {
6909 pub fn mono_class_get_image(klass: *mut MonoClass) -> *mut MonoImage;
6910}
6911extern "C" {
6912 pub fn mono_class_get_element_class(klass: *mut MonoClass) -> *mut MonoClass;
6913}
6914extern "C" {
6915 pub fn mono_class_is_valuetype(klass: *mut MonoClass) -> mono_bool;
6916}
6917extern "C" {
6918 pub fn mono_class_is_enum(klass: *mut MonoClass) -> mono_bool;
6919}
6920extern "C" {
6921 pub fn mono_class_enum_basetype(klass: *mut MonoClass) -> *mut MonoType;
6922}
6923extern "C" {
6924 pub fn mono_class_get_parent(klass: *mut MonoClass) -> *mut MonoClass;
6925}
6926extern "C" {
6927 pub fn mono_class_get_nesting_type(klass: *mut MonoClass) -> *mut MonoClass;
6928}
6929extern "C" {
6930 pub fn mono_class_get_rank(klass: *mut MonoClass) -> ::std::os::raw::c_int;
6931}
6932extern "C" {
6933 pub fn mono_class_get_flags(klass: *mut MonoClass) -> u32;
6934}
6935extern "C" {
6936 pub fn mono_class_get_name(klass: *mut MonoClass) -> *const ::std::os::raw::c_char;
6937}
6938extern "C" {
6939 pub fn mono_class_get_namespace(klass: *mut MonoClass) -> *const ::std::os::raw::c_char;
6940}
6941extern "C" {
6942 pub fn mono_class_get_type(klass: *mut MonoClass) -> *mut MonoType;
6943}
6944extern "C" {
6945 pub fn mono_class_get_type_token(klass: *mut MonoClass) -> u32;
6946}
6947extern "C" {
6948 pub fn mono_class_get_byref_type(klass: *mut MonoClass) -> *mut MonoType;
6949}
6950extern "C" {
6951 pub fn mono_class_num_fields(klass: *mut MonoClass) -> ::std::os::raw::c_int;
6952}
6953extern "C" {
6954 pub fn mono_class_num_methods(klass: *mut MonoClass) -> ::std::os::raw::c_int;
6955}
6956extern "C" {
6957 pub fn mono_class_num_properties(klass: *mut MonoClass) -> ::std::os::raw::c_int;
6958}
6959extern "C" {
6960 pub fn mono_class_num_events(klass: *mut MonoClass) -> ::std::os::raw::c_int;
6961}
6962extern "C" {
6963 pub fn mono_class_get_fields(
6964 klass: *mut MonoClass,
6965 iter: *mut *mut ::std::os::raw::c_void,
6966 ) -> *mut MonoClassField;
6967}
6968extern "C" {
6969 pub fn mono_class_get_methods(
6970 klass: *mut MonoClass,
6971 iter: *mut *mut ::std::os::raw::c_void,
6972 ) -> *mut MonoMethod;
6973}
6974extern "C" {
6975 pub fn mono_class_get_properties(
6976 klass: *mut MonoClass,
6977 iter: *mut *mut ::std::os::raw::c_void,
6978 ) -> *mut MonoProperty;
6979}
6980extern "C" {
6981 pub fn mono_class_get_events(
6982 klass: *mut MonoClass,
6983 iter: *mut *mut ::std::os::raw::c_void,
6984 ) -> *mut MonoEvent;
6985}
6986extern "C" {
6987 pub fn mono_class_get_interfaces(
6988 klass: *mut MonoClass,
6989 iter: *mut *mut ::std::os::raw::c_void,
6990 ) -> *mut MonoClass;
6991}
6992extern "C" {
6993 pub fn mono_class_get_nested_types(
6994 klass: *mut MonoClass,
6995 iter: *mut *mut ::std::os::raw::c_void,
6996 ) -> *mut MonoClass;
6997}
6998extern "C" {
6999 pub fn mono_class_is_delegate(klass: *mut MonoClass) -> mono_bool;
7000}
7001extern "C" {
7002 pub fn mono_class_implements_interface(
7003 klass: *mut MonoClass,
7004 iface: *mut MonoClass,
7005 ) -> mono_bool;
7006}
7007extern "C" {
7008 pub fn mono_field_get_name(field: *mut MonoClassField) -> *const ::std::os::raw::c_char;
7009}
7010extern "C" {
7011 pub fn mono_field_get_type(field: *mut MonoClassField) -> *mut MonoType;
7012}
7013extern "C" {
7014 pub fn mono_field_get_parent(field: *mut MonoClassField) -> *mut MonoClass;
7015}
7016extern "C" {
7017 pub fn mono_field_get_flags(field: *mut MonoClassField) -> u32;
7018}
7019extern "C" {
7020 pub fn mono_field_get_offset(field: *mut MonoClassField) -> u32;
7021}
7022extern "C" {
7023 pub fn mono_field_get_data(field: *mut MonoClassField) -> *const ::std::os::raw::c_char;
7024}
7025extern "C" {
7026 pub fn mono_property_get_name(prop: *mut MonoProperty) -> *const ::std::os::raw::c_char;
7027}
7028extern "C" {
7029 pub fn mono_property_get_set_method(prop: *mut MonoProperty) -> *mut MonoMethod;
7030}
7031extern "C" {
7032 pub fn mono_property_get_get_method(prop: *mut MonoProperty) -> *mut MonoMethod;
7033}
7034extern "C" {
7035 pub fn mono_property_get_parent(prop: *mut MonoProperty) -> *mut MonoClass;
7036}
7037extern "C" {
7038 pub fn mono_property_get_flags(prop: *mut MonoProperty) -> u32;
7039}
7040extern "C" {
7041 pub fn mono_event_get_name(event: *mut MonoEvent) -> *const ::std::os::raw::c_char;
7042}
7043extern "C" {
7044 pub fn mono_event_get_add_method(event: *mut MonoEvent) -> *mut MonoMethod;
7045}
7046extern "C" {
7047 pub fn mono_event_get_remove_method(event: *mut MonoEvent) -> *mut MonoMethod;
7048}
7049extern "C" {
7050 pub fn mono_event_get_raise_method(event: *mut MonoEvent) -> *mut MonoMethod;
7051}
7052extern "C" {
7053 pub fn mono_event_get_parent(event: *mut MonoEvent) -> *mut MonoClass;
7054}
7055extern "C" {
7056 pub fn mono_event_get_flags(event: *mut MonoEvent) -> u32;
7057}
7058extern "C" {
7059 pub fn mono_class_get_method_from_name(
7060 klass: *mut MonoClass,
7061 name: *const ::std::os::raw::c_char,
7062 param_count: ::std::os::raw::c_int,
7063 ) -> *mut MonoMethod;
7064}
7065extern "C" {
7066 pub fn mono_class_name_from_token(
7067 image: *mut MonoImage,
7068 type_token: u32,
7069 ) -> *mut ::std::os::raw::c_char;
7070}
7071extern "C" {
7072 pub fn mono_method_can_access_field(
7073 method: *mut MonoMethod,
7074 field: *mut MonoClassField,
7075 ) -> mono_bool;
7076}
7077extern "C" {
7078 pub fn mono_method_can_access_method(
7079 method: *mut MonoMethod,
7080 called: *mut MonoMethod,
7081 ) -> mono_bool;
7082}
7083extern "C" {
7084 pub fn mono_class_is_nullable(klass: *mut MonoClass) -> mono_bool;
7085}
7086extern "C" {
7087 pub fn mono_class_get_nullable_param(klass: *mut MonoClass) -> *mut MonoClass;
7088}
7089#[repr(C)]
7090#[derive(Debug, Copy, Clone)]
7091pub struct _MonoString {
7092 _unused: [u8; 0],
7093}
7094pub type MonoString = _MonoString;
7095#[repr(C)]
7096#[derive(Debug, Copy, Clone)]
7097pub struct _MonoArray {
7098 _unused: [u8; 0],
7099}
7100pub type MonoArray = _MonoArray;
7101#[repr(C)]
7102#[derive(Debug, Copy, Clone)]
7103pub struct _MonoReflectionMethod {
7104 _unused: [u8; 0],
7105}
7106pub type MonoReflectionMethod = _MonoReflectionMethod;
7107#[repr(C)]
7108#[derive(Debug, Copy, Clone)]
7109pub struct _MonoReflectionModule {
7110 _unused: [u8; 0],
7111}
7112pub type MonoReflectionModule = _MonoReflectionModule;
7113#[repr(C)]
7114#[derive(Debug, Copy, Clone)]
7115pub struct _MonoReflectionField {
7116 _unused: [u8; 0],
7117}
7118pub type MonoReflectionField = _MonoReflectionField;
7119#[repr(C)]
7120#[derive(Debug, Copy, Clone)]
7121pub struct _MonoReflectionProperty {
7122 _unused: [u8; 0],
7123}
7124pub type MonoReflectionProperty = _MonoReflectionProperty;
7125#[repr(C)]
7126#[derive(Debug, Copy, Clone)]
7127pub struct _MonoReflectionEvent {
7128 _unused: [u8; 0],
7129}
7130pub type MonoReflectionEvent = _MonoReflectionEvent;
7131#[repr(C)]
7132#[derive(Debug, Copy, Clone)]
7133pub struct _MonoReflectionType {
7134 _unused: [u8; 0],
7135}
7136pub type MonoReflectionType = _MonoReflectionType;
7137#[repr(C)]
7138#[derive(Debug, Copy, Clone)]
7139pub struct _MonoDelegate {
7140 _unused: [u8; 0],
7141}
7142pub type MonoDelegate = _MonoDelegate;
7143#[repr(C)]
7144#[derive(Debug, Copy, Clone)]
7145pub struct _MonoThreadsSync {
7146 _unused: [u8; 0],
7147}
7148pub type MonoThreadsSync = _MonoThreadsSync;
7149#[repr(C)]
7150#[derive(Debug, Copy, Clone)]
7151pub struct _MonoThread {
7152 _unused: [u8; 0],
7153}
7154pub type MonoThread = _MonoThread;
7155#[repr(C)]
7156#[derive(Debug, Copy, Clone)]
7157pub struct _MonoDynamicAssembly {
7158 _unused: [u8; 0],
7159}
7160pub type MonoDynamicAssembly = _MonoDynamicAssembly;
7161#[repr(C)]
7162#[derive(Debug, Copy, Clone)]
7163pub struct _MonoDynamicImage {
7164 _unused: [u8; 0],
7165}
7166pub type MonoDynamicImage = _MonoDynamicImage;
7167#[repr(C)]
7168#[derive(Debug, Copy, Clone)]
7169pub struct _MonoReflectionMethodBody {
7170 _unused: [u8; 0],
7171}
7172pub type MonoReflectionMethodBody = _MonoReflectionMethodBody;
7173#[repr(C)]
7174#[derive(Debug, Copy, Clone)]
7175pub struct _MonoAppContext {
7176 _unused: [u8; 0],
7177}
7178pub type MonoAppContext = _MonoAppContext;
7179#[repr(C)]
7180#[derive(Debug, Copy, Clone)]
7181pub struct _MonoObject {
7182 pub vtable: *mut MonoVTable,
7183 pub synchronisation: *mut MonoThreadsSync,
7184}
7185#[test]
7186fn bindgen_test_layout__MonoObject() {
7187 assert_eq!(
7188 ::std::mem::size_of::<_MonoObject>(),
7189 16usize,
7190 concat!("Size of: ", stringify!(_MonoObject))
7191 );
7192 assert_eq!(
7193 ::std::mem::align_of::<_MonoObject>(),
7194 8usize,
7195 concat!("Alignment of ", stringify!(_MonoObject))
7196 );
7197 fn test_field_vtable() {
7198 assert_eq!(
7199 unsafe {
7200 let uninit = ::std::mem::MaybeUninit::<_MonoObject>::uninit();
7201 let ptr = uninit.as_ptr();
7202 ::std::ptr::addr_of!((*ptr).vtable) as usize - ptr as usize
7203 },
7204 0usize,
7205 concat!(
7206 "Offset of field: ",
7207 stringify!(_MonoObject),
7208 "::",
7209 stringify!(vtable)
7210 )
7211 );
7212 }
7213 test_field_vtable();
7214 fn test_field_synchronisation() {
7215 assert_eq!(
7216 unsafe {
7217 let uninit = ::std::mem::MaybeUninit::<_MonoObject>::uninit();
7218 let ptr = uninit.as_ptr();
7219 ::std::ptr::addr_of!((*ptr).synchronisation) as usize - ptr as usize
7220 },
7221 8usize,
7222 concat!(
7223 "Offset of field: ",
7224 stringify!(_MonoObject),
7225 "::",
7226 stringify!(synchronisation)
7227 )
7228 );
7229 }
7230 test_field_synchronisation();
7231}
7232pub type MonoInvokeFunc = ::std::option::Option<
7233 unsafe extern "C" fn(
7234 method: *mut MonoMethod,
7235 obj: *mut ::std::os::raw::c_void,
7236 params: *mut *mut ::std::os::raw::c_void,
7237 exc: *mut *mut MonoObject,
7238 error: *mut MonoError,
7239 ) -> *mut MonoObject,
7240>;
7241pub type MonoCompileFunc = ::std::option::Option<
7242 unsafe extern "C" fn(method: *mut MonoMethod) -> *mut ::std::os::raw::c_void,
7243>;
7244pub type MonoMainThreadFunc =
7245 ::std::option::Option<unsafe extern "C" fn(user_data: *mut ::std::os::raw::c_void)>;
7246extern "C" {
7247 pub fn mono_string_chars(s: *mut MonoString) -> *mut mono_unichar2;
7248}
7249extern "C" {
7250 pub fn mono_string_length(s: *mut MonoString) -> ::std::os::raw::c_int;
7251}
7252extern "C" {
7253 pub fn mono_object_new(domain: *mut MonoDomain, klass: *mut MonoClass) -> *mut MonoObject;
7254}
7255extern "C" {
7256 pub fn mono_object_new_specific(vtable: *mut MonoVTable) -> *mut MonoObject;
7257}
7258extern "C" {
7259 pub fn mono_object_new_fast(vtable: *mut MonoVTable) -> *mut MonoObject;
7260}
7261extern "C" {
7262 pub fn mono_object_new_alloc_specific(vtable: *mut MonoVTable) -> *mut MonoObject;
7263}
7264extern "C" {
7265 pub fn mono_object_new_from_token(
7266 domain: *mut MonoDomain,
7267 image: *mut MonoImage,
7268 token: u32,
7269 ) -> *mut MonoObject;
7270}
7271extern "C" {
7272 pub fn mono_array_new(
7273 domain: *mut MonoDomain,
7274 eclass: *mut MonoClass,
7275 n: usize,
7276 ) -> *mut MonoArray;
7277}
7278extern "C" {
7279 pub fn mono_array_new_full(
7280 domain: *mut MonoDomain,
7281 array_class: *mut MonoClass,
7282 lengths: *mut usize,
7283 lower_bounds: *mut isize,
7284 ) -> *mut MonoArray;
7285}
7286extern "C" {
7287 pub fn mono_array_new_specific(vtable: *mut MonoVTable, n: usize) -> *mut MonoArray;
7288}
7289extern "C" {
7290 pub fn mono_array_clone(array: *mut MonoArray) -> *mut MonoArray;
7291}
7292extern "C" {
7293 pub fn mono_array_addr_with_size(
7294 array: *mut MonoArray,
7295 size: ::std::os::raw::c_int,
7296 idx: usize,
7297 ) -> *mut ::std::os::raw::c_char;
7298}
7299extern "C" {
7300 pub fn mono_array_length(array: *mut MonoArray) -> usize;
7301}
7302extern "C" {
7303 pub fn mono_string_empty(domain: *mut MonoDomain) -> *mut MonoString;
7304}
7305extern "C" {
7306 pub fn mono_string_empty_wrapper() -> *mut MonoString;
7307}
7308extern "C" {
7309 pub fn mono_string_new_utf16(
7310 domain: *mut MonoDomain,
7311 text: *const mono_unichar2,
7312 len: i32,
7313 ) -> *mut MonoString;
7314}
7315extern "C" {
7316 pub fn mono_string_new_size(domain: *mut MonoDomain, len: i32) -> *mut MonoString;
7317}
7318extern "C" {
7319 pub fn mono_ldstr(
7320 domain: *mut MonoDomain,
7321 image: *mut MonoImage,
7322 str_index: u32,
7323 ) -> *mut MonoString;
7324}
7325extern "C" {
7326 pub fn mono_string_is_interned(str_: *mut MonoString) -> *mut MonoString;
7327}
7328extern "C" {
7329 pub fn mono_string_intern(str_: *mut MonoString) -> *mut MonoString;
7330}
7331extern "C" {
7332 pub fn mono_string_new(
7333 domain: *mut MonoDomain,
7334 text: *const ::std::os::raw::c_char,
7335 ) -> *mut MonoString;
7336}
7337extern "C" {
7338 pub fn mono_string_new_wrapper(text: *const ::std::os::raw::c_char) -> *mut MonoString;
7339}
7340extern "C" {
7341 pub fn mono_string_new_len(
7342 domain: *mut MonoDomain,
7343 text: *const ::std::os::raw::c_char,
7344 length: ::std::os::raw::c_uint,
7345 ) -> *mut MonoString;
7346}
7347extern "C" {
7348 pub fn mono_string_new_utf32(
7349 domain: *mut MonoDomain,
7350 text: *const mono_unichar4,
7351 len: i32,
7352 ) -> *mut MonoString;
7353}
7354extern "C" {
7355 pub fn mono_string_to_utf8(string_obj: *mut MonoString) -> *mut ::std::os::raw::c_char;
7356}
7357extern "C" {
7358 pub fn mono_string_to_utf8_checked(
7359 string_obj: *mut MonoString,
7360 error: *mut MonoError,
7361 ) -> *mut ::std::os::raw::c_char;
7362}
7363extern "C" {
7364 pub fn mono_string_to_utf16(string_obj: *mut MonoString) -> *mut mono_unichar2;
7365}
7366extern "C" {
7367 pub fn mono_string_to_utf32(string_obj: *mut MonoString) -> *mut mono_unichar4;
7368}
7369extern "C" {
7370 pub fn mono_string_from_utf16(data: *mut mono_unichar2) -> *mut MonoString;
7371}
7372extern "C" {
7373 pub fn mono_string_from_utf32(data: *mut mono_unichar4) -> *mut MonoString;
7374}
7375extern "C" {
7376 pub fn mono_string_equal(s1: *mut MonoString, s2: *mut MonoString) -> mono_bool;
7377}
7378extern "C" {
7379 pub fn mono_string_hash(s: *mut MonoString) -> ::std::os::raw::c_uint;
7380}
7381extern "C" {
7382 pub fn mono_object_hash(obj: *mut MonoObject) -> ::std::os::raw::c_int;
7383}
7384extern "C" {
7385 pub fn mono_object_to_string(
7386 obj: *mut MonoObject,
7387 exc: *mut *mut MonoObject,
7388 ) -> *mut MonoString;
7389}
7390extern "C" {
7391 pub fn mono_value_box(
7392 domain: *mut MonoDomain,
7393 klass: *mut MonoClass,
7394 val: *mut ::std::os::raw::c_void,
7395 ) -> *mut MonoObject;
7396}
7397extern "C" {
7398 pub fn mono_value_copy(
7399 dest: *mut ::std::os::raw::c_void,
7400 src: *mut ::std::os::raw::c_void,
7401 klass: *mut MonoClass,
7402 );
7403}
7404extern "C" {
7405 pub fn mono_value_copy_array(
7406 dest: *mut MonoArray,
7407 dest_idx: ::std::os::raw::c_int,
7408 src: *mut ::std::os::raw::c_void,
7409 count: ::std::os::raw::c_int,
7410 );
7411}
7412extern "C" {
7413 pub fn mono_object_get_vtable(obj: *mut MonoObject) -> *mut MonoVTable;
7414}
7415extern "C" {
7416 pub fn mono_object_get_domain(obj: *mut MonoObject) -> *mut MonoDomain;
7417}
7418extern "C" {
7419 pub fn mono_object_get_class(obj: *mut MonoObject) -> *mut MonoClass;
7420}
7421extern "C" {
7422 pub fn mono_object_unbox(obj: *mut MonoObject) -> *mut ::std::os::raw::c_void;
7423}
7424extern "C" {
7425 pub fn mono_object_clone(obj: *mut MonoObject) -> *mut MonoObject;
7426}
7427extern "C" {
7428 pub fn mono_object_isinst(obj: *mut MonoObject, klass: *mut MonoClass) -> *mut MonoObject;
7429}
7430extern "C" {
7431 pub fn mono_object_isinst_mbyref(
7432 obj: *mut MonoObject,
7433 klass: *mut MonoClass,
7434 ) -> *mut MonoObject;
7435}
7436extern "C" {
7437 pub fn mono_object_castclass_mbyref(
7438 obj: *mut MonoObject,
7439 klass: *mut MonoClass,
7440 ) -> *mut MonoObject;
7441}
7442extern "C" {
7443 pub fn mono_monitor_try_enter(obj: *mut MonoObject, ms: u32) -> mono_bool;
7444}
7445extern "C" {
7446 pub fn mono_monitor_enter(obj: *mut MonoObject) -> mono_bool;
7447}
7448extern "C" {
7449 pub fn mono_monitor_enter_v4(obj: *mut MonoObject, lock_taken: *mut ::std::os::raw::c_char);
7450}
7451extern "C" {
7452 pub fn mono_object_get_size(o: *mut MonoObject) -> ::std::os::raw::c_uint;
7453}
7454extern "C" {
7455 pub fn mono_monitor_exit(obj: *mut MonoObject);
7456}
7457extern "C" {
7458 pub fn mono_raise_exception(ex: *mut MonoException);
7459}
7460extern "C" {
7461 pub fn mono_runtime_set_pending_exception(
7462 exc: *mut MonoException,
7463 overwrite: mono_bool,
7464 ) -> mono_bool;
7465}
7466extern "C" {
7467 pub fn mono_reraise_exception(ex: *mut MonoException);
7468}
7469extern "C" {
7470 pub fn mono_runtime_object_init(this_obj: *mut MonoObject);
7471}
7472extern "C" {
7473 pub fn mono_runtime_class_init(vtable: *mut MonoVTable);
7474}
7475extern "C" {
7476 pub fn mono_vtable_domain(vtable: *mut MonoVTable) -> *mut MonoDomain;
7477}
7478extern "C" {
7479 pub fn mono_vtable_class(vtable: *mut MonoVTable) -> *mut MonoClass;
7480}
7481extern "C" {
7482 pub fn mono_object_get_virtual_method(
7483 obj: *mut MonoObject,
7484 method: *mut MonoMethod,
7485 ) -> *mut MonoMethod;
7486}
7487extern "C" {
7488 pub fn mono_runtime_invoke(
7489 method: *mut MonoMethod,
7490 obj: *mut ::std::os::raw::c_void,
7491 params: *mut *mut ::std::os::raw::c_void,
7492 exc: *mut *mut MonoObject,
7493 ) -> *mut MonoObject;
7494}
7495extern "C" {
7496 pub fn mono_get_delegate_invoke(klass: *mut MonoClass) -> *mut MonoMethod;
7497}
7498extern "C" {
7499 pub fn mono_get_delegate_begin_invoke(klass: *mut MonoClass) -> *mut MonoMethod;
7500}
7501extern "C" {
7502 pub fn mono_get_delegate_end_invoke(klass: *mut MonoClass) -> *mut MonoMethod;
7503}
7504extern "C" {
7505 pub fn mono_runtime_delegate_invoke(
7506 delegate: *mut MonoObject,
7507 params: *mut *mut ::std::os::raw::c_void,
7508 exc: *mut *mut MonoObject,
7509 ) -> *mut MonoObject;
7510}
7511extern "C" {
7512 pub fn mono_runtime_invoke_array(
7513 method: *mut MonoMethod,
7514 obj: *mut ::std::os::raw::c_void,
7515 params: *mut MonoArray,
7516 exc: *mut *mut MonoObject,
7517 ) -> *mut MonoObject;
7518}
7519extern "C" {
7520 pub fn mono_method_get_unmanaged_thunk(method: *mut MonoMethod) -> *mut ::std::os::raw::c_void;
7521}
7522extern "C" {
7523 pub fn mono_runtime_get_main_args() -> *mut MonoArray;
7524}
7525extern "C" {
7526 pub fn mono_runtime_exec_managed_code(
7527 domain: *mut MonoDomain,
7528 main_func: MonoMainThreadFunc,
7529 main_args: *mut ::std::os::raw::c_void,
7530 );
7531}
7532extern "C" {
7533 pub fn mono_runtime_run_main(
7534 method: *mut MonoMethod,
7535 argc: ::std::os::raw::c_int,
7536 argv: *mut *mut ::std::os::raw::c_char,
7537 exc: *mut *mut MonoObject,
7538 ) -> ::std::os::raw::c_int;
7539}
7540extern "C" {
7541 pub fn mono_runtime_exec_main(
7542 method: *mut MonoMethod,
7543 args: *mut MonoArray,
7544 exc: *mut *mut MonoObject,
7545 ) -> ::std::os::raw::c_int;
7546}
7547extern "C" {
7548 pub fn mono_runtime_set_main_args(
7549 argc: ::std::os::raw::c_int,
7550 argv: *mut *mut ::std::os::raw::c_char,
7551 ) -> ::std::os::raw::c_int;
7552}
7553extern "C" {
7554 pub fn mono_load_remote_field(
7555 this_obj: *mut MonoObject,
7556 klass: *mut MonoClass,
7557 field: *mut MonoClassField,
7558 res: *mut *mut ::std::os::raw::c_void,
7559 ) -> *mut ::std::os::raw::c_void;
7560}
7561extern "C" {
7562 pub fn mono_load_remote_field_new(
7563 this_obj: *mut MonoObject,
7564 klass: *mut MonoClass,
7565 field: *mut MonoClassField,
7566 ) -> *mut MonoObject;
7567}
7568extern "C" {
7569 pub fn mono_store_remote_field(
7570 this_obj: *mut MonoObject,
7571 klass: *mut MonoClass,
7572 field: *mut MonoClassField,
7573 val: *mut ::std::os::raw::c_void,
7574 );
7575}
7576extern "C" {
7577 pub fn mono_store_remote_field_new(
7578 this_obj: *mut MonoObject,
7579 klass: *mut MonoClass,
7580 field: *mut MonoClassField,
7581 arg: *mut MonoObject,
7582 );
7583}
7584extern "C" {
7585 pub fn mono_unhandled_exception(exc: *mut MonoObject);
7586}
7587extern "C" {
7588 pub fn mono_print_unhandled_exception(exc: *mut MonoObject);
7589}
7590extern "C" {
7591 pub fn mono_compile_method(method: *mut MonoMethod) -> *mut ::std::os::raw::c_void;
7592}
7593extern "C" {
7594 pub fn mono_field_set_value(
7595 obj: *mut MonoObject,
7596 field: *mut MonoClassField,
7597 value: *mut ::std::os::raw::c_void,
7598 );
7599}
7600extern "C" {
7601 pub fn mono_field_static_set_value(
7602 vt: *mut MonoVTable,
7603 field: *mut MonoClassField,
7604 value: *mut ::std::os::raw::c_void,
7605 );
7606}
7607extern "C" {
7608 pub fn mono_field_get_value(
7609 obj: *mut MonoObject,
7610 field: *mut MonoClassField,
7611 value: *mut ::std::os::raw::c_void,
7612 );
7613}
7614extern "C" {
7615 pub fn mono_field_static_get_value(
7616 vt: *mut MonoVTable,
7617 field: *mut MonoClassField,
7618 value: *mut ::std::os::raw::c_void,
7619 );
7620}
7621extern "C" {
7622 pub fn mono_field_get_value_object(
7623 domain: *mut MonoDomain,
7624 field: *mut MonoClassField,
7625 obj: *mut MonoObject,
7626 ) -> *mut MonoObject;
7627}
7628extern "C" {
7629 pub fn mono_property_set_value(
7630 prop: *mut MonoProperty,
7631 obj: *mut ::std::os::raw::c_void,
7632 params: *mut *mut ::std::os::raw::c_void,
7633 exc: *mut *mut MonoObject,
7634 );
7635}
7636extern "C" {
7637 pub fn mono_property_get_value(
7638 prop: *mut MonoProperty,
7639 obj: *mut ::std::os::raw::c_void,
7640 params: *mut *mut ::std::os::raw::c_void,
7641 exc: *mut *mut MonoObject,
7642 ) -> *mut MonoObject;
7643}
7644extern "C" {
7645 pub fn mono_gchandle_new(obj: *mut MonoObject, pinned: mono_bool) -> u32;
7646}
7647extern "C" {
7648 pub fn mono_gchandle_new_weakref(obj: *mut MonoObject, track_resurrection: mono_bool) -> u32;
7649}
7650extern "C" {
7651 pub fn mono_gchandle_get_target(gchandle: u32) -> *mut MonoObject;
7652}
7653extern "C" {
7654 pub fn mono_gchandle_free(gchandle: u32);
7655}
7656pub type mono_reference_queue_callback =
7657 ::std::option::Option<unsafe extern "C" fn(user_data: *mut ::std::os::raw::c_void)>;
7658#[repr(C)]
7659#[derive(Debug, Copy, Clone)]
7660pub struct _MonoReferenceQueue {
7661 _unused: [u8; 0],
7662}
7663pub type MonoReferenceQueue = _MonoReferenceQueue;
7664extern "C" {
7665 pub fn mono_gc_reference_queue_new(
7666 callback: mono_reference_queue_callback,
7667 ) -> *mut MonoReferenceQueue;
7668}
7669extern "C" {
7670 pub fn mono_gc_reference_queue_free(queue: *mut MonoReferenceQueue);
7671}
7672extern "C" {
7673 pub fn mono_gc_reference_queue_add(
7674 queue: *mut MonoReferenceQueue,
7675 obj: *mut MonoObject,
7676 user_data: *mut ::std::os::raw::c_void,
7677 ) -> mono_bool;
7678}
7679extern "C" {
7680 pub fn mono_gc_wbarrier_set_field(
7681 obj: *mut MonoObject,
7682 field_ptr: *mut ::std::os::raw::c_void,
7683 value: *mut MonoObject,
7684 );
7685}
7686extern "C" {
7687 pub fn mono_gc_wbarrier_set_arrayref(
7688 arr: *mut MonoArray,
7689 slot_ptr: *mut ::std::os::raw::c_void,
7690 value: *mut MonoObject,
7691 );
7692}
7693extern "C" {
7694 pub fn mono_gc_wbarrier_arrayref_copy(
7695 dest_ptr: *mut ::std::os::raw::c_void,
7696 src_ptr: *mut ::std::os::raw::c_void,
7697 count: ::std::os::raw::c_int,
7698 );
7699}
7700extern "C" {
7701 pub fn mono_gc_wbarrier_generic_store(ptr: *mut ::std::os::raw::c_void, value: *mut MonoObject);
7702}
7703extern "C" {
7704 pub fn mono_gc_wbarrier_generic_store_atomic(
7705 ptr: *mut ::std::os::raw::c_void,
7706 value: *mut MonoObject,
7707 );
7708}
7709extern "C" {
7710 pub fn mono_gc_wbarrier_generic_nostore(ptr: *mut ::std::os::raw::c_void);
7711}
7712extern "C" {
7713 pub fn mono_gc_wbarrier_value_copy(
7714 dest: *mut ::std::os::raw::c_void,
7715 src: *mut ::std::os::raw::c_void,
7716 count: ::std::os::raw::c_int,
7717 klass: *mut MonoClass,
7718 );
7719}
7720extern "C" {
7721 pub fn mono_gc_wbarrier_object_copy(obj: *mut MonoObject, src: *mut MonoObject);
7722}
7723#[repr(C)]
7724#[derive(Debug, Copy, Clone)]
7725pub struct MonoTypeNameParse {
7726 _unused: [u8; 0],
7727}
7728#[repr(C)]
7729#[derive(Debug, Copy, Clone)]
7730pub struct MonoCustomAttrEntry {
7731 pub ctor: *mut MonoMethod,
7732 pub data_size: u32,
7733 pub data: *const mono_byte,
7734}
7735#[test]
7736fn bindgen_test_layout_MonoCustomAttrEntry() {
7737 assert_eq!(
7738 ::std::mem::size_of::<MonoCustomAttrEntry>(),
7739 24usize,
7740 concat!("Size of: ", stringify!(MonoCustomAttrEntry))
7741 );
7742 assert_eq!(
7743 ::std::mem::align_of::<MonoCustomAttrEntry>(),
7744 8usize,
7745 concat!("Alignment of ", stringify!(MonoCustomAttrEntry))
7746 );
7747 fn test_field_ctor() {
7748 assert_eq!(
7749 unsafe {
7750 let uninit = ::std::mem::MaybeUninit::<MonoCustomAttrEntry>::uninit();
7751 let ptr = uninit.as_ptr();
7752 ::std::ptr::addr_of!((*ptr).ctor) as usize - ptr as usize
7753 },
7754 0usize,
7755 concat!(
7756 "Offset of field: ",
7757 stringify!(MonoCustomAttrEntry),
7758 "::",
7759 stringify!(ctor)
7760 )
7761 );
7762 }
7763 test_field_ctor();
7764 fn test_field_data_size() {
7765 assert_eq!(
7766 unsafe {
7767 let uninit = ::std::mem::MaybeUninit::<MonoCustomAttrEntry>::uninit();
7768 let ptr = uninit.as_ptr();
7769 ::std::ptr::addr_of!((*ptr).data_size) as usize - ptr as usize
7770 },
7771 8usize,
7772 concat!(
7773 "Offset of field: ",
7774 stringify!(MonoCustomAttrEntry),
7775 "::",
7776 stringify!(data_size)
7777 )
7778 );
7779 }
7780 test_field_data_size();
7781 fn test_field_data() {
7782 assert_eq!(
7783 unsafe {
7784 let uninit = ::std::mem::MaybeUninit::<MonoCustomAttrEntry>::uninit();
7785 let ptr = uninit.as_ptr();
7786 ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize
7787 },
7788 16usize,
7789 concat!(
7790 "Offset of field: ",
7791 stringify!(MonoCustomAttrEntry),
7792 "::",
7793 stringify!(data)
7794 )
7795 );
7796 }
7797 test_field_data();
7798}
7799#[repr(C)]
7800#[derive(Debug)]
7801pub struct MonoCustomAttrInfo {
7802 pub num_attrs: ::std::os::raw::c_int,
7803 pub cached: ::std::os::raw::c_int,
7804 pub image: *mut MonoImage,
7805 pub attrs: __IncompleteArrayField<MonoCustomAttrEntry>,
7806}
7807#[test]
7808fn bindgen_test_layout_MonoCustomAttrInfo() {
7809 assert_eq!(
7810 ::std::mem::size_of::<MonoCustomAttrInfo>(),
7811 16usize,
7812 concat!("Size of: ", stringify!(MonoCustomAttrInfo))
7813 );
7814 assert_eq!(
7815 ::std::mem::align_of::<MonoCustomAttrInfo>(),
7816 8usize,
7817 concat!("Alignment of ", stringify!(MonoCustomAttrInfo))
7818 );
7819 fn test_field_num_attrs() {
7820 assert_eq!(
7821 unsafe {
7822 let uninit = ::std::mem::MaybeUninit::<MonoCustomAttrInfo>::uninit();
7823 let ptr = uninit.as_ptr();
7824 ::std::ptr::addr_of!((*ptr).num_attrs) as usize - ptr as usize
7825 },
7826 0usize,
7827 concat!(
7828 "Offset of field: ",
7829 stringify!(MonoCustomAttrInfo),
7830 "::",
7831 stringify!(num_attrs)
7832 )
7833 );
7834 }
7835 test_field_num_attrs();
7836 fn test_field_cached() {
7837 assert_eq!(
7838 unsafe {
7839 let uninit = ::std::mem::MaybeUninit::<MonoCustomAttrInfo>::uninit();
7840 let ptr = uninit.as_ptr();
7841 ::std::ptr::addr_of!((*ptr).cached) as usize - ptr as usize
7842 },
7843 4usize,
7844 concat!(
7845 "Offset of field: ",
7846 stringify!(MonoCustomAttrInfo),
7847 "::",
7848 stringify!(cached)
7849 )
7850 );
7851 }
7852 test_field_cached();
7853 fn test_field_image() {
7854 assert_eq!(
7855 unsafe {
7856 let uninit = ::std::mem::MaybeUninit::<MonoCustomAttrInfo>::uninit();
7857 let ptr = uninit.as_ptr();
7858 ::std::ptr::addr_of!((*ptr).image) as usize - ptr as usize
7859 },
7860 8usize,
7861 concat!(
7862 "Offset of field: ",
7863 stringify!(MonoCustomAttrInfo),
7864 "::",
7865 stringify!(image)
7866 )
7867 );
7868 }
7869 test_field_image();
7870 fn test_field_attrs() {
7871 assert_eq!(
7872 unsafe {
7873 let uninit = ::std::mem::MaybeUninit::<MonoCustomAttrInfo>::uninit();
7874 let ptr = uninit.as_ptr();
7875 ::std::ptr::addr_of!((*ptr).attrs) as usize - ptr as usize
7876 },
7877 16usize,
7878 concat!(
7879 "Offset of field: ",
7880 stringify!(MonoCustomAttrInfo),
7881 "::",
7882 stringify!(attrs)
7883 )
7884 );
7885 }
7886 test_field_attrs();
7887}
7888#[repr(C)]
7889#[derive(Debug, Copy, Clone)]
7890pub struct MonoReflectionMethodAux {
7891 pub param_names: *mut *mut ::std::os::raw::c_char,
7892 pub param_marshall: *mut *mut MonoMarshalSpec,
7893 pub param_cattr: *mut *mut MonoCustomAttrInfo,
7894 pub param_defaults: *mut *mut u8,
7895 pub param_default_types: *mut u32,
7896 pub dllentry: *mut ::std::os::raw::c_char,
7897 pub dll: *mut ::std::os::raw::c_char,
7898}
7899#[test]
7900fn bindgen_test_layout_MonoReflectionMethodAux() {
7901 assert_eq!(
7902 ::std::mem::size_of::<MonoReflectionMethodAux>(),
7903 56usize,
7904 concat!("Size of: ", stringify!(MonoReflectionMethodAux))
7905 );
7906 assert_eq!(
7907 ::std::mem::align_of::<MonoReflectionMethodAux>(),
7908 8usize,
7909 concat!("Alignment of ", stringify!(MonoReflectionMethodAux))
7910 );
7911 fn test_field_param_names() {
7912 assert_eq!(
7913 unsafe {
7914 let uninit = ::std::mem::MaybeUninit::<MonoReflectionMethodAux>::uninit();
7915 let ptr = uninit.as_ptr();
7916 ::std::ptr::addr_of!((*ptr).param_names) as usize - ptr as usize
7917 },
7918 0usize,
7919 concat!(
7920 "Offset of field: ",
7921 stringify!(MonoReflectionMethodAux),
7922 "::",
7923 stringify!(param_names)
7924 )
7925 );
7926 }
7927 test_field_param_names();
7928 fn test_field_param_marshall() {
7929 assert_eq!(
7930 unsafe {
7931 let uninit = ::std::mem::MaybeUninit::<MonoReflectionMethodAux>::uninit();
7932 let ptr = uninit.as_ptr();
7933 ::std::ptr::addr_of!((*ptr).param_marshall) as usize - ptr as usize
7934 },
7935 8usize,
7936 concat!(
7937 "Offset of field: ",
7938 stringify!(MonoReflectionMethodAux),
7939 "::",
7940 stringify!(param_marshall)
7941 )
7942 );
7943 }
7944 test_field_param_marshall();
7945 fn test_field_param_cattr() {
7946 assert_eq!(
7947 unsafe {
7948 let uninit = ::std::mem::MaybeUninit::<MonoReflectionMethodAux>::uninit();
7949 let ptr = uninit.as_ptr();
7950 ::std::ptr::addr_of!((*ptr).param_cattr) as usize - ptr as usize
7951 },
7952 16usize,
7953 concat!(
7954 "Offset of field: ",
7955 stringify!(MonoReflectionMethodAux),
7956 "::",
7957 stringify!(param_cattr)
7958 )
7959 );
7960 }
7961 test_field_param_cattr();
7962 fn test_field_param_defaults() {
7963 assert_eq!(
7964 unsafe {
7965 let uninit = ::std::mem::MaybeUninit::<MonoReflectionMethodAux>::uninit();
7966 let ptr = uninit.as_ptr();
7967 ::std::ptr::addr_of!((*ptr).param_defaults) as usize - ptr as usize
7968 },
7969 24usize,
7970 concat!(
7971 "Offset of field: ",
7972 stringify!(MonoReflectionMethodAux),
7973 "::",
7974 stringify!(param_defaults)
7975 )
7976 );
7977 }
7978 test_field_param_defaults();
7979 fn test_field_param_default_types() {
7980 assert_eq!(
7981 unsafe {
7982 let uninit = ::std::mem::MaybeUninit::<MonoReflectionMethodAux>::uninit();
7983 let ptr = uninit.as_ptr();
7984 ::std::ptr::addr_of!((*ptr).param_default_types) as usize - ptr as usize
7985 },
7986 32usize,
7987 concat!(
7988 "Offset of field: ",
7989 stringify!(MonoReflectionMethodAux),
7990 "::",
7991 stringify!(param_default_types)
7992 )
7993 );
7994 }
7995 test_field_param_default_types();
7996 fn test_field_dllentry() {
7997 assert_eq!(
7998 unsafe {
7999 let uninit = ::std::mem::MaybeUninit::<MonoReflectionMethodAux>::uninit();
8000 let ptr = uninit.as_ptr();
8001 ::std::ptr::addr_of!((*ptr).dllentry) as usize - ptr as usize
8002 },
8003 40usize,
8004 concat!(
8005 "Offset of field: ",
8006 stringify!(MonoReflectionMethodAux),
8007 "::",
8008 stringify!(dllentry)
8009 )
8010 );
8011 }
8012 test_field_dllentry();
8013 fn test_field_dll() {
8014 assert_eq!(
8015 unsafe {
8016 let uninit = ::std::mem::MaybeUninit::<MonoReflectionMethodAux>::uninit();
8017 let ptr = uninit.as_ptr();
8018 ::std::ptr::addr_of!((*ptr).dll) as usize - ptr as usize
8019 },
8020 48usize,
8021 concat!(
8022 "Offset of field: ",
8023 stringify!(MonoReflectionMethodAux),
8024 "::",
8025 stringify!(dll)
8026 )
8027 );
8028 }
8029 test_field_dll();
8030}
8031pub const MonoResolveTokenError_ResolveTokenError_OutOfRange: MonoResolveTokenError = 0;
8032pub const MonoResolveTokenError_ResolveTokenError_BadTable: MonoResolveTokenError = 1;
8033pub const MonoResolveTokenError_ResolveTokenError_Other: MonoResolveTokenError = 2;
8034pub type MonoResolveTokenError = ::std::os::raw::c_uint;
8035extern "C" {
8036 pub fn mono_reflection_parse_type(
8037 name: *mut ::std::os::raw::c_char,
8038 info: *mut MonoTypeNameParse,
8039 ) -> ::std::os::raw::c_int;
8040}
8041extern "C" {
8042 pub fn mono_reflection_get_type(
8043 image: *mut MonoImage,
8044 info: *mut MonoTypeNameParse,
8045 ignorecase: mono_bool,
8046 type_resolve: *mut mono_bool,
8047 ) -> *mut MonoType;
8048}
8049extern "C" {
8050 pub fn mono_reflection_free_type_info(info: *mut MonoTypeNameParse);
8051}
8052extern "C" {
8053 pub fn mono_reflection_type_from_name(
8054 name: *mut ::std::os::raw::c_char,
8055 image: *mut MonoImage,
8056 ) -> *mut MonoType;
8057}
8058extern "C" {
8059 pub fn mono_reflection_get_token(obj: *mut MonoObject) -> u32;
8060}
8061extern "C" {
8062 pub fn mono_assembly_get_object(
8063 domain: *mut MonoDomain,
8064 assembly: *mut MonoAssembly,
8065 ) -> *mut MonoReflectionAssembly;
8066}
8067extern "C" {
8068 pub fn mono_module_get_object(
8069 domain: *mut MonoDomain,
8070 image: *mut MonoImage,
8071 ) -> *mut MonoReflectionModule;
8072}
8073extern "C" {
8074 pub fn mono_module_file_get_object(
8075 domain: *mut MonoDomain,
8076 image: *mut MonoImage,
8077 table_index: ::std::os::raw::c_int,
8078 ) -> *mut MonoReflectionModule;
8079}
8080extern "C" {
8081 pub fn mono_type_get_object(
8082 domain: *mut MonoDomain,
8083 type_: *mut MonoType,
8084 ) -> *mut MonoReflectionType;
8085}
8086extern "C" {
8087 pub fn mono_method_get_object(
8088 domain: *mut MonoDomain,
8089 method: *mut MonoMethod,
8090 refclass: *mut MonoClass,
8091 ) -> *mut MonoReflectionMethod;
8092}
8093extern "C" {
8094 pub fn mono_field_get_object(
8095 domain: *mut MonoDomain,
8096 klass: *mut MonoClass,
8097 field: *mut MonoClassField,
8098 ) -> *mut MonoReflectionField;
8099}
8100extern "C" {
8101 pub fn mono_property_get_object(
8102 domain: *mut MonoDomain,
8103 klass: *mut MonoClass,
8104 property: *mut MonoProperty,
8105 ) -> *mut MonoReflectionProperty;
8106}
8107extern "C" {
8108 pub fn mono_event_get_object(
8109 domain: *mut MonoDomain,
8110 klass: *mut MonoClass,
8111 event: *mut MonoEvent,
8112 ) -> *mut MonoReflectionEvent;
8113}
8114extern "C" {
8115 pub fn mono_param_get_objects(
8116 domain: *mut MonoDomain,
8117 method: *mut MonoMethod,
8118 ) -> *mut MonoArray;
8119}
8120extern "C" {
8121 pub fn mono_method_body_get_object(
8122 domain: *mut MonoDomain,
8123 method: *mut MonoMethod,
8124 ) -> *mut MonoReflectionMethodBody;
8125}
8126extern "C" {
8127 pub fn mono_get_dbnull_object(domain: *mut MonoDomain) -> *mut MonoObject;
8128}
8129extern "C" {
8130 pub fn mono_reflection_get_custom_attrs_by_type(
8131 obj: *mut MonoObject,
8132 attr_klass: *mut MonoClass,
8133 error: *mut MonoError,
8134 ) -> *mut MonoArray;
8135}
8136extern "C" {
8137 pub fn mono_reflection_get_custom_attrs(obj: *mut MonoObject) -> *mut MonoArray;
8138}
8139extern "C" {
8140 pub fn mono_reflection_get_custom_attrs_data(obj: *mut MonoObject) -> *mut MonoArray;
8141}
8142extern "C" {
8143 pub fn mono_reflection_get_custom_attrs_blob(
8144 assembly: *mut MonoReflectionAssembly,
8145 ctor: *mut MonoObject,
8146 ctorArgs: *mut MonoArray,
8147 properties: *mut MonoArray,
8148 porpValues: *mut MonoArray,
8149 fields: *mut MonoArray,
8150 fieldValues: *mut MonoArray,
8151 ) -> *mut MonoArray;
8152}
8153extern "C" {
8154 pub fn mono_reflection_get_custom_attrs_info(obj: *mut MonoObject) -> *mut MonoCustomAttrInfo;
8155}
8156extern "C" {
8157 pub fn mono_custom_attrs_construct(cinfo: *mut MonoCustomAttrInfo) -> *mut MonoArray;
8158}
8159extern "C" {
8160 pub fn mono_custom_attrs_from_index(image: *mut MonoImage, idx: u32)
8161 -> *mut MonoCustomAttrInfo;
8162}
8163extern "C" {
8164 pub fn mono_custom_attrs_from_method(method: *mut MonoMethod) -> *mut MonoCustomAttrInfo;
8165}
8166extern "C" {
8167 pub fn mono_custom_attrs_from_class(klass: *mut MonoClass) -> *mut MonoCustomAttrInfo;
8168}
8169extern "C" {
8170 pub fn mono_custom_attrs_from_assembly(assembly: *mut MonoAssembly) -> *mut MonoCustomAttrInfo;
8171}
8172extern "C" {
8173 pub fn mono_custom_attrs_from_property(
8174 klass: *mut MonoClass,
8175 property: *mut MonoProperty,
8176 ) -> *mut MonoCustomAttrInfo;
8177}
8178extern "C" {
8179 pub fn mono_custom_attrs_from_event(
8180 klass: *mut MonoClass,
8181 event: *mut MonoEvent,
8182 ) -> *mut MonoCustomAttrInfo;
8183}
8184extern "C" {
8185 pub fn mono_custom_attrs_from_field(
8186 klass: *mut MonoClass,
8187 field: *mut MonoClassField,
8188 ) -> *mut MonoCustomAttrInfo;
8189}
8190extern "C" {
8191 pub fn mono_custom_attrs_from_param(
8192 method: *mut MonoMethod,
8193 param: u32,
8194 ) -> *mut MonoCustomAttrInfo;
8195}
8196extern "C" {
8197 pub fn mono_custom_attrs_has_attr(
8198 ainfo: *mut MonoCustomAttrInfo,
8199 attr_klass: *mut MonoClass,
8200 ) -> mono_bool;
8201}
8202extern "C" {
8203 pub fn mono_custom_attrs_get_attr(
8204 ainfo: *mut MonoCustomAttrInfo,
8205 attr_klass: *mut MonoClass,
8206 ) -> *mut MonoObject;
8207}
8208extern "C" {
8209 pub fn mono_custom_attrs_free(ainfo: *mut MonoCustomAttrInfo);
8210}
8211pub const MONO_DECLSEC_FLAG_REQUEST: _bindgen_ty_65 = 1;
8212pub const MONO_DECLSEC_FLAG_DEMAND: _bindgen_ty_65 = 2;
8213pub const MONO_DECLSEC_FLAG_ASSERT: _bindgen_ty_65 = 4;
8214pub const MONO_DECLSEC_FLAG_DENY: _bindgen_ty_65 = 8;
8215pub const MONO_DECLSEC_FLAG_PERMITONLY: _bindgen_ty_65 = 16;
8216pub const MONO_DECLSEC_FLAG_LINKDEMAND: _bindgen_ty_65 = 32;
8217pub const MONO_DECLSEC_FLAG_INHERITANCEDEMAND: _bindgen_ty_65 = 64;
8218pub const MONO_DECLSEC_FLAG_REQUEST_MINIMUM: _bindgen_ty_65 = 128;
8219pub const MONO_DECLSEC_FLAG_REQUEST_OPTIONAL: _bindgen_ty_65 = 256;
8220pub const MONO_DECLSEC_FLAG_REQUEST_REFUSE: _bindgen_ty_65 = 512;
8221pub const MONO_DECLSEC_FLAG_PREJIT_GRANT: _bindgen_ty_65 = 1024;
8222pub const MONO_DECLSEC_FLAG_PREJIT_DENY: _bindgen_ty_65 = 2048;
8223pub const MONO_DECLSEC_FLAG_NONCAS_DEMAND: _bindgen_ty_65 = 4096;
8224pub const MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND: _bindgen_ty_65 = 8192;
8225pub const MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND: _bindgen_ty_65 = 16384;
8226pub const MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE: _bindgen_ty_65 = 32768;
8227pub const MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE: _bindgen_ty_65 = 65536;
8228pub const MONO_DECLSEC_FLAG_DEMAND_CHOICE: _bindgen_ty_65 = 131072;
8229pub type _bindgen_ty_65 = ::std::os::raw::c_uint;
8230extern "C" {
8231 pub fn mono_declsec_flags_from_method(method: *mut MonoMethod) -> u32;
8232}
8233extern "C" {
8234 pub fn mono_declsec_flags_from_class(klass: *mut MonoClass) -> u32;
8235}
8236extern "C" {
8237 pub fn mono_declsec_flags_from_assembly(assembly: *mut MonoAssembly) -> u32;
8238}
8239#[repr(C)]
8240#[derive(Debug, Copy, Clone)]
8241pub struct MonoDeclSecurityEntry {
8242 pub blob: *mut ::std::os::raw::c_char,
8243 pub size: u32,
8244 pub index: u32,
8245}
8246#[test]
8247fn bindgen_test_layout_MonoDeclSecurityEntry() {
8248 assert_eq!(
8249 ::std::mem::size_of::<MonoDeclSecurityEntry>(),
8250 16usize,
8251 concat!("Size of: ", stringify!(MonoDeclSecurityEntry))
8252 );
8253 assert_eq!(
8254 ::std::mem::align_of::<MonoDeclSecurityEntry>(),
8255 8usize,
8256 concat!("Alignment of ", stringify!(MonoDeclSecurityEntry))
8257 );
8258 fn test_field_blob() {
8259 assert_eq!(
8260 unsafe {
8261 let uninit = ::std::mem::MaybeUninit::<MonoDeclSecurityEntry>::uninit();
8262 let ptr = uninit.as_ptr();
8263 ::std::ptr::addr_of!((*ptr).blob) as usize - ptr as usize
8264 },
8265 0usize,
8266 concat!(
8267 "Offset of field: ",
8268 stringify!(MonoDeclSecurityEntry),
8269 "::",
8270 stringify!(blob)
8271 )
8272 );
8273 }
8274 test_field_blob();
8275 fn test_field_size() {
8276 assert_eq!(
8277 unsafe {
8278 let uninit = ::std::mem::MaybeUninit::<MonoDeclSecurityEntry>::uninit();
8279 let ptr = uninit.as_ptr();
8280 ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize
8281 },
8282 8usize,
8283 concat!(
8284 "Offset of field: ",
8285 stringify!(MonoDeclSecurityEntry),
8286 "::",
8287 stringify!(size)
8288 )
8289 );
8290 }
8291 test_field_size();
8292 fn test_field_index() {
8293 assert_eq!(
8294 unsafe {
8295 let uninit = ::std::mem::MaybeUninit::<MonoDeclSecurityEntry>::uninit();
8296 let ptr = uninit.as_ptr();
8297 ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize
8298 },
8299 12usize,
8300 concat!(
8301 "Offset of field: ",
8302 stringify!(MonoDeclSecurityEntry),
8303 "::",
8304 stringify!(index)
8305 )
8306 );
8307 }
8308 test_field_index();
8309}
8310#[repr(C)]
8311#[derive(Debug, Copy, Clone)]
8312pub struct MonoDeclSecurityActions {
8313 pub demand: MonoDeclSecurityEntry,
8314 pub noncasdemand: MonoDeclSecurityEntry,
8315 pub demandchoice: MonoDeclSecurityEntry,
8316}
8317#[test]
8318fn bindgen_test_layout_MonoDeclSecurityActions() {
8319 assert_eq!(
8320 ::std::mem::size_of::<MonoDeclSecurityActions>(),
8321 48usize,
8322 concat!("Size of: ", stringify!(MonoDeclSecurityActions))
8323 );
8324 assert_eq!(
8325 ::std::mem::align_of::<MonoDeclSecurityActions>(),
8326 8usize,
8327 concat!("Alignment of ", stringify!(MonoDeclSecurityActions))
8328 );
8329 fn test_field_demand() {
8330 assert_eq!(
8331 unsafe {
8332 let uninit = ::std::mem::MaybeUninit::<MonoDeclSecurityActions>::uninit();
8333 let ptr = uninit.as_ptr();
8334 ::std::ptr::addr_of!((*ptr).demand) as usize - ptr as usize
8335 },
8336 0usize,
8337 concat!(
8338 "Offset of field: ",
8339 stringify!(MonoDeclSecurityActions),
8340 "::",
8341 stringify!(demand)
8342 )
8343 );
8344 }
8345 test_field_demand();
8346 fn test_field_noncasdemand() {
8347 assert_eq!(
8348 unsafe {
8349 let uninit = ::std::mem::MaybeUninit::<MonoDeclSecurityActions>::uninit();
8350 let ptr = uninit.as_ptr();
8351 ::std::ptr::addr_of!((*ptr).noncasdemand) as usize - ptr as usize
8352 },
8353 16usize,
8354 concat!(
8355 "Offset of field: ",
8356 stringify!(MonoDeclSecurityActions),
8357 "::",
8358 stringify!(noncasdemand)
8359 )
8360 );
8361 }
8362 test_field_noncasdemand();
8363 fn test_field_demandchoice() {
8364 assert_eq!(
8365 unsafe {
8366 let uninit = ::std::mem::MaybeUninit::<MonoDeclSecurityActions>::uninit();
8367 let ptr = uninit.as_ptr();
8368 ::std::ptr::addr_of!((*ptr).demandchoice) as usize - ptr as usize
8369 },
8370 32usize,
8371 concat!(
8372 "Offset of field: ",
8373 stringify!(MonoDeclSecurityActions),
8374 "::",
8375 stringify!(demandchoice)
8376 )
8377 );
8378 }
8379 test_field_demandchoice();
8380}
8381extern "C" {
8382 pub fn mono_declsec_get_demands(
8383 callee: *mut MonoMethod,
8384 demands: *mut MonoDeclSecurityActions,
8385 ) -> MonoBoolean;
8386}
8387extern "C" {
8388 pub fn mono_declsec_get_linkdemands(
8389 callee: *mut MonoMethod,
8390 klass: *mut MonoDeclSecurityActions,
8391 cmethod: *mut MonoDeclSecurityActions,
8392 ) -> MonoBoolean;
8393}
8394extern "C" {
8395 pub fn mono_declsec_get_inheritdemands_class(
8396 klass: *mut MonoClass,
8397 demands: *mut MonoDeclSecurityActions,
8398 ) -> MonoBoolean;
8399}
8400extern "C" {
8401 pub fn mono_declsec_get_inheritdemands_method(
8402 callee: *mut MonoMethod,
8403 demands: *mut MonoDeclSecurityActions,
8404 ) -> MonoBoolean;
8405}
8406extern "C" {
8407 pub fn mono_declsec_get_method_action(
8408 method: *mut MonoMethod,
8409 action: u32,
8410 entry: *mut MonoDeclSecurityEntry,
8411 ) -> MonoBoolean;
8412}
8413extern "C" {
8414 pub fn mono_declsec_get_class_action(
8415 klass: *mut MonoClass,
8416 action: u32,
8417 entry: *mut MonoDeclSecurityEntry,
8418 ) -> MonoBoolean;
8419}
8420extern "C" {
8421 pub fn mono_declsec_get_assembly_action(
8422 assembly: *mut MonoAssembly,
8423 action: u32,
8424 entry: *mut MonoDeclSecurityEntry,
8425 ) -> MonoBoolean;
8426}
8427extern "C" {
8428 pub fn mono_reflection_type_get_type(reftype: *mut MonoReflectionType) -> *mut MonoType;
8429}
8430extern "C" {
8431 pub fn mono_reflection_assembly_get_assembly(
8432 refassembly: *mut MonoReflectionAssembly,
8433 ) -> *mut MonoAssembly;
8434}
8435pub type MonoThreadStartCB = ::std::option::Option<
8436 unsafe extern "C" fn(
8437 tid: isize,
8438 stack_start: *mut ::std::os::raw::c_void,
8439 func: *mut ::std::os::raw::c_void,
8440 ),
8441>;
8442pub type MonoThreadAttachCB = ::std::option::Option<
8443 unsafe extern "C" fn(tid: isize, stack_start: *mut ::std::os::raw::c_void),
8444>;
8445#[repr(C)]
8446#[derive(Debug, Copy, Clone)]
8447pub struct _MonoAppDomain {
8448 _unused: [u8; 0],
8449}
8450pub type MonoAppDomain = _MonoAppDomain;
8451pub type MonoDomainFunc = ::std::option::Option<
8452 unsafe extern "C" fn(domain: *mut MonoDomain, user_data: *mut ::std::os::raw::c_void),
8453>;
8454extern "C" {
8455 pub fn mono_init(filename: *const ::std::os::raw::c_char) -> *mut MonoDomain;
8456}
8457extern "C" {
8458 pub fn mono_init_from_assembly(
8459 domain_name: *const ::std::os::raw::c_char,
8460 filename: *const ::std::os::raw::c_char,
8461 ) -> *mut MonoDomain;
8462}
8463extern "C" {
8464 pub fn mono_init_version(
8465 domain_name: *const ::std::os::raw::c_char,
8466 version: *const ::std::os::raw::c_char,
8467 ) -> *mut MonoDomain;
8468}
8469extern "C" {
8470 pub fn mono_get_root_domain() -> *mut MonoDomain;
8471}
8472extern "C" {
8473 pub fn mono_runtime_init(
8474 domain: *mut MonoDomain,
8475 start_cb: MonoThreadStartCB,
8476 attach_cb: MonoThreadAttachCB,
8477 );
8478}
8479extern "C" {
8480 pub fn mono_runtime_cleanup(domain: *mut MonoDomain);
8481}
8482extern "C" {
8483 pub fn mono_install_runtime_cleanup(func: MonoDomainFunc);
8484}
8485extern "C" {
8486 pub fn mono_runtime_quit();
8487}
8488extern "C" {
8489 pub fn mono_runtime_set_shutting_down();
8490}
8491extern "C" {
8492 pub fn mono_runtime_is_shutting_down() -> mono_bool;
8493}
8494extern "C" {
8495 pub fn mono_check_corlib_version() -> *const ::std::os::raw::c_char;
8496}
8497extern "C" {
8498 pub fn mono_domain_create() -> *mut MonoDomain;
8499}
8500extern "C" {
8501 pub fn mono_domain_create_appdomain(
8502 friendly_name: *mut ::std::os::raw::c_char,
8503 configuration_file: *mut ::std::os::raw::c_char,
8504 ) -> *mut MonoDomain;
8505}
8506extern "C" {
8507 pub fn mono_domain_set_config(
8508 domain: *mut MonoDomain,
8509 base_dir: *const ::std::os::raw::c_char,
8510 config_file_name: *const ::std::os::raw::c_char,
8511 );
8512}
8513extern "C" {
8514 pub fn mono_domain_get() -> *mut MonoDomain;
8515}
8516extern "C" {
8517 pub fn mono_domain_get_by_id(domainid: i32) -> *mut MonoDomain;
8518}
8519extern "C" {
8520 pub fn mono_domain_get_id(domain: *mut MonoDomain) -> i32;
8521}
8522extern "C" {
8523 pub fn mono_domain_get_friendly_name(domain: *mut MonoDomain) -> *const ::std::os::raw::c_char;
8524}
8525extern "C" {
8526 pub fn mono_domain_set(domain: *mut MonoDomain, force: mono_bool) -> mono_bool;
8527}
8528extern "C" {
8529 pub fn mono_domain_set_internal(domain: *mut MonoDomain);
8530}
8531extern "C" {
8532 pub fn mono_domain_unload(domain: *mut MonoDomain);
8533}
8534extern "C" {
8535 pub fn mono_domain_try_unload(domain: *mut MonoDomain, exc: *mut *mut MonoObject);
8536}
8537extern "C" {
8538 pub fn mono_domain_is_unloading(domain: *mut MonoDomain) -> mono_bool;
8539}
8540extern "C" {
8541 pub fn mono_domain_from_appdomain(appdomain: *mut MonoAppDomain) -> *mut MonoDomain;
8542}
8543extern "C" {
8544 pub fn mono_domain_foreach(func: MonoDomainFunc, user_data: *mut ::std::os::raw::c_void);
8545}
8546extern "C" {
8547 pub fn mono_domain_assembly_open(
8548 domain: *mut MonoDomain,
8549 name: *const ::std::os::raw::c_char,
8550 ) -> *mut MonoAssembly;
8551}
8552extern "C" {
8553 pub fn mono_domain_finalize(domain: *mut MonoDomain, timeout: u32) -> mono_bool;
8554}
8555extern "C" {
8556 pub fn mono_domain_free(domain: *mut MonoDomain, force: mono_bool);
8557}
8558extern "C" {
8559 pub fn mono_domain_has_type_resolve(domain: *mut MonoDomain) -> mono_bool;
8560}
8561extern "C" {
8562 pub fn mono_domain_try_type_resolve(
8563 domain: *mut MonoDomain,
8564 name: *mut ::std::os::raw::c_char,
8565 tb: *mut MonoObject,
8566 ) -> *mut MonoReflectionAssembly;
8567}
8568extern "C" {
8569 pub fn mono_domain_owns_vtable_slot(
8570 domain: *mut MonoDomain,
8571 vtable_slot: *mut ::std::os::raw::c_void,
8572 ) -> mono_bool;
8573}
8574extern "C" {
8575 pub fn mono_context_init(domain: *mut MonoDomain);
8576}
8577extern "C" {
8578 pub fn mono_context_set(new_context: *mut MonoAppContext);
8579}
8580extern "C" {
8581 pub fn mono_context_get() -> *mut MonoAppContext;
8582}
8583extern "C" {
8584 pub fn mono_context_get_id(context: *mut MonoAppContext) -> i32;
8585}
8586extern "C" {
8587 pub fn mono_context_get_domain_id(context: *mut MonoAppContext) -> i32;
8588}
8589extern "C" {
8590 pub fn mono_jit_info_table_find(
8591 domain: *mut MonoDomain,
8592 addr: *mut ::std::os::raw::c_void,
8593 ) -> *mut MonoJitInfo;
8594}
8595extern "C" {
8596 pub fn mono_jit_info_get_code_start(ji: *mut MonoJitInfo) -> *mut ::std::os::raw::c_void;
8597}
8598extern "C" {
8599 pub fn mono_jit_info_get_code_size(ji: *mut MonoJitInfo) -> ::std::os::raw::c_int;
8600}
8601extern "C" {
8602 pub fn mono_jit_info_get_method(ji: *mut MonoJitInfo) -> *mut MonoMethod;
8603}
8604extern "C" {
8605 pub fn mono_get_corlib() -> *mut MonoImage;
8606}
8607extern "C" {
8608 pub fn mono_get_object_class() -> *mut MonoClass;
8609}
8610extern "C" {
8611 pub fn mono_get_byte_class() -> *mut MonoClass;
8612}
8613extern "C" {
8614 pub fn mono_get_void_class() -> *mut MonoClass;
8615}
8616extern "C" {
8617 pub fn mono_get_boolean_class() -> *mut MonoClass;
8618}
8619extern "C" {
8620 pub fn mono_get_sbyte_class() -> *mut MonoClass;
8621}
8622extern "C" {
8623 pub fn mono_get_int16_class() -> *mut MonoClass;
8624}
8625extern "C" {
8626 pub fn mono_get_uint16_class() -> *mut MonoClass;
8627}
8628extern "C" {
8629 pub fn mono_get_int32_class() -> *mut MonoClass;
8630}
8631extern "C" {
8632 pub fn mono_get_uint32_class() -> *mut MonoClass;
8633}
8634extern "C" {
8635 pub fn mono_get_intptr_class() -> *mut MonoClass;
8636}
8637extern "C" {
8638 pub fn mono_get_uintptr_class() -> *mut MonoClass;
8639}
8640extern "C" {
8641 pub fn mono_get_int64_class() -> *mut MonoClass;
8642}
8643extern "C" {
8644 pub fn mono_get_uint64_class() -> *mut MonoClass;
8645}
8646extern "C" {
8647 pub fn mono_get_single_class() -> *mut MonoClass;
8648}
8649extern "C" {
8650 pub fn mono_get_double_class() -> *mut MonoClass;
8651}
8652extern "C" {
8653 pub fn mono_get_char_class() -> *mut MonoClass;
8654}
8655extern "C" {
8656 pub fn mono_get_string_class() -> *mut MonoClass;
8657}
8658extern "C" {
8659 pub fn mono_get_enum_class() -> *mut MonoClass;
8660}
8661extern "C" {
8662 pub fn mono_get_array_class() -> *mut MonoClass;
8663}
8664extern "C" {
8665 pub fn mono_get_thread_class() -> *mut MonoClass;
8666}
8667extern "C" {
8668 pub fn mono_get_exception_class() -> *mut MonoClass;
8669}
8670extern "C" {
8671 pub fn mono_security_enable_core_clr();
8672}
8673pub type MonoCoreClrPlatformCB = ::std::option::Option<
8674 unsafe extern "C" fn(image_name: *const ::std::os::raw::c_char) -> mono_bool,
8675>;
8676extern "C" {
8677 pub fn mono_security_set_core_clr_platform_callback(callback: MonoCoreClrPlatformCB);
8678}
8679extern "C" {
8680 pub fn mono_jit_init(file: *const ::std::os::raw::c_char) -> *mut MonoDomain;
8681}
8682extern "C" {
8683 pub fn mono_jit_init_version(
8684 root_domain_name: *const ::std::os::raw::c_char,
8685 runtime_version: *const ::std::os::raw::c_char,
8686 ) -> *mut MonoDomain;
8687}
8688extern "C" {
8689 pub fn mono_jit_init_version_for_test_only(
8690 root_domain_name: *const ::std::os::raw::c_char,
8691 runtime_version: *const ::std::os::raw::c_char,
8692 ) -> *mut MonoDomain;
8693}
8694extern "C" {
8695 pub fn mono_jit_exec(
8696 domain: *mut MonoDomain,
8697 assembly: *mut MonoAssembly,
8698 argc: ::std::os::raw::c_int,
8699 argv: *mut *mut ::std::os::raw::c_char,
8700 ) -> ::std::os::raw::c_int;
8701}
8702extern "C" {
8703 pub fn mono_jit_cleanup(domain: *mut MonoDomain);
8704}
8705extern "C" {
8706 pub fn mono_jit_set_trace_options(options: *const ::std::os::raw::c_char) -> mono_bool;
8707}
8708extern "C" {
8709 pub fn mono_set_signal_chaining(chain_signals: mono_bool);
8710}
8711extern "C" {
8712 pub fn mono_set_crash_chaining(chain_signals: mono_bool);
8713}
8714extern "C" {
8715 #[doc = " This function is deprecated, use mono_jit_set_aot_mode instead."]
8716 pub fn mono_jit_set_aot_only(aot_only: mono_bool);
8717}
8718pub const MonoAotMode_MONO_AOT_MODE_NONE: MonoAotMode = 0;
8719pub const MonoAotMode_MONO_AOT_MODE_NORMAL: MonoAotMode = 1;
8720pub const MonoAotMode_MONO_AOT_MODE_HYBRID: MonoAotMode = 2;
8721pub const MonoAotMode_MONO_AOT_MODE_FULL: MonoAotMode = 3;
8722pub const MonoAotMode_MONO_AOT_MODE_LLVMONLY: MonoAotMode = 4;
8723pub const MonoAotMode_MONO_AOT_MODE_INTERP: MonoAotMode = 5;
8724pub const MonoAotMode_MONO_AOT_MODE_INTERP_LLVMONLY: MonoAotMode = 6;
8725pub const MonoAotMode_MONO_AOT_MODE_LLVMONLY_INTERP: MonoAotMode = 7;
8726pub const MonoAotMode_MONO_AOT_MODE_LAST: MonoAotMode = 1000;
8727#[doc = " Allows control over our AOT (Ahead-of-time) compilation mode."]
8728pub type MonoAotMode = ::std::os::raw::c_uint;
8729extern "C" {
8730 pub fn mono_jit_set_aot_mode(mode: MonoAotMode);
8731}
8732extern "C" {
8733 pub fn mono_jit_aot_compiling() -> mono_bool;
8734}
8735pub const MonoBreakPolicy_MONO_BREAK_POLICY_ALWAYS: MonoBreakPolicy = 0;
8736pub const MonoBreakPolicy_MONO_BREAK_POLICY_NEVER: MonoBreakPolicy = 1;
8737pub const MonoBreakPolicy_MONO_BREAK_POLICY_ON_DBG: MonoBreakPolicy = 2;
8738pub type MonoBreakPolicy = ::std::os::raw::c_uint;
8739pub type MonoBreakPolicyFunc =
8740 ::std::option::Option<unsafe extern "C" fn(method: *mut MonoMethod) -> MonoBreakPolicy>;
8741extern "C" {
8742 pub fn mono_set_break_policy(policy_callback: MonoBreakPolicyFunc);
8743}
8744extern "C" {
8745 pub fn mono_jit_parse_options(
8746 argc: ::std::os::raw::c_int,
8747 argv: *mut *mut ::std::os::raw::c_char,
8748 );
8749}
8750extern "C" {
8751 pub fn mono_get_runtime_build_info() -> *mut ::std::os::raw::c_char;
8752}
8753extern "C" {
8754 pub fn mono_set_use_llvm(use_llvm: mono_bool);
8755}
8756extern "C" {
8757 pub fn mono_aot_register_module(aot_info: *mut *mut ::std::os::raw::c_void);
8758}
8759extern "C" {
8760 pub fn mono_jit_thread_attach(domain: *mut MonoDomain) -> *mut MonoDomain;
8761}
8762extern "C" {
8763 pub fn mono_assemblies_init();
8764}
8765extern "C" {
8766 pub fn mono_assemblies_cleanup();
8767}
8768extern "C" {
8769 pub fn mono_assembly_open(
8770 filename: *const ::std::os::raw::c_char,
8771 status: *mut MonoImageOpenStatus,
8772 ) -> *mut MonoAssembly;
8773}
8774extern "C" {
8775 pub fn mono_assembly_open_full(
8776 filename: *const ::std::os::raw::c_char,
8777 status: *mut MonoImageOpenStatus,
8778 refonly: mono_bool,
8779 ) -> *mut MonoAssembly;
8780}
8781extern "C" {
8782 pub fn mono_assembly_load(
8783 aname: *mut MonoAssemblyName,
8784 basedir: *const ::std::os::raw::c_char,
8785 status: *mut MonoImageOpenStatus,
8786 ) -> *mut MonoAssembly;
8787}
8788extern "C" {
8789 pub fn mono_assembly_load_full(
8790 aname: *mut MonoAssemblyName,
8791 basedir: *const ::std::os::raw::c_char,
8792 status: *mut MonoImageOpenStatus,
8793 refonly: mono_bool,
8794 ) -> *mut MonoAssembly;
8795}
8796extern "C" {
8797 pub fn mono_assembly_load_from(
8798 image: *mut MonoImage,
8799 fname: *const ::std::os::raw::c_char,
8800 status: *mut MonoImageOpenStatus,
8801 ) -> *mut MonoAssembly;
8802}
8803extern "C" {
8804 pub fn mono_assembly_load_from_full(
8805 image: *mut MonoImage,
8806 fname: *const ::std::os::raw::c_char,
8807 status: *mut MonoImageOpenStatus,
8808 refonly: mono_bool,
8809 ) -> *mut MonoAssembly;
8810}
8811extern "C" {
8812 pub fn mono_assembly_load_with_partial_name(
8813 name: *const ::std::os::raw::c_char,
8814 status: *mut MonoImageOpenStatus,
8815 ) -> *mut MonoAssembly;
8816}
8817extern "C" {
8818 pub fn mono_assembly_loaded(aname: *mut MonoAssemblyName) -> *mut MonoAssembly;
8819}
8820extern "C" {
8821 pub fn mono_assembly_loaded_full(
8822 aname: *mut MonoAssemblyName,
8823 refonly: mono_bool,
8824 ) -> *mut MonoAssembly;
8825}
8826extern "C" {
8827 pub fn mono_assembly_get_assemblyref(
8828 image: *mut MonoImage,
8829 index: ::std::os::raw::c_int,
8830 aname: *mut MonoAssemblyName,
8831 );
8832}
8833extern "C" {
8834 pub fn mono_assembly_load_reference(image: *mut MonoImage, index: ::std::os::raw::c_int);
8835}
8836extern "C" {
8837 pub fn mono_assembly_load_references(image: *mut MonoImage, status: *mut MonoImageOpenStatus);
8838}
8839extern "C" {
8840 pub fn mono_assembly_load_module(assembly: *mut MonoAssembly, idx: u32) -> *mut MonoImage;
8841}
8842extern "C" {
8843 pub fn mono_assembly_close(assembly: *mut MonoAssembly);
8844}
8845extern "C" {
8846 pub fn mono_assembly_setrootdir(root_dir: *const ::std::os::raw::c_char);
8847}
8848extern "C" {
8849 pub fn mono_assembly_getrootdir() -> *const ::std::os::raw::c_char;
8850}
8851extern "C" {
8852 pub fn mono_native_getrootdir() -> *mut ::std::os::raw::c_char;
8853}
8854extern "C" {
8855 pub fn mono_assembly_foreach(func: MonoFunc, user_data: *mut ::std::os::raw::c_void);
8856}
8857extern "C" {
8858 pub fn mono_assembly_set_main(assembly: *mut MonoAssembly);
8859}
8860extern "C" {
8861 pub fn mono_assembly_get_main() -> *mut MonoAssembly;
8862}
8863extern "C" {
8864 pub fn mono_assembly_get_image(assembly: *mut MonoAssembly) -> *mut MonoImage;
8865}
8866extern "C" {
8867 pub fn mono_assembly_get_name(assembly: *mut MonoAssembly) -> *mut MonoAssemblyName;
8868}
8869extern "C" {
8870 pub fn mono_assembly_fill_assembly_name(
8871 image: *mut MonoImage,
8872 aname: *mut MonoAssemblyName,
8873 ) -> mono_bool;
8874}
8875extern "C" {
8876 pub fn mono_assembly_names_equal(
8877 l: *mut MonoAssemblyName,
8878 r: *mut MonoAssemblyName,
8879 ) -> mono_bool;
8880}
8881extern "C" {
8882 pub fn mono_stringify_assembly_name(
8883 aname: *mut MonoAssemblyName,
8884 ) -> *mut ::std::os::raw::c_char;
8885}
8886pub type MonoAssemblyLoadFunc = ::std::option::Option<
8887 unsafe extern "C" fn(assembly: *mut MonoAssembly, user_data: *mut ::std::os::raw::c_void),
8888>;
8889extern "C" {
8890 pub fn mono_install_assembly_load_hook(
8891 func: MonoAssemblyLoadFunc,
8892 user_data: *mut ::std::os::raw::c_void,
8893 );
8894}
8895pub type MonoAssemblySearchFunc = ::std::option::Option<
8896 unsafe extern "C" fn(
8897 aname: *mut MonoAssemblyName,
8898 user_data: *mut ::std::os::raw::c_void,
8899 ) -> *mut MonoAssembly,
8900>;
8901extern "C" {
8902 pub fn mono_install_assembly_search_hook(
8903 func: MonoAssemblySearchFunc,
8904 user_data: *mut ::std::os::raw::c_void,
8905 );
8906}
8907extern "C" {
8908 pub fn mono_install_assembly_refonly_search_hook(
8909 func: MonoAssemblySearchFunc,
8910 user_data: *mut ::std::os::raw::c_void,
8911 );
8912}
8913extern "C" {
8914 pub fn mono_assembly_invoke_search_hook(aname: *mut MonoAssemblyName) -> *mut MonoAssembly;
8915}
8916extern "C" {
8917 pub fn mono_install_assembly_postload_search_hook(
8918 func: MonoAssemblySearchFunc,
8919 user_data: *mut ::std::os::raw::c_void,
8920 );
8921}
8922extern "C" {
8923 pub fn mono_install_assembly_postload_refonly_search_hook(
8924 func: MonoAssemblySearchFunc,
8925 user_data: *mut ::std::os::raw::c_void,
8926 );
8927}
8928pub type MonoAssemblyPreLoadFunc = ::std::option::Option<
8929 unsafe extern "C" fn(
8930 aname: *mut MonoAssemblyName,
8931 assemblies_path: *mut *mut ::std::os::raw::c_char,
8932 user_data: *mut ::std::os::raw::c_void,
8933 ) -> *mut MonoAssembly,
8934>;
8935extern "C" {
8936 pub fn mono_install_assembly_preload_hook(
8937 func: MonoAssemblyPreLoadFunc,
8938 user_data: *mut ::std::os::raw::c_void,
8939 );
8940}
8941extern "C" {
8942 pub fn mono_install_assembly_refonly_preload_hook(
8943 func: MonoAssemblyPreLoadFunc,
8944 user_data: *mut ::std::os::raw::c_void,
8945 );
8946}
8947extern "C" {
8948 pub fn mono_assembly_invoke_load_hook(ass: *mut MonoAssembly);
8949}
8950extern "C" {
8951 pub fn mono_assembly_name_new(name: *const ::std::os::raw::c_char) -> *mut MonoAssemblyName;
8952}
8953extern "C" {
8954 pub fn mono_assembly_name_get_name(
8955 aname: *mut MonoAssemblyName,
8956 ) -> *const ::std::os::raw::c_char;
8957}
8958extern "C" {
8959 pub fn mono_assembly_name_get_culture(
8960 aname: *mut MonoAssemblyName,
8961 ) -> *const ::std::os::raw::c_char;
8962}
8963extern "C" {
8964 pub fn mono_assembly_name_get_version(
8965 aname: *mut MonoAssemblyName,
8966 minor: *mut u16,
8967 build: *mut u16,
8968 revision: *mut u16,
8969 ) -> u16;
8970}
8971extern "C" {
8972 pub fn mono_assembly_name_get_pubkeytoken(aname: *mut MonoAssemblyName) -> *mut mono_byte;
8973}
8974extern "C" {
8975 pub fn mono_assembly_name_free(aname: *mut MonoAssemblyName);
8976}
8977#[repr(C)]
8978#[derive(Debug, Copy, Clone)]
8979pub struct MonoBundledAssembly {
8980 pub name: *const ::std::os::raw::c_char,
8981 pub data: *const ::std::os::raw::c_uchar,
8982 pub size: ::std::os::raw::c_uint,
8983}
8984#[test]
8985fn bindgen_test_layout_MonoBundledAssembly() {
8986 assert_eq!(
8987 ::std::mem::size_of::<MonoBundledAssembly>(),
8988 24usize,
8989 concat!("Size of: ", stringify!(MonoBundledAssembly))
8990 );
8991 assert_eq!(
8992 ::std::mem::align_of::<MonoBundledAssembly>(),
8993 8usize,
8994 concat!("Alignment of ", stringify!(MonoBundledAssembly))
8995 );
8996 fn test_field_name() {
8997 assert_eq!(
8998 unsafe {
8999 let uninit = ::std::mem::MaybeUninit::<MonoBundledAssembly>::uninit();
9000 let ptr = uninit.as_ptr();
9001 ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize
9002 },
9003 0usize,
9004 concat!(
9005 "Offset of field: ",
9006 stringify!(MonoBundledAssembly),
9007 "::",
9008 stringify!(name)
9009 )
9010 );
9011 }
9012 test_field_name();
9013 fn test_field_data() {
9014 assert_eq!(
9015 unsafe {
9016 let uninit = ::std::mem::MaybeUninit::<MonoBundledAssembly>::uninit();
9017 let ptr = uninit.as_ptr();
9018 ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize
9019 },
9020 8usize,
9021 concat!(
9022 "Offset of field: ",
9023 stringify!(MonoBundledAssembly),
9024 "::",
9025 stringify!(data)
9026 )
9027 );
9028 }
9029 test_field_data();
9030 fn test_field_size() {
9031 assert_eq!(
9032 unsafe {
9033 let uninit = ::std::mem::MaybeUninit::<MonoBundledAssembly>::uninit();
9034 let ptr = uninit.as_ptr();
9035 ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize
9036 },
9037 16usize,
9038 concat!(
9039 "Offset of field: ",
9040 stringify!(MonoBundledAssembly),
9041 "::",
9042 stringify!(size)
9043 )
9044 );
9045 }
9046 test_field_size();
9047}
9048extern "C" {
9049 pub fn mono_register_bundled_assemblies(assemblies: *mut *const MonoBundledAssembly);
9050}
9051extern "C" {
9052 pub fn mono_register_config_for_assembly(
9053 assembly_name: *const ::std::os::raw::c_char,
9054 config_xml: *const ::std::os::raw::c_char,
9055 );
9056}
9057extern "C" {
9058 pub fn mono_register_symfile_for_assembly(
9059 assembly_name: *const ::std::os::raw::c_char,
9060 raw_contents: *const mono_byte,
9061 size: ::std::os::raw::c_int,
9062 );
9063}
9064extern "C" {
9065 pub fn mono_register_machine_config(config_xml: *const ::std::os::raw::c_char);
9066}
9067extern "C" {
9068 pub fn mono_set_rootdir();
9069}
9070extern "C" {
9071 pub fn mono_set_dirs(
9072 assembly_dir: *const ::std::os::raw::c_char,
9073 config_dir: *const ::std::os::raw::c_char,
9074 );
9075}
9076extern "C" {
9077 pub fn mono_set_assemblies_path(path: *const ::std::os::raw::c_char);
9078}
9079pub type MonoDisIndenter = ::std::option::Option<
9080 unsafe extern "C" fn(
9081 dh: *mut MonoDisHelper,
9082 method: *mut MonoMethod,
9083 ip_offset: u32,
9084 ) -> *mut ::std::os::raw::c_char,
9085>;
9086pub type MonoDisTokener = ::std::option::Option<
9087 unsafe extern "C" fn(
9088 dh: *mut MonoDisHelper,
9089 method: *mut MonoMethod,
9090 token: u32,
9091 ) -> *mut ::std::os::raw::c_char,
9092>;
9093#[repr(C)]
9094#[derive(Debug, Copy, Clone)]
9095pub struct MonoDisHelper {
9096 pub newline: *const ::std::os::raw::c_char,
9097 pub label_format: *const ::std::os::raw::c_char,
9098 pub label_target: *const ::std::os::raw::c_char,
9099 pub indenter: MonoDisIndenter,
9100 pub tokener: MonoDisTokener,
9101 pub user_data: *mut ::std::os::raw::c_void,
9102}
9103#[test]
9104fn bindgen_test_layout_MonoDisHelper() {
9105 assert_eq!(
9106 ::std::mem::size_of::<MonoDisHelper>(),
9107 48usize,
9108 concat!("Size of: ", stringify!(MonoDisHelper))
9109 );
9110 assert_eq!(
9111 ::std::mem::align_of::<MonoDisHelper>(),
9112 8usize,
9113 concat!("Alignment of ", stringify!(MonoDisHelper))
9114 );
9115 fn test_field_newline() {
9116 assert_eq!(
9117 unsafe {
9118 let uninit = ::std::mem::MaybeUninit::<MonoDisHelper>::uninit();
9119 let ptr = uninit.as_ptr();
9120 ::std::ptr::addr_of!((*ptr).newline) as usize - ptr as usize
9121 },
9122 0usize,
9123 concat!(
9124 "Offset of field: ",
9125 stringify!(MonoDisHelper),
9126 "::",
9127 stringify!(newline)
9128 )
9129 );
9130 }
9131 test_field_newline();
9132 fn test_field_label_format() {
9133 assert_eq!(
9134 unsafe {
9135 let uninit = ::std::mem::MaybeUninit::<MonoDisHelper>::uninit();
9136 let ptr = uninit.as_ptr();
9137 ::std::ptr::addr_of!((*ptr).label_format) as usize - ptr as usize
9138 },
9139 8usize,
9140 concat!(
9141 "Offset of field: ",
9142 stringify!(MonoDisHelper),
9143 "::",
9144 stringify!(label_format)
9145 )
9146 );
9147 }
9148 test_field_label_format();
9149 fn test_field_label_target() {
9150 assert_eq!(
9151 unsafe {
9152 let uninit = ::std::mem::MaybeUninit::<MonoDisHelper>::uninit();
9153 let ptr = uninit.as_ptr();
9154 ::std::ptr::addr_of!((*ptr).label_target) as usize - ptr as usize
9155 },
9156 16usize,
9157 concat!(
9158 "Offset of field: ",
9159 stringify!(MonoDisHelper),
9160 "::",
9161 stringify!(label_target)
9162 )
9163 );
9164 }
9165 test_field_label_target();
9166 fn test_field_indenter() {
9167 assert_eq!(
9168 unsafe {
9169 let uninit = ::std::mem::MaybeUninit::<MonoDisHelper>::uninit();
9170 let ptr = uninit.as_ptr();
9171 ::std::ptr::addr_of!((*ptr).indenter) as usize - ptr as usize
9172 },
9173 24usize,
9174 concat!(
9175 "Offset of field: ",
9176 stringify!(MonoDisHelper),
9177 "::",
9178 stringify!(indenter)
9179 )
9180 );
9181 }
9182 test_field_indenter();
9183 fn test_field_tokener() {
9184 assert_eq!(
9185 unsafe {
9186 let uninit = ::std::mem::MaybeUninit::<MonoDisHelper>::uninit();
9187 let ptr = uninit.as_ptr();
9188 ::std::ptr::addr_of!((*ptr).tokener) as usize - ptr as usize
9189 },
9190 32usize,
9191 concat!(
9192 "Offset of field: ",
9193 stringify!(MonoDisHelper),
9194 "::",
9195 stringify!(tokener)
9196 )
9197 );
9198 }
9199 test_field_tokener();
9200 fn test_field_user_data() {
9201 assert_eq!(
9202 unsafe {
9203 let uninit = ::std::mem::MaybeUninit::<MonoDisHelper>::uninit();
9204 let ptr = uninit.as_ptr();
9205 ::std::ptr::addr_of!((*ptr).user_data) as usize - ptr as usize
9206 },
9207 40usize,
9208 concat!(
9209 "Offset of field: ",
9210 stringify!(MonoDisHelper),
9211 "::",
9212 stringify!(user_data)
9213 )
9214 );
9215 }
9216 test_field_user_data();
9217}
9218extern "C" {
9219 pub fn mono_disasm_code_one(
9220 dh: *mut MonoDisHelper,
9221 method: *mut MonoMethod,
9222 ip: *const mono_byte,
9223 endp: *mut *const mono_byte,
9224 ) -> *mut ::std::os::raw::c_char;
9225}
9226extern "C" {
9227 pub fn mono_disasm_code(
9228 dh: *mut MonoDisHelper,
9229 method: *mut MonoMethod,
9230 ip: *const mono_byte,
9231 end: *const mono_byte,
9232 ) -> *mut ::std::os::raw::c_char;
9233}
9234#[repr(C)]
9235#[derive(Debug, Copy, Clone)]
9236pub struct MonoMethodDesc {
9237 _unused: [u8; 0],
9238}
9239extern "C" {
9240 pub fn mono_type_full_name(type_: *mut MonoType) -> *mut ::std::os::raw::c_char;
9241}
9242extern "C" {
9243 pub fn mono_signature_get_desc(
9244 sig: *mut MonoMethodSignature,
9245 include_namespace: mono_bool,
9246 ) -> *mut ::std::os::raw::c_char;
9247}
9248extern "C" {
9249 pub fn mono_context_get_desc(context: *mut MonoGenericContext) -> *mut ::std::os::raw::c_char;
9250}
9251extern "C" {
9252 pub fn mono_method_desc_new(
9253 name: *const ::std::os::raw::c_char,
9254 include_namespace: mono_bool,
9255 ) -> *mut MonoMethodDesc;
9256}
9257extern "C" {
9258 pub fn mono_method_desc_from_method(method: *mut MonoMethod) -> *mut MonoMethodDesc;
9259}
9260extern "C" {
9261 pub fn mono_method_desc_free(desc: *mut MonoMethodDesc);
9262}
9263extern "C" {
9264 pub fn mono_method_desc_match(desc: *mut MonoMethodDesc, method: *mut MonoMethod) -> mono_bool;
9265}
9266extern "C" {
9267 pub fn mono_method_desc_is_full(desc: *mut MonoMethodDesc) -> mono_bool;
9268}
9269extern "C" {
9270 pub fn mono_method_desc_full_match(
9271 desc: *mut MonoMethodDesc,
9272 method: *mut MonoMethod,
9273 ) -> mono_bool;
9274}
9275extern "C" {
9276 pub fn mono_method_desc_search_in_class(
9277 desc: *mut MonoMethodDesc,
9278 klass: *mut MonoClass,
9279 ) -> *mut MonoMethod;
9280}
9281extern "C" {
9282 pub fn mono_method_desc_search_in_image(
9283 desc: *mut MonoMethodDesc,
9284 image: *mut MonoImage,
9285 ) -> *mut MonoMethod;
9286}
9287extern "C" {
9288 pub fn mono_method_full_name(
9289 method: *mut MonoMethod,
9290 signature: mono_bool,
9291 ) -> *mut ::std::os::raw::c_char;
9292}
9293extern "C" {
9294 pub fn mono_method_get_reflection_name(method: *mut MonoMethod) -> *mut ::std::os::raw::c_char;
9295}
9296extern "C" {
9297 pub fn mono_field_full_name(field: *mut MonoClassField) -> *mut ::std::os::raw::c_char;
9298}
9299extern "C" {
9300 pub fn mono_exception_from_name(
9301 image: *mut MonoImage,
9302 name_space: *const ::std::os::raw::c_char,
9303 name: *const ::std::os::raw::c_char,
9304 ) -> *mut MonoException;
9305}
9306extern "C" {
9307 pub fn mono_exception_from_token(image: *mut MonoImage, token: u32) -> *mut MonoException;
9308}
9309extern "C" {
9310 pub fn mono_exception_from_name_two_strings(
9311 image: *mut MonoImage,
9312 name_space: *const ::std::os::raw::c_char,
9313 name: *const ::std::os::raw::c_char,
9314 a1: *mut MonoString,
9315 a2: *mut MonoString,
9316 ) -> *mut MonoException;
9317}
9318extern "C" {
9319 pub fn mono_exception_from_name_msg(
9320 image: *mut MonoImage,
9321 name_space: *const ::std::os::raw::c_char,
9322 name: *const ::std::os::raw::c_char,
9323 msg: *const ::std::os::raw::c_char,
9324 ) -> *mut MonoException;
9325}
9326extern "C" {
9327 pub fn mono_exception_from_token_two_strings(
9328 image: *mut MonoImage,
9329 token: u32,
9330 a1: *mut MonoString,
9331 a2: *mut MonoString,
9332 ) -> *mut MonoException;
9333}
9334extern "C" {
9335 pub fn mono_exception_from_name_domain(
9336 domain: *mut MonoDomain,
9337 image: *mut MonoImage,
9338 name_space: *const ::std::os::raw::c_char,
9339 name: *const ::std::os::raw::c_char,
9340 ) -> *mut MonoException;
9341}
9342extern "C" {
9343 pub fn mono_get_exception_divide_by_zero() -> *mut MonoException;
9344}
9345extern "C" {
9346 pub fn mono_get_exception_security() -> *mut MonoException;
9347}
9348extern "C" {
9349 pub fn mono_get_exception_arithmetic() -> *mut MonoException;
9350}
9351extern "C" {
9352 pub fn mono_get_exception_overflow() -> *mut MonoException;
9353}
9354extern "C" {
9355 pub fn mono_get_exception_null_reference() -> *mut MonoException;
9356}
9357extern "C" {
9358 pub fn mono_get_exception_execution_engine(
9359 msg: *const ::std::os::raw::c_char,
9360 ) -> *mut MonoException;
9361}
9362extern "C" {
9363 pub fn mono_get_exception_thread_abort() -> *mut MonoException;
9364}
9365extern "C" {
9366 pub fn mono_get_exception_thread_state(
9367 msg: *const ::std::os::raw::c_char,
9368 ) -> *mut MonoException;
9369}
9370extern "C" {
9371 pub fn mono_get_exception_thread_interrupted() -> *mut MonoException;
9372}
9373extern "C" {
9374 pub fn mono_get_exception_serialization(
9375 msg: *const ::std::os::raw::c_char,
9376 ) -> *mut MonoException;
9377}
9378extern "C" {
9379 pub fn mono_get_exception_invalid_cast() -> *mut MonoException;
9380}
9381extern "C" {
9382 pub fn mono_get_exception_invalid_operation(
9383 msg: *const ::std::os::raw::c_char,
9384 ) -> *mut MonoException;
9385}
9386extern "C" {
9387 pub fn mono_get_exception_index_out_of_range() -> *mut MonoException;
9388}
9389extern "C" {
9390 pub fn mono_get_exception_array_type_mismatch() -> *mut MonoException;
9391}
9392extern "C" {
9393 pub fn mono_get_exception_type_load(
9394 class_name: *mut MonoString,
9395 assembly_name: *mut ::std::os::raw::c_char,
9396 ) -> *mut MonoException;
9397}
9398extern "C" {
9399 pub fn mono_get_exception_missing_method(
9400 class_name: *const ::std::os::raw::c_char,
9401 member_name: *const ::std::os::raw::c_char,
9402 ) -> *mut MonoException;
9403}
9404extern "C" {
9405 pub fn mono_get_exception_missing_field(
9406 class_name: *const ::std::os::raw::c_char,
9407 member_name: *const ::std::os::raw::c_char,
9408 ) -> *mut MonoException;
9409}
9410extern "C" {
9411 pub fn mono_get_exception_not_implemented(
9412 msg: *const ::std::os::raw::c_char,
9413 ) -> *mut MonoException;
9414}
9415extern "C" {
9416 pub fn mono_get_exception_not_supported(
9417 msg: *const ::std::os::raw::c_char,
9418 ) -> *mut MonoException;
9419}
9420extern "C" {
9421 pub fn mono_get_exception_argument_null(
9422 arg: *const ::std::os::raw::c_char,
9423 ) -> *mut MonoException;
9424}
9425extern "C" {
9426 pub fn mono_get_exception_argument(
9427 arg: *const ::std::os::raw::c_char,
9428 msg: *const ::std::os::raw::c_char,
9429 ) -> *mut MonoException;
9430}
9431extern "C" {
9432 pub fn mono_get_exception_argument_out_of_range(
9433 arg: *const ::std::os::raw::c_char,
9434 ) -> *mut MonoException;
9435}
9436extern "C" {
9437 pub fn mono_get_exception_io(msg: *const ::std::os::raw::c_char) -> *mut MonoException;
9438}
9439extern "C" {
9440 pub fn mono_get_exception_file_not_found(fname: *mut MonoString) -> *mut MonoException;
9441}
9442extern "C" {
9443 pub fn mono_get_exception_file_not_found2(
9444 msg: *const ::std::os::raw::c_char,
9445 fname: *mut MonoString,
9446 ) -> *mut MonoException;
9447}
9448extern "C" {
9449 pub fn mono_get_exception_type_initialization(
9450 type_name: *const ::std::os::raw::c_char,
9451 inner: *mut MonoException,
9452 ) -> *mut MonoException;
9453}
9454extern "C" {
9455 pub fn mono_get_exception_synchronization_lock(
9456 msg: *const ::std::os::raw::c_char,
9457 ) -> *mut MonoException;
9458}
9459extern "C" {
9460 pub fn mono_get_exception_cannot_unload_appdomain(
9461 msg: *const ::std::os::raw::c_char,
9462 ) -> *mut MonoException;
9463}
9464extern "C" {
9465 pub fn mono_get_exception_appdomain_unloaded() -> *mut MonoException;
9466}
9467extern "C" {
9468 pub fn mono_get_exception_bad_image_format(
9469 msg: *const ::std::os::raw::c_char,
9470 ) -> *mut MonoException;
9471}
9472extern "C" {
9473 pub fn mono_get_exception_bad_image_format2(
9474 msg: *const ::std::os::raw::c_char,
9475 fname: *mut MonoString,
9476 ) -> *mut MonoException;
9477}
9478extern "C" {
9479 pub fn mono_get_exception_stack_overflow() -> *mut MonoException;
9480}
9481extern "C" {
9482 pub fn mono_get_exception_out_of_memory() -> *mut MonoException;
9483}
9484extern "C" {
9485 pub fn mono_get_exception_field_access() -> *mut MonoException;
9486}
9487extern "C" {
9488 pub fn mono_get_exception_method_access() -> *mut MonoException;
9489}
9490extern "C" {
9491 pub fn mono_get_exception_reflection_type_load(
9492 types: *mut MonoArray,
9493 exceptions: *mut MonoArray,
9494 ) -> *mut MonoException;
9495}
9496extern "C" {
9497 pub fn mono_get_exception_runtime_wrapped(
9498 wrapped_exception: *mut MonoObject,
9499 ) -> *mut MonoException;
9500}
9501pub type MonoUnhandledExceptionFunc = ::std::option::Option<
9502 unsafe extern "C" fn(exc: *mut MonoObject, user_data: *mut ::std::os::raw::c_void),
9503>;
9504extern "C" {
9505 pub fn mono_install_unhandled_exception_hook(
9506 func: MonoUnhandledExceptionFunc,
9507 user_data: *mut ::std::os::raw::c_void,
9508 );
9509}
9510extern "C" {
9511 pub fn mono_invoke_unhandled_exception_hook(exc: *mut MonoObject);
9512}
9513pub type MonoThreadManageCallback =
9514 ::std::option::Option<unsafe extern "C" fn(thread: *mut MonoThread) -> mono_bool>;
9515extern "C" {
9516 pub fn mono_thread_init(start_cb: MonoThreadStartCB, attach_cb: MonoThreadAttachCB);
9517}
9518extern "C" {
9519 pub fn mono_thread_cleanup();
9520}
9521extern "C" {
9522 pub fn mono_thread_manage();
9523}
9524extern "C" {
9525 pub fn mono_thread_current() -> *mut MonoThread;
9526}
9527extern "C" {
9528 pub fn mono_thread_set_main(thread: *mut MonoThread);
9529}
9530extern "C" {
9531 pub fn mono_thread_get_main() -> *mut MonoThread;
9532}
9533extern "C" {
9534 pub fn mono_thread_stop(thread: *mut MonoThread);
9535}
9536extern "C" {
9537 pub fn mono_thread_new_init(
9538 tid: isize,
9539 stack_start: *mut ::std::os::raw::c_void,
9540 func: *mut ::std::os::raw::c_void,
9541 );
9542}
9543extern "C" {
9544 pub fn mono_thread_create(
9545 domain: *mut MonoDomain,
9546 func: *mut ::std::os::raw::c_void,
9547 arg: *mut ::std::os::raw::c_void,
9548 );
9549}
9550extern "C" {
9551 pub fn mono_thread_attach(domain: *mut MonoDomain) -> *mut MonoThread;
9552}
9553extern "C" {
9554 pub fn mono_thread_detach(thread: *mut MonoThread);
9555}
9556extern "C" {
9557 pub fn mono_thread_exit();
9558}
9559extern "C" {
9560 pub fn mono_threads_attach_tools_thread();
9561}
9562extern "C" {
9563 pub fn mono_thread_get_name_utf8(thread: *mut MonoThread) -> *mut ::std::os::raw::c_char;
9564}
9565extern "C" {
9566 pub fn mono_thread_get_managed_id(thread: *mut MonoThread) -> i32;
9567}
9568extern "C" {
9569 pub fn mono_thread_set_manage_callback(thread: *mut MonoThread, func: MonoThreadManageCallback);
9570}
9571extern "C" {
9572 pub fn mono_threads_set_default_stacksize(stacksize: u32);
9573}
9574extern "C" {
9575 pub fn mono_threads_get_default_stacksize() -> u32;
9576}
9577extern "C" {
9578 pub fn mono_threads_request_thread_dump();
9579}
9580extern "C" {
9581 pub fn mono_thread_is_foreign(thread: *mut MonoThread) -> mono_bool;
9582}
9583extern "C" {
9584 pub fn mono_thread_detach_if_exiting() -> mono_bool;
9585}
9586pub type __builtin_va_list = [__va_list_tag; 1usize];
9587#[repr(C)]
9588#[derive(Debug, Copy, Clone)]
9589pub struct __va_list_tag {
9590 pub gp_offset: ::std::os::raw::c_uint,
9591 pub fp_offset: ::std::os::raw::c_uint,
9592 pub overflow_arg_area: *mut ::std::os::raw::c_void,
9593 pub reg_save_area: *mut ::std::os::raw::c_void,
9594}
9595#[test]
9596fn bindgen_test_layout___va_list_tag() {
9597 assert_eq!(
9598 ::std::mem::size_of::<__va_list_tag>(),
9599 24usize,
9600 concat!("Size of: ", stringify!(__va_list_tag))
9601 );
9602 assert_eq!(
9603 ::std::mem::align_of::<__va_list_tag>(),
9604 8usize,
9605 concat!("Alignment of ", stringify!(__va_list_tag))
9606 );
9607 fn test_field_gp_offset() {
9608 assert_eq!(
9609 unsafe {
9610 let uninit = ::std::mem::MaybeUninit::<__va_list_tag>::uninit();
9611 let ptr = uninit.as_ptr();
9612 ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize
9613 },
9614 0usize,
9615 concat!(
9616 "Offset of field: ",
9617 stringify!(__va_list_tag),
9618 "::",
9619 stringify!(gp_offset)
9620 )
9621 );
9622 }
9623 test_field_gp_offset();
9624 fn test_field_fp_offset() {
9625 assert_eq!(
9626 unsafe {
9627 let uninit = ::std::mem::MaybeUninit::<__va_list_tag>::uninit();
9628 let ptr = uninit.as_ptr();
9629 ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize
9630 },
9631 4usize,
9632 concat!(
9633 "Offset of field: ",
9634 stringify!(__va_list_tag),
9635 "::",
9636 stringify!(fp_offset)
9637 )
9638 );
9639 }
9640 test_field_fp_offset();
9641 fn test_field_overflow_arg_area() {
9642 assert_eq!(
9643 unsafe {
9644 let uninit = ::std::mem::MaybeUninit::<__va_list_tag>::uninit();
9645 let ptr = uninit.as_ptr();
9646 ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize
9647 },
9648 8usize,
9649 concat!(
9650 "Offset of field: ",
9651 stringify!(__va_list_tag),
9652 "::",
9653 stringify!(overflow_arg_area)
9654 )
9655 );
9656 }
9657 test_field_overflow_arg_area();
9658 fn test_field_reg_save_area() {
9659 assert_eq!(
9660 unsafe {
9661 let uninit = ::std::mem::MaybeUninit::<__va_list_tag>::uninit();
9662 let ptr = uninit.as_ptr();
9663 ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize
9664 },
9665 16usize,
9666 concat!(
9667 "Offset of field: ",
9668 stringify!(__va_list_tag),
9669 "::",
9670 stringify!(reg_save_area)
9671 )
9672 );
9673 }
9674 test_field_reg_save_area();
9675}