1pub const _SYS_TYPES_H: u32 = 1;
4pub const _FEATURES_H: u32 = 1;
5pub const _DEFAULT_SOURCE: u32 = 1;
6pub const __GLIBC_USE_ISOC2X: u32 = 0;
7pub const __USE_ISOC11: u32 = 1;
8pub const __USE_ISOC99: u32 = 1;
9pub const __USE_ISOC95: u32 = 1;
10pub const __USE_POSIX_IMPLICITLY: u32 = 1;
11pub const _POSIX_SOURCE: u32 = 1;
12pub const _POSIX_C_SOURCE: u32 = 200809;
13pub const __USE_POSIX: u32 = 1;
14pub const __USE_POSIX2: u32 = 1;
15pub const __USE_POSIX199309: u32 = 1;
16pub const __USE_POSIX199506: u32 = 1;
17pub const __USE_XOPEN2K: u32 = 1;
18pub const __USE_XOPEN2K8: u32 = 1;
19pub const _ATFILE_SOURCE: u32 = 1;
20pub const __USE_MISC: u32 = 1;
21pub const __USE_ATFILE: u32 = 1;
22pub const __USE_FORTIFY_LEVEL: u32 = 0;
23pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
24pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
25pub const _STDC_PREDEF_H: u32 = 1;
26pub const __STDC_IEC_559__: u32 = 1;
27pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
28pub const __STDC_ISO_10646__: u32 = 201706;
29pub const __GNU_LIBRARY__: u32 = 6;
30pub const __GLIBC__: u32 = 2;
31pub const __GLIBC_MINOR__: u32 = 31;
32pub const _SYS_CDEFS_H: u32 = 1;
33pub const __glibc_c99_flexarr_available: u32 = 1;
34pub const __WORDSIZE: u32 = 64;
35pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
36pub const __SYSCALL_WORDSIZE: u32 = 64;
37pub const __LONG_DOUBLE_USES_FLOAT128: u32 = 0;
38pub const __HAVE_GENERIC_SELECTION: u32 = 1;
39pub const _BITS_TYPES_H: u32 = 1;
40pub const __TIMESIZE: u32 = 64;
41pub const _BITS_TYPESIZES_H: u32 = 1;
42pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
43pub const __INO_T_MATCHES_INO64_T: u32 = 1;
44pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
45pub const __STATFS_MATCHES_STATFS64: u32 = 1;
46pub const __FD_SETSIZE: u32 = 1024;
47pub const _BITS_TIME64_H: u32 = 1;
48pub const __clock_t_defined: u32 = 1;
49pub const __clockid_t_defined: u32 = 1;
50pub const __time_t_defined: u32 = 1;
51pub const __timer_t_defined: u32 = 1;
52pub const _BITS_STDINT_INTN_H: u32 = 1;
53pub const __BIT_TYPES_DEFINED__: u32 = 1;
54pub const _ENDIAN_H: u32 = 1;
55pub const _BITS_ENDIAN_H: u32 = 1;
56pub const __LITTLE_ENDIAN: u32 = 1234;
57pub const __BIG_ENDIAN: u32 = 4321;
58pub const __PDP_ENDIAN: u32 = 3412;
59pub const _BITS_ENDIANNESS_H: u32 = 1;
60pub const __BYTE_ORDER: u32 = 1234;
61pub const __FLOAT_WORD_ORDER: u32 = 1234;
62pub const LITTLE_ENDIAN: u32 = 1234;
63pub const BIG_ENDIAN: u32 = 4321;
64pub const PDP_ENDIAN: u32 = 3412;
65pub const BYTE_ORDER: u32 = 1234;
66pub const _BITS_BYTESWAP_H: u32 = 1;
67pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
68pub const _SYS_SELECT_H: u32 = 1;
69pub const __FD_ZERO_STOS: &[u8; 6] = b"stosq\0";
70pub const __sigset_t_defined: u32 = 1;
71pub const __timeval_defined: u32 = 1;
72pub const _STRUCT_TIMESPEC: u32 = 1;
73pub const FD_SETSIZE: u32 = 1024;
74pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
75pub const _THREAD_SHARED_TYPES_H: u32 = 1;
76pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
77pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
78pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
79pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
80pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
81pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
82pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
83pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
84pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
85pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
86pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
87pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
88pub const __have_pthread_attr_t: u32 = 1;
89pub type __u_char = ::std::os::raw::c_uchar;
90pub type __u_short = ::std::os::raw::c_ushort;
91pub type __u_int = ::std::os::raw::c_uint;
92pub type __u_long = ::std::os::raw::c_ulong;
93pub type __int8_t = ::std::os::raw::c_schar;
94pub type __uint8_t = ::std::os::raw::c_uchar;
95pub type __int16_t = ::std::os::raw::c_short;
96pub type __uint16_t = ::std::os::raw::c_ushort;
97pub type __int32_t = ::std::os::raw::c_int;
98pub type __uint32_t = ::std::os::raw::c_uint;
99pub type __int64_t = ::std::os::raw::c_long;
100pub type __uint64_t = ::std::os::raw::c_ulong;
101pub type __int_least8_t = __int8_t;
102pub type __uint_least8_t = __uint8_t;
103pub type __int_least16_t = __int16_t;
104pub type __uint_least16_t = __uint16_t;
105pub type __int_least32_t = __int32_t;
106pub type __uint_least32_t = __uint32_t;
107pub type __int_least64_t = __int64_t;
108pub type __uint_least64_t = __uint64_t;
109pub type __quad_t = ::std::os::raw::c_long;
110pub type __u_quad_t = ::std::os::raw::c_ulong;
111pub type __intmax_t = ::std::os::raw::c_long;
112pub type __uintmax_t = ::std::os::raw::c_ulong;
113pub type __dev_t = ::std::os::raw::c_ulong;
114pub type __uid_t = ::std::os::raw::c_uint;
115pub type __gid_t = ::std::os::raw::c_uint;
116pub type __ino_t = ::std::os::raw::c_ulong;
117pub type __ino64_t = ::std::os::raw::c_ulong;
118pub type __mode_t = ::std::os::raw::c_uint;
119pub type __nlink_t = ::std::os::raw::c_ulong;
120pub type __off_t = ::std::os::raw::c_long;
121pub type __off64_t = ::std::os::raw::c_long;
122pub type __pid_t = ::std::os::raw::c_int;
123#[repr(C)]
124#[derive(Debug, Copy, Clone)]
125pub struct __fsid_t {
126 pub __val: [::std::os::raw::c_int; 2usize],
127}
128#[test]
129fn bindgen_test_layout___fsid_t() {
130 const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
131 let ptr = UNINIT.as_ptr();
132 assert_eq!(
133 ::std::mem::size_of::<__fsid_t>(),
134 8usize,
135 concat!("Size of: ", stringify!(__fsid_t))
136 );
137 assert_eq!(
138 ::std::mem::align_of::<__fsid_t>(),
139 4usize,
140 concat!("Alignment of ", stringify!(__fsid_t))
141 );
142 assert_eq!(
143 unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
144 0usize,
145 concat!(
146 "Offset of field: ",
147 stringify!(__fsid_t),
148 "::",
149 stringify!(__val)
150 )
151 );
152}
153pub type __clock_t = ::std::os::raw::c_long;
154pub type __rlim_t = ::std::os::raw::c_ulong;
155pub type __rlim64_t = ::std::os::raw::c_ulong;
156pub type __id_t = ::std::os::raw::c_uint;
157pub type __time_t = ::std::os::raw::c_long;
158pub type __useconds_t = ::std::os::raw::c_uint;
159pub type __suseconds_t = ::std::os::raw::c_long;
160pub type __daddr_t = ::std::os::raw::c_int;
161pub type __key_t = ::std::os::raw::c_int;
162pub type __clockid_t = ::std::os::raw::c_int;
163pub type __timer_t = *mut ::std::os::raw::c_void;
164pub type __blksize_t = ::std::os::raw::c_long;
165pub type __blkcnt_t = ::std::os::raw::c_long;
166pub type __blkcnt64_t = ::std::os::raw::c_long;
167pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
168pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
169pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
170pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
171pub type __fsword_t = ::std::os::raw::c_long;
172pub type __ssize_t = ::std::os::raw::c_long;
173pub type __syscall_slong_t = ::std::os::raw::c_long;
174pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
175pub type __loff_t = __off64_t;
176pub type __caddr_t = *mut ::std::os::raw::c_char;
177pub type __intptr_t = ::std::os::raw::c_long;
178pub type __socklen_t = ::std::os::raw::c_uint;
179pub type __sig_atomic_t = ::std::os::raw::c_int;
180pub type u_char = __u_char;
181pub type u_short = __u_short;
182pub type u_int = __u_int;
183pub type u_long = __u_long;
184pub type quad_t = __quad_t;
185pub type u_quad_t = __u_quad_t;
186pub type fsid_t = __fsid_t;
187pub type loff_t = __loff_t;
188pub type ino_t = __ino_t;
189pub type dev_t = __dev_t;
190pub type gid_t = __gid_t;
191pub type mode_t = __mode_t;
192pub type nlink_t = __nlink_t;
193pub type uid_t = __uid_t;
194pub type off_t = __off_t;
195pub type pid_t = __pid_t;
196pub type id_t = __id_t;
197pub type daddr_t = __daddr_t;
198pub type caddr_t = __caddr_t;
199pub type key_t = __key_t;
200pub type clock_t = __clock_t;
201pub type clockid_t = __clockid_t;
202pub type time_t = __time_t;
203pub type timer_t = __timer_t;
204pub type ulong = ::std::os::raw::c_ulong;
205pub type ushort = ::std::os::raw::c_ushort;
206pub type uint = ::std::os::raw::c_uint;
207pub type u_int8_t = __uint8_t;
208pub type u_int16_t = __uint16_t;
209pub type u_int32_t = __uint32_t;
210pub type u_int64_t = __uint64_t;
211pub type register_t = ::std::os::raw::c_long;
212#[repr(C)]
213#[derive(Debug, Copy, Clone)]
214pub struct __sigset_t {
215 pub __val: [::std::os::raw::c_ulong; 16usize],
216}
217#[test]
218fn bindgen_test_layout___sigset_t() {
219 const UNINIT: ::std::mem::MaybeUninit<__sigset_t> = ::std::mem::MaybeUninit::uninit();
220 let ptr = UNINIT.as_ptr();
221 assert_eq!(
222 ::std::mem::size_of::<__sigset_t>(),
223 128usize,
224 concat!("Size of: ", stringify!(__sigset_t))
225 );
226 assert_eq!(
227 ::std::mem::align_of::<__sigset_t>(),
228 8usize,
229 concat!("Alignment of ", stringify!(__sigset_t))
230 );
231 assert_eq!(
232 unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
233 0usize,
234 concat!(
235 "Offset of field: ",
236 stringify!(__sigset_t),
237 "::",
238 stringify!(__val)
239 )
240 );
241}
242pub type sigset_t = __sigset_t;
243#[repr(C)]
244#[derive(Debug, Copy, Clone)]
245pub struct timeval {
246 pub tv_sec: __time_t,
247 pub tv_usec: __suseconds_t,
248}
249#[test]
250fn bindgen_test_layout_timeval() {
251 const UNINIT: ::std::mem::MaybeUninit<timeval> = ::std::mem::MaybeUninit::uninit();
252 let ptr = UNINIT.as_ptr();
253 assert_eq!(
254 ::std::mem::size_of::<timeval>(),
255 16usize,
256 concat!("Size of: ", stringify!(timeval))
257 );
258 assert_eq!(
259 ::std::mem::align_of::<timeval>(),
260 8usize,
261 concat!("Alignment of ", stringify!(timeval))
262 );
263 assert_eq!(
264 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
265 0usize,
266 concat!(
267 "Offset of field: ",
268 stringify!(timeval),
269 "::",
270 stringify!(tv_sec)
271 )
272 );
273 assert_eq!(
274 unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize },
275 8usize,
276 concat!(
277 "Offset of field: ",
278 stringify!(timeval),
279 "::",
280 stringify!(tv_usec)
281 )
282 );
283}
284#[repr(C)]
285#[derive(Debug, Copy, Clone)]
286pub struct timespec {
287 pub tv_sec: __time_t,
288 pub tv_nsec: __syscall_slong_t,
289}
290#[test]
291fn bindgen_test_layout_timespec() {
292 const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
293 let ptr = UNINIT.as_ptr();
294 assert_eq!(
295 ::std::mem::size_of::<timespec>(),
296 16usize,
297 concat!("Size of: ", stringify!(timespec))
298 );
299 assert_eq!(
300 ::std::mem::align_of::<timespec>(),
301 8usize,
302 concat!("Alignment of ", stringify!(timespec))
303 );
304 assert_eq!(
305 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
306 0usize,
307 concat!(
308 "Offset of field: ",
309 stringify!(timespec),
310 "::",
311 stringify!(tv_sec)
312 )
313 );
314 assert_eq!(
315 unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
316 8usize,
317 concat!(
318 "Offset of field: ",
319 stringify!(timespec),
320 "::",
321 stringify!(tv_nsec)
322 )
323 );
324}
325pub type suseconds_t = __suseconds_t;
326pub type __fd_mask = ::std::os::raw::c_long;
327#[repr(C)]
328#[derive(Debug, Copy, Clone)]
329pub struct fd_set {
330 pub __fds_bits: [__fd_mask; 16usize],
331}
332#[test]
333fn bindgen_test_layout_fd_set() {
334 const UNINIT: ::std::mem::MaybeUninit<fd_set> = ::std::mem::MaybeUninit::uninit();
335 let ptr = UNINIT.as_ptr();
336 assert_eq!(
337 ::std::mem::size_of::<fd_set>(),
338 128usize,
339 concat!("Size of: ", stringify!(fd_set))
340 );
341 assert_eq!(
342 ::std::mem::align_of::<fd_set>(),
343 8usize,
344 concat!("Alignment of ", stringify!(fd_set))
345 );
346 assert_eq!(
347 unsafe { ::std::ptr::addr_of!((*ptr).__fds_bits) as usize - ptr as usize },
348 0usize,
349 concat!(
350 "Offset of field: ",
351 stringify!(fd_set),
352 "::",
353 stringify!(__fds_bits)
354 )
355 );
356}
357pub type fd_mask = __fd_mask;
358extern "C" {
359 pub fn select(
360 __nfds: ::std::os::raw::c_int,
361 __readfds: *mut fd_set,
362 __writefds: *mut fd_set,
363 __exceptfds: *mut fd_set,
364 __timeout: *mut timeval,
365 ) -> ::std::os::raw::c_int;
366}
367extern "C" {
368 pub fn pselect(
369 __nfds: ::std::os::raw::c_int,
370 __readfds: *mut fd_set,
371 __writefds: *mut fd_set,
372 __exceptfds: *mut fd_set,
373 __timeout: *const timespec,
374 __sigmask: *const __sigset_t,
375 ) -> ::std::os::raw::c_int;
376}
377pub type blksize_t = __blksize_t;
378pub type blkcnt_t = __blkcnt_t;
379pub type fsblkcnt_t = __fsblkcnt_t;
380pub type fsfilcnt_t = __fsfilcnt_t;
381#[repr(C)]
382#[derive(Debug, Copy, Clone)]
383pub struct __pthread_internal_list {
384 pub __prev: *mut __pthread_internal_list,
385 pub __next: *mut __pthread_internal_list,
386}
387#[test]
388fn bindgen_test_layout___pthread_internal_list() {
389 const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_list> =
390 ::std::mem::MaybeUninit::uninit();
391 let ptr = UNINIT.as_ptr();
392 assert_eq!(
393 ::std::mem::size_of::<__pthread_internal_list>(),
394 16usize,
395 concat!("Size of: ", stringify!(__pthread_internal_list))
396 );
397 assert_eq!(
398 ::std::mem::align_of::<__pthread_internal_list>(),
399 8usize,
400 concat!("Alignment of ", stringify!(__pthread_internal_list))
401 );
402 assert_eq!(
403 unsafe { ::std::ptr::addr_of!((*ptr).__prev) as usize - ptr as usize },
404 0usize,
405 concat!(
406 "Offset of field: ",
407 stringify!(__pthread_internal_list),
408 "::",
409 stringify!(__prev)
410 )
411 );
412 assert_eq!(
413 unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
414 8usize,
415 concat!(
416 "Offset of field: ",
417 stringify!(__pthread_internal_list),
418 "::",
419 stringify!(__next)
420 )
421 );
422}
423pub type __pthread_list_t = __pthread_internal_list;
424#[repr(C)]
425#[derive(Debug, Copy, Clone)]
426pub struct __pthread_internal_slist {
427 pub __next: *mut __pthread_internal_slist,
428}
429#[test]
430fn bindgen_test_layout___pthread_internal_slist() {
431 const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_slist> =
432 ::std::mem::MaybeUninit::uninit();
433 let ptr = UNINIT.as_ptr();
434 assert_eq!(
435 ::std::mem::size_of::<__pthread_internal_slist>(),
436 8usize,
437 concat!("Size of: ", stringify!(__pthread_internal_slist))
438 );
439 assert_eq!(
440 ::std::mem::align_of::<__pthread_internal_slist>(),
441 8usize,
442 concat!("Alignment of ", stringify!(__pthread_internal_slist))
443 );
444 assert_eq!(
445 unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
446 0usize,
447 concat!(
448 "Offset of field: ",
449 stringify!(__pthread_internal_slist),
450 "::",
451 stringify!(__next)
452 )
453 );
454}
455pub type __pthread_slist_t = __pthread_internal_slist;
456#[repr(C)]
457#[derive(Debug, Copy, Clone)]
458pub struct __pthread_mutex_s {
459 pub __lock: ::std::os::raw::c_int,
460 pub __count: ::std::os::raw::c_uint,
461 pub __owner: ::std::os::raw::c_int,
462 pub __nusers: ::std::os::raw::c_uint,
463 pub __kind: ::std::os::raw::c_int,
464 pub __spins: ::std::os::raw::c_short,
465 pub __elision: ::std::os::raw::c_short,
466 pub __list: __pthread_list_t,
467}
468#[test]
469fn bindgen_test_layout___pthread_mutex_s() {
470 const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s> = ::std::mem::MaybeUninit::uninit();
471 let ptr = UNINIT.as_ptr();
472 assert_eq!(
473 ::std::mem::size_of::<__pthread_mutex_s>(),
474 40usize,
475 concat!("Size of: ", stringify!(__pthread_mutex_s))
476 );
477 assert_eq!(
478 ::std::mem::align_of::<__pthread_mutex_s>(),
479 8usize,
480 concat!("Alignment of ", stringify!(__pthread_mutex_s))
481 );
482 assert_eq!(
483 unsafe { ::std::ptr::addr_of!((*ptr).__lock) as usize - ptr as usize },
484 0usize,
485 concat!(
486 "Offset of field: ",
487 stringify!(__pthread_mutex_s),
488 "::",
489 stringify!(__lock)
490 )
491 );
492 assert_eq!(
493 unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
494 4usize,
495 concat!(
496 "Offset of field: ",
497 stringify!(__pthread_mutex_s),
498 "::",
499 stringify!(__count)
500 )
501 );
502 assert_eq!(
503 unsafe { ::std::ptr::addr_of!((*ptr).__owner) as usize - ptr as usize },
504 8usize,
505 concat!(
506 "Offset of field: ",
507 stringify!(__pthread_mutex_s),
508 "::",
509 stringify!(__owner)
510 )
511 );
512 assert_eq!(
513 unsafe { ::std::ptr::addr_of!((*ptr).__nusers) as usize - ptr as usize },
514 12usize,
515 concat!(
516 "Offset of field: ",
517 stringify!(__pthread_mutex_s),
518 "::",
519 stringify!(__nusers)
520 )
521 );
522 assert_eq!(
523 unsafe { ::std::ptr::addr_of!((*ptr).__kind) as usize - ptr as usize },
524 16usize,
525 concat!(
526 "Offset of field: ",
527 stringify!(__pthread_mutex_s),
528 "::",
529 stringify!(__kind)
530 )
531 );
532 assert_eq!(
533 unsafe { ::std::ptr::addr_of!((*ptr).__spins) as usize - ptr as usize },
534 20usize,
535 concat!(
536 "Offset of field: ",
537 stringify!(__pthread_mutex_s),
538 "::",
539 stringify!(__spins)
540 )
541 );
542 assert_eq!(
543 unsafe { ::std::ptr::addr_of!((*ptr).__elision) as usize - ptr as usize },
544 22usize,
545 concat!(
546 "Offset of field: ",
547 stringify!(__pthread_mutex_s),
548 "::",
549 stringify!(__elision)
550 )
551 );
552 assert_eq!(
553 unsafe { ::std::ptr::addr_of!((*ptr).__list) as usize - ptr as usize },
554 24usize,
555 concat!(
556 "Offset of field: ",
557 stringify!(__pthread_mutex_s),
558 "::",
559 stringify!(__list)
560 )
561 );
562}
563#[repr(C)]
564#[derive(Debug, Copy, Clone)]
565pub struct __pthread_rwlock_arch_t {
566 pub __readers: ::std::os::raw::c_uint,
567 pub __writers: ::std::os::raw::c_uint,
568 pub __wrphase_futex: ::std::os::raw::c_uint,
569 pub __writers_futex: ::std::os::raw::c_uint,
570 pub __pad3: ::std::os::raw::c_uint,
571 pub __pad4: ::std::os::raw::c_uint,
572 pub __cur_writer: ::std::os::raw::c_int,
573 pub __shared: ::std::os::raw::c_int,
574 pub __rwelision: ::std::os::raw::c_schar,
575 pub __pad1: [::std::os::raw::c_uchar; 7usize],
576 pub __pad2: ::std::os::raw::c_ulong,
577 pub __flags: ::std::os::raw::c_uint,
578}
579#[test]
580fn bindgen_test_layout___pthread_rwlock_arch_t() {
581 const UNINIT: ::std::mem::MaybeUninit<__pthread_rwlock_arch_t> =
582 ::std::mem::MaybeUninit::uninit();
583 let ptr = UNINIT.as_ptr();
584 assert_eq!(
585 ::std::mem::size_of::<__pthread_rwlock_arch_t>(),
586 56usize,
587 concat!("Size of: ", stringify!(__pthread_rwlock_arch_t))
588 );
589 assert_eq!(
590 ::std::mem::align_of::<__pthread_rwlock_arch_t>(),
591 8usize,
592 concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
593 );
594 assert_eq!(
595 unsafe { ::std::ptr::addr_of!((*ptr).__readers) as usize - ptr as usize },
596 0usize,
597 concat!(
598 "Offset of field: ",
599 stringify!(__pthread_rwlock_arch_t),
600 "::",
601 stringify!(__readers)
602 )
603 );
604 assert_eq!(
605 unsafe { ::std::ptr::addr_of!((*ptr).__writers) as usize - ptr as usize },
606 4usize,
607 concat!(
608 "Offset of field: ",
609 stringify!(__pthread_rwlock_arch_t),
610 "::",
611 stringify!(__writers)
612 )
613 );
614 assert_eq!(
615 unsafe { ::std::ptr::addr_of!((*ptr).__wrphase_futex) as usize - ptr as usize },
616 8usize,
617 concat!(
618 "Offset of field: ",
619 stringify!(__pthread_rwlock_arch_t),
620 "::",
621 stringify!(__wrphase_futex)
622 )
623 );
624 assert_eq!(
625 unsafe { ::std::ptr::addr_of!((*ptr).__writers_futex) as usize - ptr as usize },
626 12usize,
627 concat!(
628 "Offset of field: ",
629 stringify!(__pthread_rwlock_arch_t),
630 "::",
631 stringify!(__writers_futex)
632 )
633 );
634 assert_eq!(
635 unsafe { ::std::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize },
636 16usize,
637 concat!(
638 "Offset of field: ",
639 stringify!(__pthread_rwlock_arch_t),
640 "::",
641 stringify!(__pad3)
642 )
643 );
644 assert_eq!(
645 unsafe { ::std::ptr::addr_of!((*ptr).__pad4) as usize - ptr as usize },
646 20usize,
647 concat!(
648 "Offset of field: ",
649 stringify!(__pthread_rwlock_arch_t),
650 "::",
651 stringify!(__pad4)
652 )
653 );
654 assert_eq!(
655 unsafe { ::std::ptr::addr_of!((*ptr).__cur_writer) as usize - ptr as usize },
656 24usize,
657 concat!(
658 "Offset of field: ",
659 stringify!(__pthread_rwlock_arch_t),
660 "::",
661 stringify!(__cur_writer)
662 )
663 );
664 assert_eq!(
665 unsafe { ::std::ptr::addr_of!((*ptr).__shared) as usize - ptr as usize },
666 28usize,
667 concat!(
668 "Offset of field: ",
669 stringify!(__pthread_rwlock_arch_t),
670 "::",
671 stringify!(__shared)
672 )
673 );
674 assert_eq!(
675 unsafe { ::std::ptr::addr_of!((*ptr).__rwelision) as usize - ptr as usize },
676 32usize,
677 concat!(
678 "Offset of field: ",
679 stringify!(__pthread_rwlock_arch_t),
680 "::",
681 stringify!(__rwelision)
682 )
683 );
684 assert_eq!(
685 unsafe { ::std::ptr::addr_of!((*ptr).__pad1) as usize - ptr as usize },
686 33usize,
687 concat!(
688 "Offset of field: ",
689 stringify!(__pthread_rwlock_arch_t),
690 "::",
691 stringify!(__pad1)
692 )
693 );
694 assert_eq!(
695 unsafe { ::std::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize },
696 40usize,
697 concat!(
698 "Offset of field: ",
699 stringify!(__pthread_rwlock_arch_t),
700 "::",
701 stringify!(__pad2)
702 )
703 );
704 assert_eq!(
705 unsafe { ::std::ptr::addr_of!((*ptr).__flags) as usize - ptr as usize },
706 48usize,
707 concat!(
708 "Offset of field: ",
709 stringify!(__pthread_rwlock_arch_t),
710 "::",
711 stringify!(__flags)
712 )
713 );
714}
715#[repr(C)]
716#[derive(Copy, Clone)]
717pub struct __pthread_cond_s {
718 pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1,
719 pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2,
720 pub __g_refs: [::std::os::raw::c_uint; 2usize],
721 pub __g_size: [::std::os::raw::c_uint; 2usize],
722 pub __g1_orig_size: ::std::os::raw::c_uint,
723 pub __wrefs: ::std::os::raw::c_uint,
724 pub __g_signals: [::std::os::raw::c_uint; 2usize],
725}
726#[repr(C)]
727#[derive(Copy, Clone)]
728pub union __pthread_cond_s__bindgen_ty_1 {
729 pub __wseq: ::std::os::raw::c_ulonglong,
730 pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
731}
732#[repr(C)]
733#[derive(Debug, Copy, Clone)]
734pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
735 pub __low: ::std::os::raw::c_uint,
736 pub __high: ::std::os::raw::c_uint,
737}
738#[test]
739fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1__bindgen_ty_1() {
740 const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1> =
741 ::std::mem::MaybeUninit::uninit();
742 let ptr = UNINIT.as_ptr();
743 assert_eq!(
744 ::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
745 8usize,
746 concat!(
747 "Size of: ",
748 stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
749 )
750 );
751 assert_eq!(
752 ::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
753 4usize,
754 concat!(
755 "Alignment of ",
756 stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
757 )
758 );
759 assert_eq!(
760 unsafe { ::std::ptr::addr_of!((*ptr).__low) as usize - ptr as usize },
761 0usize,
762 concat!(
763 "Offset of field: ",
764 stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
765 "::",
766 stringify!(__low)
767 )
768 );
769 assert_eq!(
770 unsafe { ::std::ptr::addr_of!((*ptr).__high) as usize - ptr as usize },
771 4usize,
772 concat!(
773 "Offset of field: ",
774 stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
775 "::",
776 stringify!(__high)
777 )
778 );
779}
780#[test]
781fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1() {
782 const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s__bindgen_ty_1> =
783 ::std::mem::MaybeUninit::uninit();
784 let ptr = UNINIT.as_ptr();
785 assert_eq!(
786 ::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1>(),
787 8usize,
788 concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_1))
789 );
790 assert_eq!(
791 ::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1>(),
792 8usize,
793 concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_1))
794 );
795 assert_eq!(
796 unsafe { ::std::ptr::addr_of!((*ptr).__wseq) as usize - ptr as usize },
797 0usize,
798 concat!(
799 "Offset of field: ",
800 stringify!(__pthread_cond_s__bindgen_ty_1),
801 "::",
802 stringify!(__wseq)
803 )
804 );
805 assert_eq!(
806 unsafe { ::std::ptr::addr_of!((*ptr).__wseq32) as usize - ptr as usize },
807 0usize,
808 concat!(
809 "Offset of field: ",
810 stringify!(__pthread_cond_s__bindgen_ty_1),
811 "::",
812 stringify!(__wseq32)
813 )
814 );
815}
816#[repr(C)]
817#[derive(Copy, Clone)]
818pub union __pthread_cond_s__bindgen_ty_2 {
819 pub __g1_start: ::std::os::raw::c_ulonglong,
820 pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
821}
822#[repr(C)]
823#[derive(Debug, Copy, Clone)]
824pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
825 pub __low: ::std::os::raw::c_uint,
826 pub __high: ::std::os::raw::c_uint,
827}
828#[test]
829fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2__bindgen_ty_1() {
830 const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1> =
831 ::std::mem::MaybeUninit::uninit();
832 let ptr = UNINIT.as_ptr();
833 assert_eq!(
834 ::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
835 8usize,
836 concat!(
837 "Size of: ",
838 stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
839 )
840 );
841 assert_eq!(
842 ::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
843 4usize,
844 concat!(
845 "Alignment of ",
846 stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
847 )
848 );
849 assert_eq!(
850 unsafe { ::std::ptr::addr_of!((*ptr).__low) as usize - ptr as usize },
851 0usize,
852 concat!(
853 "Offset of field: ",
854 stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
855 "::",
856 stringify!(__low)
857 )
858 );
859 assert_eq!(
860 unsafe { ::std::ptr::addr_of!((*ptr).__high) as usize - ptr as usize },
861 4usize,
862 concat!(
863 "Offset of field: ",
864 stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
865 "::",
866 stringify!(__high)
867 )
868 );
869}
870#[test]
871fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2() {
872 const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s__bindgen_ty_2> =
873 ::std::mem::MaybeUninit::uninit();
874 let ptr = UNINIT.as_ptr();
875 assert_eq!(
876 ::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2>(),
877 8usize,
878 concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_2))
879 );
880 assert_eq!(
881 ::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2>(),
882 8usize,
883 concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_2))
884 );
885 assert_eq!(
886 unsafe { ::std::ptr::addr_of!((*ptr).__g1_start) as usize - ptr as usize },
887 0usize,
888 concat!(
889 "Offset of field: ",
890 stringify!(__pthread_cond_s__bindgen_ty_2),
891 "::",
892 stringify!(__g1_start)
893 )
894 );
895 assert_eq!(
896 unsafe { ::std::ptr::addr_of!((*ptr).__g1_start32) as usize - ptr as usize },
897 0usize,
898 concat!(
899 "Offset of field: ",
900 stringify!(__pthread_cond_s__bindgen_ty_2),
901 "::",
902 stringify!(__g1_start32)
903 )
904 );
905}
906#[test]
907fn bindgen_test_layout___pthread_cond_s() {
908 const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s> = ::std::mem::MaybeUninit::uninit();
909 let ptr = UNINIT.as_ptr();
910 assert_eq!(
911 ::std::mem::size_of::<__pthread_cond_s>(),
912 48usize,
913 concat!("Size of: ", stringify!(__pthread_cond_s))
914 );
915 assert_eq!(
916 ::std::mem::align_of::<__pthread_cond_s>(),
917 8usize,
918 concat!("Alignment of ", stringify!(__pthread_cond_s))
919 );
920 assert_eq!(
921 unsafe { ::std::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as usize },
922 16usize,
923 concat!(
924 "Offset of field: ",
925 stringify!(__pthread_cond_s),
926 "::",
927 stringify!(__g_refs)
928 )
929 );
930 assert_eq!(
931 unsafe { ::std::ptr::addr_of!((*ptr).__g_size) as usize - ptr as usize },
932 24usize,
933 concat!(
934 "Offset of field: ",
935 stringify!(__pthread_cond_s),
936 "::",
937 stringify!(__g_size)
938 )
939 );
940 assert_eq!(
941 unsafe { ::std::ptr::addr_of!((*ptr).__g1_orig_size) as usize - ptr as usize },
942 32usize,
943 concat!(
944 "Offset of field: ",
945 stringify!(__pthread_cond_s),
946 "::",
947 stringify!(__g1_orig_size)
948 )
949 );
950 assert_eq!(
951 unsafe { ::std::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as usize },
952 36usize,
953 concat!(
954 "Offset of field: ",
955 stringify!(__pthread_cond_s),
956 "::",
957 stringify!(__wrefs)
958 )
959 );
960 assert_eq!(
961 unsafe { ::std::ptr::addr_of!((*ptr).__g_signals) as usize - ptr as usize },
962 40usize,
963 concat!(
964 "Offset of field: ",
965 stringify!(__pthread_cond_s),
966 "::",
967 stringify!(__g_signals)
968 )
969 );
970}
971pub type pthread_t = ::std::os::raw::c_ulong;
972#[repr(C)]
973#[derive(Copy, Clone)]
974pub union pthread_mutexattr_t {
975 pub __size: [::std::os::raw::c_char; 4usize],
976 pub __align: ::std::os::raw::c_int,
977}
978#[test]
979fn bindgen_test_layout_pthread_mutexattr_t() {
980 const UNINIT: ::std::mem::MaybeUninit<pthread_mutexattr_t> = ::std::mem::MaybeUninit::uninit();
981 let ptr = UNINIT.as_ptr();
982 assert_eq!(
983 ::std::mem::size_of::<pthread_mutexattr_t>(),
984 4usize,
985 concat!("Size of: ", stringify!(pthread_mutexattr_t))
986 );
987 assert_eq!(
988 ::std::mem::align_of::<pthread_mutexattr_t>(),
989 4usize,
990 concat!("Alignment of ", stringify!(pthread_mutexattr_t))
991 );
992 assert_eq!(
993 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
994 0usize,
995 concat!(
996 "Offset of field: ",
997 stringify!(pthread_mutexattr_t),
998 "::",
999 stringify!(__size)
1000 )
1001 );
1002 assert_eq!(
1003 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1004 0usize,
1005 concat!(
1006 "Offset of field: ",
1007 stringify!(pthread_mutexattr_t),
1008 "::",
1009 stringify!(__align)
1010 )
1011 );
1012}
1013#[repr(C)]
1014#[derive(Copy, Clone)]
1015pub union pthread_condattr_t {
1016 pub __size: [::std::os::raw::c_char; 4usize],
1017 pub __align: ::std::os::raw::c_int,
1018}
1019#[test]
1020fn bindgen_test_layout_pthread_condattr_t() {
1021 const UNINIT: ::std::mem::MaybeUninit<pthread_condattr_t> = ::std::mem::MaybeUninit::uninit();
1022 let ptr = UNINIT.as_ptr();
1023 assert_eq!(
1024 ::std::mem::size_of::<pthread_condattr_t>(),
1025 4usize,
1026 concat!("Size of: ", stringify!(pthread_condattr_t))
1027 );
1028 assert_eq!(
1029 ::std::mem::align_of::<pthread_condattr_t>(),
1030 4usize,
1031 concat!("Alignment of ", stringify!(pthread_condattr_t))
1032 );
1033 assert_eq!(
1034 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1035 0usize,
1036 concat!(
1037 "Offset of field: ",
1038 stringify!(pthread_condattr_t),
1039 "::",
1040 stringify!(__size)
1041 )
1042 );
1043 assert_eq!(
1044 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1045 0usize,
1046 concat!(
1047 "Offset of field: ",
1048 stringify!(pthread_condattr_t),
1049 "::",
1050 stringify!(__align)
1051 )
1052 );
1053}
1054pub type pthread_key_t = ::std::os::raw::c_uint;
1055pub type pthread_once_t = ::std::os::raw::c_int;
1056#[repr(C)]
1057#[derive(Copy, Clone)]
1058pub union pthread_attr_t {
1059 pub __size: [::std::os::raw::c_char; 56usize],
1060 pub __align: ::std::os::raw::c_long,
1061}
1062#[test]
1063fn bindgen_test_layout_pthread_attr_t() {
1064 const UNINIT: ::std::mem::MaybeUninit<pthread_attr_t> = ::std::mem::MaybeUninit::uninit();
1065 let ptr = UNINIT.as_ptr();
1066 assert_eq!(
1067 ::std::mem::size_of::<pthread_attr_t>(),
1068 56usize,
1069 concat!("Size of: ", stringify!(pthread_attr_t))
1070 );
1071 assert_eq!(
1072 ::std::mem::align_of::<pthread_attr_t>(),
1073 8usize,
1074 concat!("Alignment of ", stringify!(pthread_attr_t))
1075 );
1076 assert_eq!(
1077 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1078 0usize,
1079 concat!(
1080 "Offset of field: ",
1081 stringify!(pthread_attr_t),
1082 "::",
1083 stringify!(__size)
1084 )
1085 );
1086 assert_eq!(
1087 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1088 0usize,
1089 concat!(
1090 "Offset of field: ",
1091 stringify!(pthread_attr_t),
1092 "::",
1093 stringify!(__align)
1094 )
1095 );
1096}
1097#[repr(C)]
1098#[derive(Copy, Clone)]
1099pub union pthread_mutex_t {
1100 pub __data: __pthread_mutex_s,
1101 pub __size: [::std::os::raw::c_char; 40usize],
1102 pub __align: ::std::os::raw::c_long,
1103}
1104#[test]
1105fn bindgen_test_layout_pthread_mutex_t() {
1106 const UNINIT: ::std::mem::MaybeUninit<pthread_mutex_t> = ::std::mem::MaybeUninit::uninit();
1107 let ptr = UNINIT.as_ptr();
1108 assert_eq!(
1109 ::std::mem::size_of::<pthread_mutex_t>(),
1110 40usize,
1111 concat!("Size of: ", stringify!(pthread_mutex_t))
1112 );
1113 assert_eq!(
1114 ::std::mem::align_of::<pthread_mutex_t>(),
1115 8usize,
1116 concat!("Alignment of ", stringify!(pthread_mutex_t))
1117 );
1118 assert_eq!(
1119 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
1120 0usize,
1121 concat!(
1122 "Offset of field: ",
1123 stringify!(pthread_mutex_t),
1124 "::",
1125 stringify!(__data)
1126 )
1127 );
1128 assert_eq!(
1129 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1130 0usize,
1131 concat!(
1132 "Offset of field: ",
1133 stringify!(pthread_mutex_t),
1134 "::",
1135 stringify!(__size)
1136 )
1137 );
1138 assert_eq!(
1139 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1140 0usize,
1141 concat!(
1142 "Offset of field: ",
1143 stringify!(pthread_mutex_t),
1144 "::",
1145 stringify!(__align)
1146 )
1147 );
1148}
1149#[repr(C)]
1150#[derive(Copy, Clone)]
1151pub union pthread_cond_t {
1152 pub __data: __pthread_cond_s,
1153 pub __size: [::std::os::raw::c_char; 48usize],
1154 pub __align: ::std::os::raw::c_longlong,
1155}
1156#[test]
1157fn bindgen_test_layout_pthread_cond_t() {
1158 const UNINIT: ::std::mem::MaybeUninit<pthread_cond_t> = ::std::mem::MaybeUninit::uninit();
1159 let ptr = UNINIT.as_ptr();
1160 assert_eq!(
1161 ::std::mem::size_of::<pthread_cond_t>(),
1162 48usize,
1163 concat!("Size of: ", stringify!(pthread_cond_t))
1164 );
1165 assert_eq!(
1166 ::std::mem::align_of::<pthread_cond_t>(),
1167 8usize,
1168 concat!("Alignment of ", stringify!(pthread_cond_t))
1169 );
1170 assert_eq!(
1171 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
1172 0usize,
1173 concat!(
1174 "Offset of field: ",
1175 stringify!(pthread_cond_t),
1176 "::",
1177 stringify!(__data)
1178 )
1179 );
1180 assert_eq!(
1181 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1182 0usize,
1183 concat!(
1184 "Offset of field: ",
1185 stringify!(pthread_cond_t),
1186 "::",
1187 stringify!(__size)
1188 )
1189 );
1190 assert_eq!(
1191 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1192 0usize,
1193 concat!(
1194 "Offset of field: ",
1195 stringify!(pthread_cond_t),
1196 "::",
1197 stringify!(__align)
1198 )
1199 );
1200}
1201#[repr(C)]
1202#[derive(Copy, Clone)]
1203pub union pthread_rwlock_t {
1204 pub __data: __pthread_rwlock_arch_t,
1205 pub __size: [::std::os::raw::c_char; 56usize],
1206 pub __align: ::std::os::raw::c_long,
1207}
1208#[test]
1209fn bindgen_test_layout_pthread_rwlock_t() {
1210 const UNINIT: ::std::mem::MaybeUninit<pthread_rwlock_t> = ::std::mem::MaybeUninit::uninit();
1211 let ptr = UNINIT.as_ptr();
1212 assert_eq!(
1213 ::std::mem::size_of::<pthread_rwlock_t>(),
1214 56usize,
1215 concat!("Size of: ", stringify!(pthread_rwlock_t))
1216 );
1217 assert_eq!(
1218 ::std::mem::align_of::<pthread_rwlock_t>(),
1219 8usize,
1220 concat!("Alignment of ", stringify!(pthread_rwlock_t))
1221 );
1222 assert_eq!(
1223 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
1224 0usize,
1225 concat!(
1226 "Offset of field: ",
1227 stringify!(pthread_rwlock_t),
1228 "::",
1229 stringify!(__data)
1230 )
1231 );
1232 assert_eq!(
1233 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1234 0usize,
1235 concat!(
1236 "Offset of field: ",
1237 stringify!(pthread_rwlock_t),
1238 "::",
1239 stringify!(__size)
1240 )
1241 );
1242 assert_eq!(
1243 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1244 0usize,
1245 concat!(
1246 "Offset of field: ",
1247 stringify!(pthread_rwlock_t),
1248 "::",
1249 stringify!(__align)
1250 )
1251 );
1252}
1253#[repr(C)]
1254#[derive(Copy, Clone)]
1255pub union pthread_rwlockattr_t {
1256 pub __size: [::std::os::raw::c_char; 8usize],
1257 pub __align: ::std::os::raw::c_long,
1258}
1259#[test]
1260fn bindgen_test_layout_pthread_rwlockattr_t() {
1261 const UNINIT: ::std::mem::MaybeUninit<pthread_rwlockattr_t> = ::std::mem::MaybeUninit::uninit();
1262 let ptr = UNINIT.as_ptr();
1263 assert_eq!(
1264 ::std::mem::size_of::<pthread_rwlockattr_t>(),
1265 8usize,
1266 concat!("Size of: ", stringify!(pthread_rwlockattr_t))
1267 );
1268 assert_eq!(
1269 ::std::mem::align_of::<pthread_rwlockattr_t>(),
1270 8usize,
1271 concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
1272 );
1273 assert_eq!(
1274 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1275 0usize,
1276 concat!(
1277 "Offset of field: ",
1278 stringify!(pthread_rwlockattr_t),
1279 "::",
1280 stringify!(__size)
1281 )
1282 );
1283 assert_eq!(
1284 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1285 0usize,
1286 concat!(
1287 "Offset of field: ",
1288 stringify!(pthread_rwlockattr_t),
1289 "::",
1290 stringify!(__align)
1291 )
1292 );
1293}
1294pub type pthread_spinlock_t = ::std::os::raw::c_int;
1295#[repr(C)]
1296#[derive(Copy, Clone)]
1297pub union pthread_barrier_t {
1298 pub __size: [::std::os::raw::c_char; 32usize],
1299 pub __align: ::std::os::raw::c_long,
1300}
1301#[test]
1302fn bindgen_test_layout_pthread_barrier_t() {
1303 const UNINIT: ::std::mem::MaybeUninit<pthread_barrier_t> = ::std::mem::MaybeUninit::uninit();
1304 let ptr = UNINIT.as_ptr();
1305 assert_eq!(
1306 ::std::mem::size_of::<pthread_barrier_t>(),
1307 32usize,
1308 concat!("Size of: ", stringify!(pthread_barrier_t))
1309 );
1310 assert_eq!(
1311 ::std::mem::align_of::<pthread_barrier_t>(),
1312 8usize,
1313 concat!("Alignment of ", stringify!(pthread_barrier_t))
1314 );
1315 assert_eq!(
1316 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1317 0usize,
1318 concat!(
1319 "Offset of field: ",
1320 stringify!(pthread_barrier_t),
1321 "::",
1322 stringify!(__size)
1323 )
1324 );
1325 assert_eq!(
1326 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1327 0usize,
1328 concat!(
1329 "Offset of field: ",
1330 stringify!(pthread_barrier_t),
1331 "::",
1332 stringify!(__align)
1333 )
1334 );
1335}
1336#[repr(C)]
1337#[derive(Copy, Clone)]
1338pub union pthread_barrierattr_t {
1339 pub __size: [::std::os::raw::c_char; 4usize],
1340 pub __align: ::std::os::raw::c_int,
1341}
1342#[test]
1343fn bindgen_test_layout_pthread_barrierattr_t() {
1344 const UNINIT: ::std::mem::MaybeUninit<pthread_barrierattr_t> =
1345 ::std::mem::MaybeUninit::uninit();
1346 let ptr = UNINIT.as_ptr();
1347 assert_eq!(
1348 ::std::mem::size_of::<pthread_barrierattr_t>(),
1349 4usize,
1350 concat!("Size of: ", stringify!(pthread_barrierattr_t))
1351 );
1352 assert_eq!(
1353 ::std::mem::align_of::<pthread_barrierattr_t>(),
1354 4usize,
1355 concat!("Alignment of ", stringify!(pthread_barrierattr_t))
1356 );
1357 assert_eq!(
1358 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
1359 0usize,
1360 concat!(
1361 "Offset of field: ",
1362 stringify!(pthread_barrierattr_t),
1363 "::",
1364 stringify!(__size)
1365 )
1366 );
1367 assert_eq!(
1368 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
1369 0usize,
1370 concat!(
1371 "Offset of field: ",
1372 stringify!(pthread_barrierattr_t),
1373 "::",
1374 stringify!(__align)
1375 )
1376 );
1377}
1378#[repr(C)]
1379#[derive(Debug, Copy, Clone)]
1380pub struct munge_ctx {
1381 _unused: [u8; 0],
1382}
1383pub type munge_ctx_t = *mut munge_ctx;
1384pub const munge_opt_MUNGE_OPT_CIPHER_TYPE: munge_opt = 0;
1385pub const munge_opt_MUNGE_OPT_MAC_TYPE: munge_opt = 1;
1386pub const munge_opt_MUNGE_OPT_ZIP_TYPE: munge_opt = 2;
1387pub const munge_opt_MUNGE_OPT_REALM: munge_opt = 3;
1388pub const munge_opt_MUNGE_OPT_TTL: munge_opt = 4;
1389pub const munge_opt_MUNGE_OPT_ADDR4: munge_opt = 5;
1390pub const munge_opt_MUNGE_OPT_ENCODE_TIME: munge_opt = 6;
1391pub const munge_opt_MUNGE_OPT_DECODE_TIME: munge_opt = 7;
1392pub const munge_opt_MUNGE_OPT_SOCKET: munge_opt = 8;
1393pub const munge_opt_MUNGE_OPT_UID_RESTRICTION: munge_opt = 9;
1394pub const munge_opt_MUNGE_OPT_GID_RESTRICTION: munge_opt = 10;
1395pub type munge_opt = ::std::os::raw::c_uint;
1396pub use self::munge_opt as munge_opt_t;
1397pub const munge_cipher_MUNGE_CIPHER_NONE: munge_cipher = 0;
1398pub const munge_cipher_MUNGE_CIPHER_DEFAULT: munge_cipher = 1;
1399pub const munge_cipher_MUNGE_CIPHER_BLOWFISH: munge_cipher = 2;
1400pub const munge_cipher_MUNGE_CIPHER_CAST5: munge_cipher = 3;
1401pub const munge_cipher_MUNGE_CIPHER_AES128: munge_cipher = 4;
1402pub const munge_cipher_MUNGE_CIPHER_AES256: munge_cipher = 5;
1403pub const munge_cipher_MUNGE_CIPHER_LAST_ITEM: munge_cipher = 6;
1404pub type munge_cipher = ::std::os::raw::c_uint;
1405pub use self::munge_cipher as munge_cipher_t;
1406pub const munge_mac_MUNGE_MAC_NONE: munge_mac = 0;
1407pub const munge_mac_MUNGE_MAC_DEFAULT: munge_mac = 1;
1408pub const munge_mac_MUNGE_MAC_MD5: munge_mac = 2;
1409pub const munge_mac_MUNGE_MAC_SHA1: munge_mac = 3;
1410pub const munge_mac_MUNGE_MAC_RIPEMD160: munge_mac = 4;
1411pub const munge_mac_MUNGE_MAC_SHA256: munge_mac = 5;
1412pub const munge_mac_MUNGE_MAC_SHA512: munge_mac = 6;
1413pub const munge_mac_MUNGE_MAC_LAST_ITEM: munge_mac = 7;
1414pub type munge_mac = ::std::os::raw::c_uint;
1415pub use self::munge_mac as munge_mac_t;
1416pub const munge_zip_MUNGE_ZIP_NONE: munge_zip = 0;
1417pub const munge_zip_MUNGE_ZIP_DEFAULT: munge_zip = 1;
1418pub const munge_zip_MUNGE_ZIP_BZLIB: munge_zip = 2;
1419pub const munge_zip_MUNGE_ZIP_ZLIB: munge_zip = 3;
1420pub const munge_zip_MUNGE_ZIP_LAST_ITEM: munge_zip = 4;
1421pub type munge_zip = ::std::os::raw::c_uint;
1422pub use self::munge_zip as munge_zip_t;
1423pub const munge_ttl_MUNGE_TTL_MAXIMUM: munge_ttl = -1;
1424pub const munge_ttl_MUNGE_TTL_DEFAULT: munge_ttl = 0;
1425pub type munge_ttl = ::std::os::raw::c_int;
1426pub use self::munge_ttl as munge_ttl_t;
1427pub const munge_uid_MUNGE_UID_ANY: munge_uid = -1;
1428pub type munge_uid = ::std::os::raw::c_int;
1429pub use self::munge_uid as munge_uid_t;
1430pub const munge_gid_MUNGE_GID_ANY: munge_gid = -1;
1431pub type munge_gid = ::std::os::raw::c_int;
1432pub use self::munge_gid as munge_gid_t;
1433pub const munge_enum_MUNGE_ENUM_CIPHER: munge_enum = 0;
1434pub const munge_enum_MUNGE_ENUM_MAC: munge_enum = 1;
1435pub const munge_enum_MUNGE_ENUM_ZIP: munge_enum = 2;
1436pub type munge_enum = ::std::os::raw::c_uint;
1437pub use self::munge_enum as munge_enum_t;
1438pub const munge_err_EMUNGE_SUCCESS: munge_err = 0;
1439pub const munge_err_EMUNGE_SNAFU: munge_err = 1;
1440pub const munge_err_EMUNGE_BAD_ARG: munge_err = 2;
1441pub const munge_err_EMUNGE_BAD_LENGTH: munge_err = 3;
1442pub const munge_err_EMUNGE_OVERFLOW: munge_err = 4;
1443pub const munge_err_EMUNGE_NO_MEMORY: munge_err = 5;
1444pub const munge_err_EMUNGE_SOCKET: munge_err = 6;
1445pub const munge_err_EMUNGE_TIMEOUT: munge_err = 7;
1446pub const munge_err_EMUNGE_BAD_CRED: munge_err = 8;
1447pub const munge_err_EMUNGE_BAD_VERSION: munge_err = 9;
1448pub const munge_err_EMUNGE_BAD_CIPHER: munge_err = 10;
1449pub const munge_err_EMUNGE_BAD_MAC: munge_err = 11;
1450pub const munge_err_EMUNGE_BAD_ZIP: munge_err = 12;
1451pub const munge_err_EMUNGE_BAD_REALM: munge_err = 13;
1452pub const munge_err_EMUNGE_CRED_INVALID: munge_err = 14;
1453pub const munge_err_EMUNGE_CRED_EXPIRED: munge_err = 15;
1454pub const munge_err_EMUNGE_CRED_REWOUND: munge_err = 16;
1455pub const munge_err_EMUNGE_CRED_REPLAYED: munge_err = 17;
1456pub const munge_err_EMUNGE_CRED_UNAUTHORIZED: munge_err = 18;
1457pub type munge_err = ::std::os::raw::c_uint;
1458pub use self::munge_err as munge_err_t;
1459extern "C" {
1460 pub fn munge_encode(
1461 cred: *mut *mut ::std::os::raw::c_char,
1462 ctx: munge_ctx_t,
1463 buf: *const ::std::os::raw::c_void,
1464 len: ::std::os::raw::c_int,
1465 ) -> munge_err_t;
1466}
1467extern "C" {
1468 pub fn munge_decode(
1469 cred: *const ::std::os::raw::c_char,
1470 ctx: munge_ctx_t,
1471 buf: *mut *mut ::std::os::raw::c_void,
1472 len: *mut ::std::os::raw::c_int,
1473 uid: *mut uid_t,
1474 gid: *mut gid_t,
1475 ) -> munge_err_t;
1476}
1477extern "C" {
1478 pub fn munge_strerror(e: munge_err_t) -> *const ::std::os::raw::c_char;
1479}
1480extern "C" {
1481 pub fn munge_ctx_create() -> munge_ctx_t;
1482}
1483extern "C" {
1484 pub fn munge_ctx_copy(ctx: munge_ctx_t) -> munge_ctx_t;
1485}
1486extern "C" {
1487 pub fn munge_ctx_destroy(ctx: munge_ctx_t);
1488}
1489extern "C" {
1490 pub fn munge_ctx_strerror(ctx: munge_ctx_t) -> *const ::std::os::raw::c_char;
1491}
1492extern "C" {
1493 pub fn munge_ctx_get(ctx: munge_ctx_t, opt: ::std::os::raw::c_int, ...) -> munge_err_t;
1494}
1495extern "C" {
1496 pub fn munge_ctx_set(ctx: munge_ctx_t, opt: ::std::os::raw::c_int, ...) -> munge_err_t;
1497}
1498extern "C" {
1499 pub fn munge_enum_is_valid(
1500 type_: munge_enum_t,
1501 val: ::std::os::raw::c_int,
1502 ) -> ::std::os::raw::c_int;
1503}
1504extern "C" {
1505 pub fn munge_enum_int_to_str(
1506 type_: munge_enum_t,
1507 val: ::std::os::raw::c_int,
1508 ) -> *const ::std::os::raw::c_char;
1509}
1510extern "C" {
1511 pub fn munge_enum_str_to_int(
1512 type_: munge_enum_t,
1513 str_: *const ::std::os::raw::c_char,
1514 ) -> ::std::os::raw::c_int;
1515}