1pub const __WORDSIZE: u32 = 64;
4pub const __DARWIN_ONLY_64_BIT_INO_T: u32 = 1;
5pub const __DARWIN_ONLY_UNIX_CONFORMANCE: u32 = 1;
6pub const __DARWIN_ONLY_VERS_1050: u32 = 1;
7pub const __DARWIN_UNIX03: u32 = 1;
8pub const __DARWIN_64_BIT_INO_T: u32 = 1;
9pub const __DARWIN_VERS_1050: u32 = 1;
10pub const __DARWIN_NON_CANCELABLE: u32 = 0;
11pub const __DARWIN_SUF_EXTSN: &'static [u8; 14usize] = b"$DARWIN_EXTSN\0";
12pub const __DARWIN_C_ANSI: u32 = 4096;
13pub const __DARWIN_C_FULL: u32 = 900000;
14pub const __DARWIN_C_LEVEL: u32 = 900000;
15pub const __STDC_WANT_LIB_EXT1__: u32 = 1;
16pub const __DARWIN_NO_LONG_LONG: u32 = 0;
17pub const _DARWIN_FEATURE_64_BIT_INODE: u32 = 1;
18pub const _DARWIN_FEATURE_ONLY_64_BIT_INODE: u32 = 1;
19pub const _DARWIN_FEATURE_ONLY_VERS_1050: u32 = 1;
20pub const _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE: u32 = 1;
21pub const _DARWIN_FEATURE_UNIX_CONFORMANCE: u32 = 3;
22pub const __PTHREAD_SIZE__: u32 = 8176;
23pub const __PTHREAD_ATTR_SIZE__: u32 = 56;
24pub const __PTHREAD_MUTEXATTR_SIZE__: u32 = 8;
25pub const __PTHREAD_MUTEX_SIZE__: u32 = 56;
26pub const __PTHREAD_CONDATTR_SIZE__: u32 = 8;
27pub const __PTHREAD_COND_SIZE__: u32 = 40;
28pub const __PTHREAD_ONCE_SIZE__: u32 = 8;
29pub const __PTHREAD_RWLOCK_SIZE__: u32 = 192;
30pub const __PTHREAD_RWLOCKATTR_SIZE__: u32 = 16;
31pub const INT8_MAX: u32 = 127;
32pub const INT16_MAX: u32 = 32767;
33pub const INT32_MAX: u32 = 2147483647;
34pub const INT64_MAX: u64 = 9223372036854775807;
35pub const INT8_MIN: i32 = -128;
36pub const INT16_MIN: i32 = -32768;
37pub const INT32_MIN: i32 = -2147483648;
38pub const INT64_MIN: i64 = -9223372036854775808;
39pub const UINT8_MAX: u32 = 255;
40pub const UINT16_MAX: u32 = 65535;
41pub const UINT32_MAX: u32 = 4294967295;
42pub const UINT64_MAX: i32 = -1;
43pub const INT_LEAST8_MIN: i32 = -128;
44pub const INT_LEAST16_MIN: i32 = -32768;
45pub const INT_LEAST32_MIN: i32 = -2147483648;
46pub const INT_LEAST64_MIN: i64 = -9223372036854775808;
47pub const INT_LEAST8_MAX: u32 = 127;
48pub const INT_LEAST16_MAX: u32 = 32767;
49pub const INT_LEAST32_MAX: u32 = 2147483647;
50pub const INT_LEAST64_MAX: u64 = 9223372036854775807;
51pub const UINT_LEAST8_MAX: u32 = 255;
52pub const UINT_LEAST16_MAX: u32 = 65535;
53pub const UINT_LEAST32_MAX: u32 = 4294967295;
54pub const UINT_LEAST64_MAX: i32 = -1;
55pub const INT_FAST8_MIN: i32 = -128;
56pub const INT_FAST16_MIN: i32 = -32768;
57pub const INT_FAST32_MIN: i32 = -2147483648;
58pub const INT_FAST64_MIN: i64 = -9223372036854775808;
59pub const INT_FAST8_MAX: u32 = 127;
60pub const INT_FAST16_MAX: u32 = 32767;
61pub const INT_FAST32_MAX: u32 = 2147483647;
62pub const INT_FAST64_MAX: u64 = 9223372036854775807;
63pub const UINT_FAST8_MAX: u32 = 255;
64pub const UINT_FAST16_MAX: u32 = 65535;
65pub const UINT_FAST32_MAX: u32 = 4294967295;
66pub const UINT_FAST64_MAX: i32 = -1;
67pub const INTPTR_MAX: u64 = 9223372036854775807;
68pub const INTPTR_MIN: i64 = -9223372036854775808;
69pub const UINTPTR_MAX: i32 = -1;
70pub const SIZE_MAX: i32 = -1;
71pub const RSIZE_MAX: i32 = -1;
72pub const WINT_MIN: i32 = -2147483648;
73pub const WINT_MAX: u32 = 2147483647;
74pub const SIG_ATOMIC_MIN: i32 = -2147483648;
75pub const SIG_ATOMIC_MAX: u32 = 2147483647;
76pub const PG_VERSION: &'static [u8; 5usize] = b"13.3\0";
77pub const PG_MAJORVERSION: &'static [u8; 3usize] = b"13\0";
78pub const PG_VERSION_NUM: u32 = 130003;
79pub type int_least8_t = i8;
80pub type int_least16_t = i16;
81pub type int_least32_t = i32;
82pub type int_least64_t = i64;
83pub type uint_least8_t = u8;
84pub type uint_least16_t = u16;
85pub type uint_least32_t = u32;
86pub type uint_least64_t = u64;
87pub type int_fast8_t = i8;
88pub type int_fast16_t = i16;
89pub type int_fast32_t = i32;
90pub type int_fast64_t = i64;
91pub type uint_fast8_t = u8;
92pub type uint_fast16_t = u16;
93pub type uint_fast32_t = u32;
94pub type uint_fast64_t = u64;
95pub type __int8_t = ::std::os::raw::c_schar;
96pub type __uint8_t = ::std::os::raw::c_uchar;
97pub type __int16_t = ::std::os::raw::c_short;
98pub type __uint16_t = ::std::os::raw::c_ushort;
99pub type __int32_t = ::std::os::raw::c_int;
100pub type __uint32_t = ::std::os::raw::c_uint;
101pub type __int64_t = ::std::os::raw::c_longlong;
102pub type __uint64_t = ::std::os::raw::c_ulonglong;
103pub type __darwin_intptr_t = ::std::os::raw::c_long;
104pub type __darwin_natural_t = ::std::os::raw::c_uint;
105pub type __darwin_ct_rune_t = ::std::os::raw::c_int;
106#[repr(C)]
107#[derive(Copy, Clone)]
108pub union __mbstate_t {
109 pub __mbstate8: [::std::os::raw::c_char; 128usize],
110 pub _mbstateL: ::std::os::raw::c_longlong,
111}
112#[test]
113fn bindgen_test_layout___mbstate_t() {
114 assert_eq!(
115 ::std::mem::size_of::<__mbstate_t>(),
116 128usize,
117 concat!("Size of: ", stringify!(__mbstate_t))
118 );
119 assert_eq!(
120 ::std::mem::align_of::<__mbstate_t>(),
121 8usize,
122 concat!("Alignment of ", stringify!(__mbstate_t))
123 );
124 assert_eq!(
125 unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__mbstate8 as *const _ as usize },
126 0usize,
127 concat!(
128 "Offset of field: ",
129 stringify!(__mbstate_t),
130 "::",
131 stringify!(__mbstate8)
132 )
133 );
134 assert_eq!(
135 unsafe { &(*(::std::ptr::null::<__mbstate_t>()))._mbstateL as *const _ as usize },
136 0usize,
137 concat!(
138 "Offset of field: ",
139 stringify!(__mbstate_t),
140 "::",
141 stringify!(_mbstateL)
142 )
143 );
144}
145pub type __darwin_mbstate_t = __mbstate_t;
146pub type __darwin_ptrdiff_t = ::std::os::raw::c_long;
147pub type __darwin_size_t = ::std::os::raw::c_ulong;
148pub type __darwin_va_list = __builtin_va_list;
149pub type __darwin_wchar_t = ::std::os::raw::c_int;
150pub type __darwin_rune_t = __darwin_wchar_t;
151pub type __darwin_wint_t = ::std::os::raw::c_int;
152pub type __darwin_clock_t = ::std::os::raw::c_ulong;
153pub type __darwin_socklen_t = __uint32_t;
154pub type __darwin_ssize_t = ::std::os::raw::c_long;
155pub type __darwin_time_t = ::std::os::raw::c_long;
156pub type __darwin_blkcnt_t = __int64_t;
157pub type __darwin_blksize_t = __int32_t;
158pub type __darwin_dev_t = __int32_t;
159pub type __darwin_fsblkcnt_t = ::std::os::raw::c_uint;
160pub type __darwin_fsfilcnt_t = ::std::os::raw::c_uint;
161pub type __darwin_gid_t = __uint32_t;
162pub type __darwin_id_t = __uint32_t;
163pub type __darwin_ino64_t = __uint64_t;
164pub type __darwin_ino_t = __darwin_ino64_t;
165pub type __darwin_mach_port_name_t = __darwin_natural_t;
166pub type __darwin_mach_port_t = __darwin_mach_port_name_t;
167pub type __darwin_mode_t = __uint16_t;
168pub type __darwin_off_t = __int64_t;
169pub type __darwin_pid_t = __int32_t;
170pub type __darwin_sigset_t = __uint32_t;
171pub type __darwin_suseconds_t = __int32_t;
172pub type __darwin_uid_t = __uint32_t;
173pub type __darwin_useconds_t = __uint32_t;
174pub type __darwin_uuid_t = [::std::os::raw::c_uchar; 16usize];
175pub type __darwin_uuid_string_t = [::std::os::raw::c_char; 37usize];
176#[repr(C)]
177#[derive(Debug, Copy, Clone)]
178pub struct __darwin_pthread_handler_rec {
179 pub __routine: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
180 pub __arg: *mut ::std::os::raw::c_void,
181 pub __next: *mut __darwin_pthread_handler_rec,
182}
183#[test]
184fn bindgen_test_layout___darwin_pthread_handler_rec() {
185 assert_eq!(
186 ::std::mem::size_of::<__darwin_pthread_handler_rec>(),
187 24usize,
188 concat!("Size of: ", stringify!(__darwin_pthread_handler_rec))
189 );
190 assert_eq!(
191 ::std::mem::align_of::<__darwin_pthread_handler_rec>(),
192 8usize,
193 concat!("Alignment of ", stringify!(__darwin_pthread_handler_rec))
194 );
195 assert_eq!(
196 unsafe {
197 &(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__routine as *const _ as usize
198 },
199 0usize,
200 concat!(
201 "Offset of field: ",
202 stringify!(__darwin_pthread_handler_rec),
203 "::",
204 stringify!(__routine)
205 )
206 );
207 assert_eq!(
208 unsafe {
209 &(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__arg as *const _ as usize
210 },
211 8usize,
212 concat!(
213 "Offset of field: ",
214 stringify!(__darwin_pthread_handler_rec),
215 "::",
216 stringify!(__arg)
217 )
218 );
219 assert_eq!(
220 unsafe {
221 &(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__next as *const _ as usize
222 },
223 16usize,
224 concat!(
225 "Offset of field: ",
226 stringify!(__darwin_pthread_handler_rec),
227 "::",
228 stringify!(__next)
229 )
230 );
231}
232#[repr(C)]
233#[derive(Copy, Clone)]
234pub struct _opaque_pthread_attr_t {
235 pub __sig: ::std::os::raw::c_long,
236 pub __opaque: [::std::os::raw::c_char; 56usize],
237}
238#[test]
239fn bindgen_test_layout__opaque_pthread_attr_t() {
240 assert_eq!(
241 ::std::mem::size_of::<_opaque_pthread_attr_t>(),
242 64usize,
243 concat!("Size of: ", stringify!(_opaque_pthread_attr_t))
244 );
245 assert_eq!(
246 ::std::mem::align_of::<_opaque_pthread_attr_t>(),
247 8usize,
248 concat!("Alignment of ", stringify!(_opaque_pthread_attr_t))
249 );
250 assert_eq!(
251 unsafe { &(*(::std::ptr::null::<_opaque_pthread_attr_t>())).__sig as *const _ as usize },
252 0usize,
253 concat!(
254 "Offset of field: ",
255 stringify!(_opaque_pthread_attr_t),
256 "::",
257 stringify!(__sig)
258 )
259 );
260 assert_eq!(
261 unsafe { &(*(::std::ptr::null::<_opaque_pthread_attr_t>())).__opaque as *const _ as usize },
262 8usize,
263 concat!(
264 "Offset of field: ",
265 stringify!(_opaque_pthread_attr_t),
266 "::",
267 stringify!(__opaque)
268 )
269 );
270}
271#[repr(C)]
272#[derive(Copy, Clone)]
273pub struct _opaque_pthread_cond_t {
274 pub __sig: ::std::os::raw::c_long,
275 pub __opaque: [::std::os::raw::c_char; 40usize],
276}
277#[test]
278fn bindgen_test_layout__opaque_pthread_cond_t() {
279 assert_eq!(
280 ::std::mem::size_of::<_opaque_pthread_cond_t>(),
281 48usize,
282 concat!("Size of: ", stringify!(_opaque_pthread_cond_t))
283 );
284 assert_eq!(
285 ::std::mem::align_of::<_opaque_pthread_cond_t>(),
286 8usize,
287 concat!("Alignment of ", stringify!(_opaque_pthread_cond_t))
288 );
289 assert_eq!(
290 unsafe { &(*(::std::ptr::null::<_opaque_pthread_cond_t>())).__sig as *const _ as usize },
291 0usize,
292 concat!(
293 "Offset of field: ",
294 stringify!(_opaque_pthread_cond_t),
295 "::",
296 stringify!(__sig)
297 )
298 );
299 assert_eq!(
300 unsafe { &(*(::std::ptr::null::<_opaque_pthread_cond_t>())).__opaque as *const _ as usize },
301 8usize,
302 concat!(
303 "Offset of field: ",
304 stringify!(_opaque_pthread_cond_t),
305 "::",
306 stringify!(__opaque)
307 )
308 );
309}
310#[repr(C)]
311#[derive(Debug, Copy, Clone)]
312pub struct _opaque_pthread_condattr_t {
313 pub __sig: ::std::os::raw::c_long,
314 pub __opaque: [::std::os::raw::c_char; 8usize],
315}
316#[test]
317fn bindgen_test_layout__opaque_pthread_condattr_t() {
318 assert_eq!(
319 ::std::mem::size_of::<_opaque_pthread_condattr_t>(),
320 16usize,
321 concat!("Size of: ", stringify!(_opaque_pthread_condattr_t))
322 );
323 assert_eq!(
324 ::std::mem::align_of::<_opaque_pthread_condattr_t>(),
325 8usize,
326 concat!("Alignment of ", stringify!(_opaque_pthread_condattr_t))
327 );
328 assert_eq!(
329 unsafe {
330 &(*(::std::ptr::null::<_opaque_pthread_condattr_t>())).__sig as *const _ as usize
331 },
332 0usize,
333 concat!(
334 "Offset of field: ",
335 stringify!(_opaque_pthread_condattr_t),
336 "::",
337 stringify!(__sig)
338 )
339 );
340 assert_eq!(
341 unsafe {
342 &(*(::std::ptr::null::<_opaque_pthread_condattr_t>())).__opaque as *const _ as usize
343 },
344 8usize,
345 concat!(
346 "Offset of field: ",
347 stringify!(_opaque_pthread_condattr_t),
348 "::",
349 stringify!(__opaque)
350 )
351 );
352}
353#[repr(C)]
354#[derive(Copy, Clone)]
355pub struct _opaque_pthread_mutex_t {
356 pub __sig: ::std::os::raw::c_long,
357 pub __opaque: [::std::os::raw::c_char; 56usize],
358}
359#[test]
360fn bindgen_test_layout__opaque_pthread_mutex_t() {
361 assert_eq!(
362 ::std::mem::size_of::<_opaque_pthread_mutex_t>(),
363 64usize,
364 concat!("Size of: ", stringify!(_opaque_pthread_mutex_t))
365 );
366 assert_eq!(
367 ::std::mem::align_of::<_opaque_pthread_mutex_t>(),
368 8usize,
369 concat!("Alignment of ", stringify!(_opaque_pthread_mutex_t))
370 );
371 assert_eq!(
372 unsafe { &(*(::std::ptr::null::<_opaque_pthread_mutex_t>())).__sig as *const _ as usize },
373 0usize,
374 concat!(
375 "Offset of field: ",
376 stringify!(_opaque_pthread_mutex_t),
377 "::",
378 stringify!(__sig)
379 )
380 );
381 assert_eq!(
382 unsafe {
383 &(*(::std::ptr::null::<_opaque_pthread_mutex_t>())).__opaque as *const _ as usize
384 },
385 8usize,
386 concat!(
387 "Offset of field: ",
388 stringify!(_opaque_pthread_mutex_t),
389 "::",
390 stringify!(__opaque)
391 )
392 );
393}
394#[repr(C)]
395#[derive(Debug, Copy, Clone)]
396pub struct _opaque_pthread_mutexattr_t {
397 pub __sig: ::std::os::raw::c_long,
398 pub __opaque: [::std::os::raw::c_char; 8usize],
399}
400#[test]
401fn bindgen_test_layout__opaque_pthread_mutexattr_t() {
402 assert_eq!(
403 ::std::mem::size_of::<_opaque_pthread_mutexattr_t>(),
404 16usize,
405 concat!("Size of: ", stringify!(_opaque_pthread_mutexattr_t))
406 );
407 assert_eq!(
408 ::std::mem::align_of::<_opaque_pthread_mutexattr_t>(),
409 8usize,
410 concat!("Alignment of ", stringify!(_opaque_pthread_mutexattr_t))
411 );
412 assert_eq!(
413 unsafe {
414 &(*(::std::ptr::null::<_opaque_pthread_mutexattr_t>())).__sig as *const _ as usize
415 },
416 0usize,
417 concat!(
418 "Offset of field: ",
419 stringify!(_opaque_pthread_mutexattr_t),
420 "::",
421 stringify!(__sig)
422 )
423 );
424 assert_eq!(
425 unsafe {
426 &(*(::std::ptr::null::<_opaque_pthread_mutexattr_t>())).__opaque as *const _ as usize
427 },
428 8usize,
429 concat!(
430 "Offset of field: ",
431 stringify!(_opaque_pthread_mutexattr_t),
432 "::",
433 stringify!(__opaque)
434 )
435 );
436}
437#[repr(C)]
438#[derive(Debug, Copy, Clone)]
439pub struct _opaque_pthread_once_t {
440 pub __sig: ::std::os::raw::c_long,
441 pub __opaque: [::std::os::raw::c_char; 8usize],
442}
443#[test]
444fn bindgen_test_layout__opaque_pthread_once_t() {
445 assert_eq!(
446 ::std::mem::size_of::<_opaque_pthread_once_t>(),
447 16usize,
448 concat!("Size of: ", stringify!(_opaque_pthread_once_t))
449 );
450 assert_eq!(
451 ::std::mem::align_of::<_opaque_pthread_once_t>(),
452 8usize,
453 concat!("Alignment of ", stringify!(_opaque_pthread_once_t))
454 );
455 assert_eq!(
456 unsafe { &(*(::std::ptr::null::<_opaque_pthread_once_t>())).__sig as *const _ as usize },
457 0usize,
458 concat!(
459 "Offset of field: ",
460 stringify!(_opaque_pthread_once_t),
461 "::",
462 stringify!(__sig)
463 )
464 );
465 assert_eq!(
466 unsafe { &(*(::std::ptr::null::<_opaque_pthread_once_t>())).__opaque as *const _ as usize },
467 8usize,
468 concat!(
469 "Offset of field: ",
470 stringify!(_opaque_pthread_once_t),
471 "::",
472 stringify!(__opaque)
473 )
474 );
475}
476#[repr(C)]
477#[derive(Copy, Clone)]
478pub struct _opaque_pthread_rwlock_t {
479 pub __sig: ::std::os::raw::c_long,
480 pub __opaque: [::std::os::raw::c_char; 192usize],
481}
482#[test]
483fn bindgen_test_layout__opaque_pthread_rwlock_t() {
484 assert_eq!(
485 ::std::mem::size_of::<_opaque_pthread_rwlock_t>(),
486 200usize,
487 concat!("Size of: ", stringify!(_opaque_pthread_rwlock_t))
488 );
489 assert_eq!(
490 ::std::mem::align_of::<_opaque_pthread_rwlock_t>(),
491 8usize,
492 concat!("Alignment of ", stringify!(_opaque_pthread_rwlock_t))
493 );
494 assert_eq!(
495 unsafe { &(*(::std::ptr::null::<_opaque_pthread_rwlock_t>())).__sig as *const _ as usize },
496 0usize,
497 concat!(
498 "Offset of field: ",
499 stringify!(_opaque_pthread_rwlock_t),
500 "::",
501 stringify!(__sig)
502 )
503 );
504 assert_eq!(
505 unsafe {
506 &(*(::std::ptr::null::<_opaque_pthread_rwlock_t>())).__opaque as *const _ as usize
507 },
508 8usize,
509 concat!(
510 "Offset of field: ",
511 stringify!(_opaque_pthread_rwlock_t),
512 "::",
513 stringify!(__opaque)
514 )
515 );
516}
517#[repr(C)]
518#[derive(Debug, Copy, Clone)]
519pub struct _opaque_pthread_rwlockattr_t {
520 pub __sig: ::std::os::raw::c_long,
521 pub __opaque: [::std::os::raw::c_char; 16usize],
522}
523#[test]
524fn bindgen_test_layout__opaque_pthread_rwlockattr_t() {
525 assert_eq!(
526 ::std::mem::size_of::<_opaque_pthread_rwlockattr_t>(),
527 24usize,
528 concat!("Size of: ", stringify!(_opaque_pthread_rwlockattr_t))
529 );
530 assert_eq!(
531 ::std::mem::align_of::<_opaque_pthread_rwlockattr_t>(),
532 8usize,
533 concat!("Alignment of ", stringify!(_opaque_pthread_rwlockattr_t))
534 );
535 assert_eq!(
536 unsafe {
537 &(*(::std::ptr::null::<_opaque_pthread_rwlockattr_t>())).__sig as *const _ as usize
538 },
539 0usize,
540 concat!(
541 "Offset of field: ",
542 stringify!(_opaque_pthread_rwlockattr_t),
543 "::",
544 stringify!(__sig)
545 )
546 );
547 assert_eq!(
548 unsafe {
549 &(*(::std::ptr::null::<_opaque_pthread_rwlockattr_t>())).__opaque as *const _ as usize
550 },
551 8usize,
552 concat!(
553 "Offset of field: ",
554 stringify!(_opaque_pthread_rwlockattr_t),
555 "::",
556 stringify!(__opaque)
557 )
558 );
559}
560#[repr(C)]
561#[derive(Copy, Clone)]
562pub struct _opaque_pthread_t {
563 pub __sig: ::std::os::raw::c_long,
564 pub __cleanup_stack: *mut __darwin_pthread_handler_rec,
565 pub __opaque: [::std::os::raw::c_char; 8176usize],
566}
567#[test]
568fn bindgen_test_layout__opaque_pthread_t() {
569 assert_eq!(
570 ::std::mem::size_of::<_opaque_pthread_t>(),
571 8192usize,
572 concat!("Size of: ", stringify!(_opaque_pthread_t))
573 );
574 assert_eq!(
575 ::std::mem::align_of::<_opaque_pthread_t>(),
576 8usize,
577 concat!("Alignment of ", stringify!(_opaque_pthread_t))
578 );
579 assert_eq!(
580 unsafe { &(*(::std::ptr::null::<_opaque_pthread_t>())).__sig as *const _ as usize },
581 0usize,
582 concat!(
583 "Offset of field: ",
584 stringify!(_opaque_pthread_t),
585 "::",
586 stringify!(__sig)
587 )
588 );
589 assert_eq!(
590 unsafe {
591 &(*(::std::ptr::null::<_opaque_pthread_t>())).__cleanup_stack as *const _ as usize
592 },
593 8usize,
594 concat!(
595 "Offset of field: ",
596 stringify!(_opaque_pthread_t),
597 "::",
598 stringify!(__cleanup_stack)
599 )
600 );
601 assert_eq!(
602 unsafe { &(*(::std::ptr::null::<_opaque_pthread_t>())).__opaque as *const _ as usize },
603 16usize,
604 concat!(
605 "Offset of field: ",
606 stringify!(_opaque_pthread_t),
607 "::",
608 stringify!(__opaque)
609 )
610 );
611}
612pub type __darwin_pthread_attr_t = _opaque_pthread_attr_t;
613pub type __darwin_pthread_cond_t = _opaque_pthread_cond_t;
614pub type __darwin_pthread_condattr_t = _opaque_pthread_condattr_t;
615pub type __darwin_pthread_key_t = ::std::os::raw::c_ulong;
616pub type __darwin_pthread_mutex_t = _opaque_pthread_mutex_t;
617pub type __darwin_pthread_mutexattr_t = _opaque_pthread_mutexattr_t;
618pub type __darwin_pthread_once_t = _opaque_pthread_once_t;
619pub type __darwin_pthread_rwlock_t = _opaque_pthread_rwlock_t;
620pub type __darwin_pthread_rwlockattr_t = _opaque_pthread_rwlockattr_t;
621pub type __darwin_pthread_t = *mut _opaque_pthread_t;
622pub type u_int8_t = ::std::os::raw::c_uchar;
623pub type u_int16_t = ::std::os::raw::c_ushort;
624pub type u_int32_t = ::std::os::raw::c_uint;
625pub type u_int64_t = ::std::os::raw::c_ulonglong;
626pub type register_t = i64;
627pub type user_addr_t = u_int64_t;
628pub type user_size_t = u_int64_t;
629pub type user_ssize_t = i64;
630pub type user_long_t = i64;
631pub type user_ulong_t = u_int64_t;
632pub type user_time_t = i64;
633pub type user_off_t = i64;
634pub type syscall_arg_t = u_int64_t;
635pub type intmax_t = ::std::os::raw::c_long;
636pub type uintmax_t = ::std::os::raw::c_ulong;
637#[repr(C)]
638#[derive(Debug, Copy, Clone)]
639pub struct PgQueryError {
640 pub message: *mut ::std::os::raw::c_char,
641 pub funcname: *mut ::std::os::raw::c_char,
642 pub filename: *mut ::std::os::raw::c_char,
643 pub lineno: ::std::os::raw::c_int,
644 pub cursorpos: ::std::os::raw::c_int,
645 pub context: *mut ::std::os::raw::c_char,
646}
647#[test]
648fn bindgen_test_layout_PgQueryError() {
649 assert_eq!(
650 ::std::mem::size_of::<PgQueryError>(),
651 40usize,
652 concat!("Size of: ", stringify!(PgQueryError))
653 );
654 assert_eq!(
655 ::std::mem::align_of::<PgQueryError>(),
656 8usize,
657 concat!("Alignment of ", stringify!(PgQueryError))
658 );
659 assert_eq!(
660 unsafe { &(*(::std::ptr::null::<PgQueryError>())).message as *const _ as usize },
661 0usize,
662 concat!(
663 "Offset of field: ",
664 stringify!(PgQueryError),
665 "::",
666 stringify!(message)
667 )
668 );
669 assert_eq!(
670 unsafe { &(*(::std::ptr::null::<PgQueryError>())).funcname as *const _ as usize },
671 8usize,
672 concat!(
673 "Offset of field: ",
674 stringify!(PgQueryError),
675 "::",
676 stringify!(funcname)
677 )
678 );
679 assert_eq!(
680 unsafe { &(*(::std::ptr::null::<PgQueryError>())).filename as *const _ as usize },
681 16usize,
682 concat!(
683 "Offset of field: ",
684 stringify!(PgQueryError),
685 "::",
686 stringify!(filename)
687 )
688 );
689 assert_eq!(
690 unsafe { &(*(::std::ptr::null::<PgQueryError>())).lineno as *const _ as usize },
691 24usize,
692 concat!(
693 "Offset of field: ",
694 stringify!(PgQueryError),
695 "::",
696 stringify!(lineno)
697 )
698 );
699 assert_eq!(
700 unsafe { &(*(::std::ptr::null::<PgQueryError>())).cursorpos as *const _ as usize },
701 28usize,
702 concat!(
703 "Offset of field: ",
704 stringify!(PgQueryError),
705 "::",
706 stringify!(cursorpos)
707 )
708 );
709 assert_eq!(
710 unsafe { &(*(::std::ptr::null::<PgQueryError>())).context as *const _ as usize },
711 32usize,
712 concat!(
713 "Offset of field: ",
714 stringify!(PgQueryError),
715 "::",
716 stringify!(context)
717 )
718 );
719}
720#[repr(C)]
721#[derive(Debug, Copy, Clone)]
722pub struct PgQueryProtobuf {
723 pub len: ::std::os::raw::c_uint,
724 pub data: *mut ::std::os::raw::c_char,
725}
726#[test]
727fn bindgen_test_layout_PgQueryProtobuf() {
728 assert_eq!(
729 ::std::mem::size_of::<PgQueryProtobuf>(),
730 16usize,
731 concat!("Size of: ", stringify!(PgQueryProtobuf))
732 );
733 assert_eq!(
734 ::std::mem::align_of::<PgQueryProtobuf>(),
735 8usize,
736 concat!("Alignment of ", stringify!(PgQueryProtobuf))
737 );
738 assert_eq!(
739 unsafe { &(*(::std::ptr::null::<PgQueryProtobuf>())).len as *const _ as usize },
740 0usize,
741 concat!(
742 "Offset of field: ",
743 stringify!(PgQueryProtobuf),
744 "::",
745 stringify!(len)
746 )
747 );
748 assert_eq!(
749 unsafe { &(*(::std::ptr::null::<PgQueryProtobuf>())).data as *const _ as usize },
750 8usize,
751 concat!(
752 "Offset of field: ",
753 stringify!(PgQueryProtobuf),
754 "::",
755 stringify!(data)
756 )
757 );
758}
759#[repr(C)]
760#[derive(Debug, Copy, Clone)]
761pub struct PgQueryScanResult {
762 pub pbuf: PgQueryProtobuf,
763 pub stderr_buffer: *mut ::std::os::raw::c_char,
764 pub error: *mut PgQueryError,
765}
766#[test]
767fn bindgen_test_layout_PgQueryScanResult() {
768 assert_eq!(
769 ::std::mem::size_of::<PgQueryScanResult>(),
770 32usize,
771 concat!("Size of: ", stringify!(PgQueryScanResult))
772 );
773 assert_eq!(
774 ::std::mem::align_of::<PgQueryScanResult>(),
775 8usize,
776 concat!("Alignment of ", stringify!(PgQueryScanResult))
777 );
778 assert_eq!(
779 unsafe { &(*(::std::ptr::null::<PgQueryScanResult>())).pbuf as *const _ as usize },
780 0usize,
781 concat!(
782 "Offset of field: ",
783 stringify!(PgQueryScanResult),
784 "::",
785 stringify!(pbuf)
786 )
787 );
788 assert_eq!(
789 unsafe { &(*(::std::ptr::null::<PgQueryScanResult>())).stderr_buffer as *const _ as usize },
790 16usize,
791 concat!(
792 "Offset of field: ",
793 stringify!(PgQueryScanResult),
794 "::",
795 stringify!(stderr_buffer)
796 )
797 );
798 assert_eq!(
799 unsafe { &(*(::std::ptr::null::<PgQueryScanResult>())).error as *const _ as usize },
800 24usize,
801 concat!(
802 "Offset of field: ",
803 stringify!(PgQueryScanResult),
804 "::",
805 stringify!(error)
806 )
807 );
808}
809#[repr(C)]
810#[derive(Debug, Copy, Clone)]
811pub struct PgQueryParseResult {
812 pub parse_tree: *mut ::std::os::raw::c_char,
813 pub stderr_buffer: *mut ::std::os::raw::c_char,
814 pub error: *mut PgQueryError,
815}
816#[test]
817fn bindgen_test_layout_PgQueryParseResult() {
818 assert_eq!(
819 ::std::mem::size_of::<PgQueryParseResult>(),
820 24usize,
821 concat!("Size of: ", stringify!(PgQueryParseResult))
822 );
823 assert_eq!(
824 ::std::mem::align_of::<PgQueryParseResult>(),
825 8usize,
826 concat!("Alignment of ", stringify!(PgQueryParseResult))
827 );
828 assert_eq!(
829 unsafe { &(*(::std::ptr::null::<PgQueryParseResult>())).parse_tree as *const _ as usize },
830 0usize,
831 concat!(
832 "Offset of field: ",
833 stringify!(PgQueryParseResult),
834 "::",
835 stringify!(parse_tree)
836 )
837 );
838 assert_eq!(
839 unsafe {
840 &(*(::std::ptr::null::<PgQueryParseResult>())).stderr_buffer as *const _ as usize
841 },
842 8usize,
843 concat!(
844 "Offset of field: ",
845 stringify!(PgQueryParseResult),
846 "::",
847 stringify!(stderr_buffer)
848 )
849 );
850 assert_eq!(
851 unsafe { &(*(::std::ptr::null::<PgQueryParseResult>())).error as *const _ as usize },
852 16usize,
853 concat!(
854 "Offset of field: ",
855 stringify!(PgQueryParseResult),
856 "::",
857 stringify!(error)
858 )
859 );
860}
861#[repr(C)]
862#[derive(Debug, Copy, Clone)]
863pub struct PgQueryProtobufParseResult {
864 pub parse_tree: PgQueryProtobuf,
865 pub stderr_buffer: *mut ::std::os::raw::c_char,
866 pub error: *mut PgQueryError,
867}
868#[test]
869fn bindgen_test_layout_PgQueryProtobufParseResult() {
870 assert_eq!(
871 ::std::mem::size_of::<PgQueryProtobufParseResult>(),
872 32usize,
873 concat!("Size of: ", stringify!(PgQueryProtobufParseResult))
874 );
875 assert_eq!(
876 ::std::mem::align_of::<PgQueryProtobufParseResult>(),
877 8usize,
878 concat!("Alignment of ", stringify!(PgQueryProtobufParseResult))
879 );
880 assert_eq!(
881 unsafe {
882 &(*(::std::ptr::null::<PgQueryProtobufParseResult>())).parse_tree as *const _ as usize
883 },
884 0usize,
885 concat!(
886 "Offset of field: ",
887 stringify!(PgQueryProtobufParseResult),
888 "::",
889 stringify!(parse_tree)
890 )
891 );
892 assert_eq!(
893 unsafe {
894 &(*(::std::ptr::null::<PgQueryProtobufParseResult>())).stderr_buffer as *const _
895 as usize
896 },
897 16usize,
898 concat!(
899 "Offset of field: ",
900 stringify!(PgQueryProtobufParseResult),
901 "::",
902 stringify!(stderr_buffer)
903 )
904 );
905 assert_eq!(
906 unsafe {
907 &(*(::std::ptr::null::<PgQueryProtobufParseResult>())).error as *const _ as usize
908 },
909 24usize,
910 concat!(
911 "Offset of field: ",
912 stringify!(PgQueryProtobufParseResult),
913 "::",
914 stringify!(error)
915 )
916 );
917}
918#[repr(C)]
919#[derive(Debug, Copy, Clone)]
920pub struct PgQuerySplitStmt {
921 pub stmt_location: ::std::os::raw::c_int,
922 pub stmt_len: ::std::os::raw::c_int,
923}
924#[test]
925fn bindgen_test_layout_PgQuerySplitStmt() {
926 assert_eq!(
927 ::std::mem::size_of::<PgQuerySplitStmt>(),
928 8usize,
929 concat!("Size of: ", stringify!(PgQuerySplitStmt))
930 );
931 assert_eq!(
932 ::std::mem::align_of::<PgQuerySplitStmt>(),
933 4usize,
934 concat!("Alignment of ", stringify!(PgQuerySplitStmt))
935 );
936 assert_eq!(
937 unsafe { &(*(::std::ptr::null::<PgQuerySplitStmt>())).stmt_location as *const _ as usize },
938 0usize,
939 concat!(
940 "Offset of field: ",
941 stringify!(PgQuerySplitStmt),
942 "::",
943 stringify!(stmt_location)
944 )
945 );
946 assert_eq!(
947 unsafe { &(*(::std::ptr::null::<PgQuerySplitStmt>())).stmt_len as *const _ as usize },
948 4usize,
949 concat!(
950 "Offset of field: ",
951 stringify!(PgQuerySplitStmt),
952 "::",
953 stringify!(stmt_len)
954 )
955 );
956}
957#[repr(C)]
958#[derive(Debug, Copy, Clone)]
959pub struct PgQuerySplitResult {
960 pub stmts: *mut *mut PgQuerySplitStmt,
961 pub n_stmts: ::std::os::raw::c_int,
962 pub stderr_buffer: *mut ::std::os::raw::c_char,
963 pub error: *mut PgQueryError,
964}
965#[test]
966fn bindgen_test_layout_PgQuerySplitResult() {
967 assert_eq!(
968 ::std::mem::size_of::<PgQuerySplitResult>(),
969 32usize,
970 concat!("Size of: ", stringify!(PgQuerySplitResult))
971 );
972 assert_eq!(
973 ::std::mem::align_of::<PgQuerySplitResult>(),
974 8usize,
975 concat!("Alignment of ", stringify!(PgQuerySplitResult))
976 );
977 assert_eq!(
978 unsafe { &(*(::std::ptr::null::<PgQuerySplitResult>())).stmts as *const _ as usize },
979 0usize,
980 concat!(
981 "Offset of field: ",
982 stringify!(PgQuerySplitResult),
983 "::",
984 stringify!(stmts)
985 )
986 );
987 assert_eq!(
988 unsafe { &(*(::std::ptr::null::<PgQuerySplitResult>())).n_stmts as *const _ as usize },
989 8usize,
990 concat!(
991 "Offset of field: ",
992 stringify!(PgQuerySplitResult),
993 "::",
994 stringify!(n_stmts)
995 )
996 );
997 assert_eq!(
998 unsafe {
999 &(*(::std::ptr::null::<PgQuerySplitResult>())).stderr_buffer as *const _ as usize
1000 },
1001 16usize,
1002 concat!(
1003 "Offset of field: ",
1004 stringify!(PgQuerySplitResult),
1005 "::",
1006 stringify!(stderr_buffer)
1007 )
1008 );
1009 assert_eq!(
1010 unsafe { &(*(::std::ptr::null::<PgQuerySplitResult>())).error as *const _ as usize },
1011 24usize,
1012 concat!(
1013 "Offset of field: ",
1014 stringify!(PgQuerySplitResult),
1015 "::",
1016 stringify!(error)
1017 )
1018 );
1019}
1020#[repr(C)]
1021#[derive(Debug, Copy, Clone)]
1022pub struct PgQueryDeparseResult {
1023 pub query: *mut ::std::os::raw::c_char,
1024 pub error: *mut PgQueryError,
1025}
1026#[test]
1027fn bindgen_test_layout_PgQueryDeparseResult() {
1028 assert_eq!(
1029 ::std::mem::size_of::<PgQueryDeparseResult>(),
1030 16usize,
1031 concat!("Size of: ", stringify!(PgQueryDeparseResult))
1032 );
1033 assert_eq!(
1034 ::std::mem::align_of::<PgQueryDeparseResult>(),
1035 8usize,
1036 concat!("Alignment of ", stringify!(PgQueryDeparseResult))
1037 );
1038 assert_eq!(
1039 unsafe { &(*(::std::ptr::null::<PgQueryDeparseResult>())).query as *const _ as usize },
1040 0usize,
1041 concat!(
1042 "Offset of field: ",
1043 stringify!(PgQueryDeparseResult),
1044 "::",
1045 stringify!(query)
1046 )
1047 );
1048 assert_eq!(
1049 unsafe { &(*(::std::ptr::null::<PgQueryDeparseResult>())).error as *const _ as usize },
1050 8usize,
1051 concat!(
1052 "Offset of field: ",
1053 stringify!(PgQueryDeparseResult),
1054 "::",
1055 stringify!(error)
1056 )
1057 );
1058}
1059#[repr(C)]
1060#[derive(Debug, Copy, Clone)]
1061pub struct PgQueryPlpgsqlParseResult {
1062 pub plpgsql_funcs: *mut ::std::os::raw::c_char,
1063 pub error: *mut PgQueryError,
1064}
1065#[test]
1066fn bindgen_test_layout_PgQueryPlpgsqlParseResult() {
1067 assert_eq!(
1068 ::std::mem::size_of::<PgQueryPlpgsqlParseResult>(),
1069 16usize,
1070 concat!("Size of: ", stringify!(PgQueryPlpgsqlParseResult))
1071 );
1072 assert_eq!(
1073 ::std::mem::align_of::<PgQueryPlpgsqlParseResult>(),
1074 8usize,
1075 concat!("Alignment of ", stringify!(PgQueryPlpgsqlParseResult))
1076 );
1077 assert_eq!(
1078 unsafe {
1079 &(*(::std::ptr::null::<PgQueryPlpgsqlParseResult>())).plpgsql_funcs as *const _ as usize
1080 },
1081 0usize,
1082 concat!(
1083 "Offset of field: ",
1084 stringify!(PgQueryPlpgsqlParseResult),
1085 "::",
1086 stringify!(plpgsql_funcs)
1087 )
1088 );
1089 assert_eq!(
1090 unsafe { &(*(::std::ptr::null::<PgQueryPlpgsqlParseResult>())).error as *const _ as usize },
1091 8usize,
1092 concat!(
1093 "Offset of field: ",
1094 stringify!(PgQueryPlpgsqlParseResult),
1095 "::",
1096 stringify!(error)
1097 )
1098 );
1099}
1100#[repr(C)]
1101#[derive(Debug, Copy, Clone)]
1102pub struct PgQueryFingerprintResult {
1103 pub fingerprint: u64,
1104 pub fingerprint_str: *mut ::std::os::raw::c_char,
1105 pub stderr_buffer: *mut ::std::os::raw::c_char,
1106 pub error: *mut PgQueryError,
1107}
1108#[test]
1109fn bindgen_test_layout_PgQueryFingerprintResult() {
1110 assert_eq!(
1111 ::std::mem::size_of::<PgQueryFingerprintResult>(),
1112 32usize,
1113 concat!("Size of: ", stringify!(PgQueryFingerprintResult))
1114 );
1115 assert_eq!(
1116 ::std::mem::align_of::<PgQueryFingerprintResult>(),
1117 8usize,
1118 concat!("Alignment of ", stringify!(PgQueryFingerprintResult))
1119 );
1120 assert_eq!(
1121 unsafe {
1122 &(*(::std::ptr::null::<PgQueryFingerprintResult>())).fingerprint as *const _ as usize
1123 },
1124 0usize,
1125 concat!(
1126 "Offset of field: ",
1127 stringify!(PgQueryFingerprintResult),
1128 "::",
1129 stringify!(fingerprint)
1130 )
1131 );
1132 assert_eq!(
1133 unsafe {
1134 &(*(::std::ptr::null::<PgQueryFingerprintResult>())).fingerprint_str as *const _
1135 as usize
1136 },
1137 8usize,
1138 concat!(
1139 "Offset of field: ",
1140 stringify!(PgQueryFingerprintResult),
1141 "::",
1142 stringify!(fingerprint_str)
1143 )
1144 );
1145 assert_eq!(
1146 unsafe {
1147 &(*(::std::ptr::null::<PgQueryFingerprintResult>())).stderr_buffer as *const _ as usize
1148 },
1149 16usize,
1150 concat!(
1151 "Offset of field: ",
1152 stringify!(PgQueryFingerprintResult),
1153 "::",
1154 stringify!(stderr_buffer)
1155 )
1156 );
1157 assert_eq!(
1158 unsafe { &(*(::std::ptr::null::<PgQueryFingerprintResult>())).error as *const _ as usize },
1159 24usize,
1160 concat!(
1161 "Offset of field: ",
1162 stringify!(PgQueryFingerprintResult),
1163 "::",
1164 stringify!(error)
1165 )
1166 );
1167}
1168#[repr(C)]
1169#[derive(Debug, Copy, Clone)]
1170pub struct PgQueryNormalizeResult {
1171 pub normalized_query: *mut ::std::os::raw::c_char,
1172 pub error: *mut PgQueryError,
1173}
1174#[test]
1175fn bindgen_test_layout_PgQueryNormalizeResult() {
1176 assert_eq!(
1177 ::std::mem::size_of::<PgQueryNormalizeResult>(),
1178 16usize,
1179 concat!("Size of: ", stringify!(PgQueryNormalizeResult))
1180 );
1181 assert_eq!(
1182 ::std::mem::align_of::<PgQueryNormalizeResult>(),
1183 8usize,
1184 concat!("Alignment of ", stringify!(PgQueryNormalizeResult))
1185 );
1186 assert_eq!(
1187 unsafe {
1188 &(*(::std::ptr::null::<PgQueryNormalizeResult>())).normalized_query as *const _ as usize
1189 },
1190 0usize,
1191 concat!(
1192 "Offset of field: ",
1193 stringify!(PgQueryNormalizeResult),
1194 "::",
1195 stringify!(normalized_query)
1196 )
1197 );
1198 assert_eq!(
1199 unsafe { &(*(::std::ptr::null::<PgQueryNormalizeResult>())).error as *const _ as usize },
1200 8usize,
1201 concat!(
1202 "Offset of field: ",
1203 stringify!(PgQueryNormalizeResult),
1204 "::",
1205 stringify!(error)
1206 )
1207 );
1208}
1209extern "C" {
1210 pub fn pg_query_normalize(input: *const ::std::os::raw::c_char) -> PgQueryNormalizeResult;
1211}
1212extern "C" {
1213 pub fn pg_query_scan(input: *const ::std::os::raw::c_char) -> PgQueryScanResult;
1214}
1215extern "C" {
1216 pub fn pg_query_parse(input: *const ::std::os::raw::c_char) -> PgQueryParseResult;
1217}
1218extern "C" {
1219 pub fn pg_query_parse_protobuf(
1220 input: *const ::std::os::raw::c_char,
1221 ) -> PgQueryProtobufParseResult;
1222}
1223extern "C" {
1224 pub fn pg_query_parse_plpgsql(
1225 input: *const ::std::os::raw::c_char,
1226 ) -> PgQueryPlpgsqlParseResult;
1227}
1228extern "C" {
1229 pub fn pg_query_fingerprint(input: *const ::std::os::raw::c_char) -> PgQueryFingerprintResult;
1230}
1231extern "C" {
1232 pub fn pg_query_split_with_scanner(input: *const ::std::os::raw::c_char) -> PgQuerySplitResult;
1233}
1234extern "C" {
1235 pub fn pg_query_split_with_parser(input: *const ::std::os::raw::c_char) -> PgQuerySplitResult;
1236}
1237extern "C" {
1238 pub fn pg_query_deparse_protobuf(parse_tree: PgQueryProtobuf) -> PgQueryDeparseResult;
1239}
1240extern "C" {
1241 pub fn pg_query_free_normalize_result(result: PgQueryNormalizeResult);
1242}
1243extern "C" {
1244 pub fn pg_query_free_scan_result(result: PgQueryScanResult);
1245}
1246extern "C" {
1247 pub fn pg_query_free_parse_result(result: PgQueryParseResult);
1248}
1249extern "C" {
1250 pub fn pg_query_free_split_result(result: PgQuerySplitResult);
1251}
1252extern "C" {
1253 pub fn pg_query_free_deparse_result(result: PgQueryDeparseResult);
1254}
1255extern "C" {
1256 pub fn pg_query_free_protobuf_parse_result(result: PgQueryProtobufParseResult);
1257}
1258extern "C" {
1259 pub fn pg_query_free_plpgsql_parse_result(result: PgQueryPlpgsqlParseResult);
1260}
1261extern "C" {
1262 pub fn pg_query_free_fingerprint_result(result: PgQueryFingerprintResult);
1263}
1264extern "C" {
1265 pub fn pg_query_exit();
1266}
1267extern "C" {
1268 pub fn pg_query_init();
1269}
1270pub type __builtin_va_list = *mut ::std::os::raw::c_char;