1#![allow(non_upper_case_globals)]
2#![allow(non_snake_case)]
3#![allow(non_camel_case_types)]
4pub const _STRING_H: u32 = 1;
7pub const _FEATURES_H: u32 = 1;
8pub const _DEFAULT_SOURCE: u32 = 1;
9pub const __GLIBC_USE_ISOC2X: u32 = 0;
10pub const __USE_ISOC11: u32 = 1;
11pub const __USE_ISOC99: u32 = 1;
12pub const __USE_ISOC95: u32 = 1;
13pub const __USE_POSIX_IMPLICITLY: u32 = 1;
14pub const _POSIX_SOURCE: u32 = 1;
15pub const _POSIX_C_SOURCE: u32 = 200809;
16pub const __USE_POSIX: u32 = 1;
17pub const __USE_POSIX2: u32 = 1;
18pub const __USE_POSIX199309: u32 = 1;
19pub const __USE_POSIX199506: u32 = 1;
20pub const __USE_XOPEN2K: u32 = 1;
21pub const __USE_XOPEN2K8: u32 = 1;
22pub const _ATFILE_SOURCE: u32 = 1;
23pub const __WORDSIZE: u32 = 64;
24pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
25pub const __SYSCALL_WORDSIZE: u32 = 64;
26pub const __TIMESIZE: u32 = 64;
27pub const __USE_MISC: u32 = 1;
28pub const __USE_ATFILE: u32 = 1;
29pub const __USE_FORTIFY_LEVEL: u32 = 0;
30pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
31pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
32pub const _STDC_PREDEF_H: u32 = 1;
33pub const __STDC_IEC_559__: u32 = 1;
34pub const __STDC_IEC_60559_BFP__: u32 = 201404;
35pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
36pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
37pub const __STDC_ISO_10646__: u32 = 201706;
38pub const __GNU_LIBRARY__: u32 = 6;
39pub const __GLIBC__: u32 = 2;
40pub const __GLIBC_MINOR__: u32 = 36;
41pub const _SYS_CDEFS_H: u32 = 1;
42pub const __glibc_c99_flexarr_available: u32 = 1;
43pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
44pub const __HAVE_GENERIC_SELECTION: u32 = 1;
45pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
46pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
47pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
48pub const __GLIBC_USE_IEC_60559_EXT: u32 = 0;
49pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
50pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
51pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
52pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
53pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
54pub const _STRINGS_H: u32 = 1;
55pub const CST_WRONG_FORMAT: i32 = -2;
56pub const CST_ERROR_FORMAT: i32 = -1;
57pub const CST_OK_FORMAT: u32 = 0;
58pub const _STDIO_H: u32 = 1;
59pub const __GNUC_VA_LIST: u32 = 1;
60pub const _BITS_TYPES_H: u32 = 1;
61pub const _BITS_TYPESIZES_H: u32 = 1;
62pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
63pub const __INO_T_MATCHES_INO64_T: u32 = 1;
64pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
65pub const __STATFS_MATCHES_STATFS64: u32 = 1;
66pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
67pub const __FD_SETSIZE: u32 = 1024;
68pub const _BITS_TIME64_H: u32 = 1;
69pub const _____fpos_t_defined: u32 = 1;
70pub const ____mbstate_t_defined: u32 = 1;
71pub const _____fpos64_t_defined: u32 = 1;
72pub const ____FILE_defined: u32 = 1;
73pub const __FILE_defined: u32 = 1;
74pub const __struct_FILE_defined: u32 = 1;
75pub const _IO_EOF_SEEN: u32 = 16;
76pub const _IO_ERR_SEEN: u32 = 32;
77pub const _IO_USER_LOCK: u32 = 32768;
78pub const _IOFBF: u32 = 0;
79pub const _IOLBF: u32 = 1;
80pub const _IONBF: u32 = 2;
81pub const BUFSIZ: u32 = 8192;
82pub const EOF: i32 = -1;
83pub const SEEK_SET: u32 = 0;
84pub const SEEK_CUR: u32 = 1;
85pub const SEEK_END: u32 = 2;
86pub const P_tmpdir: &[u8; 5usize] = b"/tmp\0";
87pub const _BITS_STDIO_LIM_H: u32 = 1;
88pub const L_tmpnam: u32 = 20;
89pub const TMP_MAX: u32 = 238328;
90pub const FILENAME_MAX: u32 = 4096;
91pub const L_ctermid: u32 = 9;
92pub const FOPEN_MAX: u32 = 16;
93pub const __HAVE_FLOAT128: u32 = 0;
94pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
95pub const __HAVE_FLOAT64X: u32 = 1;
96pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
97pub const __HAVE_FLOAT16: u32 = 0;
98pub const __HAVE_FLOAT32: u32 = 1;
99pub const __HAVE_FLOAT64: u32 = 1;
100pub const __HAVE_FLOAT32X: u32 = 1;
101pub const __HAVE_FLOAT128X: u32 = 0;
102pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
103pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
104pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
105pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
106pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
107pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
108pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
109pub const CST_OPEN_WRITE: u32 = 1;
110pub const CST_OPEN_READ: u32 = 2;
111pub const CST_OPEN_APPEND: u32 = 4;
112pub const CST_OPEN_BINARY: u32 = 8;
113pub const CST_SEEK_ABSOLUTE: u32 = 0;
114pub const CST_SEEK_RELATIVE: u32 = 1;
115pub const CST_SEEK_ENDREL: u32 = 2;
116pub const CST_REGMAGIC: u32 = 156;
117pub const CST_NSUBEXP: u32 = 10;
118pub const CST_RX_dotted_abbrev_NUM: u32 = 0;
119pub const _STDLIB_H: u32 = 1;
120pub const WNOHANG: u32 = 1;
121pub const WUNTRACED: u32 = 2;
122pub const WSTOPPED: u32 = 2;
123pub const WEXITED: u32 = 4;
124pub const WCONTINUED: u32 = 8;
125pub const WNOWAIT: u32 = 16777216;
126pub const __WNOTHREAD: u32 = 536870912;
127pub const __WALL: u32 = 1073741824;
128pub const __WCLONE: u32 = 2147483648;
129pub const __W_CONTINUED: u32 = 65535;
130pub const __WCOREFLAG: u32 = 128;
131pub const __ldiv_t_defined: u32 = 1;
132pub const __lldiv_t_defined: u32 = 1;
133pub const RAND_MAX: u32 = 2147483647;
134pub const EXIT_FAILURE: u32 = 1;
135pub const EXIT_SUCCESS: u32 = 0;
136pub const _SYS_TYPES_H: u32 = 1;
137pub const __clock_t_defined: u32 = 1;
138pub const __clockid_t_defined: u32 = 1;
139pub const __time_t_defined: u32 = 1;
140pub const __timer_t_defined: u32 = 1;
141pub const _BITS_STDINT_INTN_H: u32 = 1;
142pub const __BIT_TYPES_DEFINED__: u32 = 1;
143pub const _ENDIAN_H: u32 = 1;
144pub const _BITS_ENDIAN_H: u32 = 1;
145pub const __LITTLE_ENDIAN: u32 = 1234;
146pub const __BIG_ENDIAN: u32 = 4321;
147pub const __PDP_ENDIAN: u32 = 3412;
148pub const _BITS_ENDIANNESS_H: u32 = 1;
149pub const __BYTE_ORDER: u32 = 1234;
150pub const __FLOAT_WORD_ORDER: u32 = 1234;
151pub const LITTLE_ENDIAN: u32 = 1234;
152pub const BIG_ENDIAN: u32 = 4321;
153pub const PDP_ENDIAN: u32 = 3412;
154pub const BYTE_ORDER: u32 = 1234;
155pub const _BITS_BYTESWAP_H: u32 = 1;
156pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
157pub const _SYS_SELECT_H: u32 = 1;
158pub const __sigset_t_defined: u32 = 1;
159pub const __timeval_defined: u32 = 1;
160pub const _STRUCT_TIMESPEC: u32 = 1;
161pub const FD_SETSIZE: u32 = 1024;
162pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
163pub const _THREAD_SHARED_TYPES_H: u32 = 1;
164pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
165pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
166pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
167pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
168pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
169pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
170pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
171pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
172pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
173pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
174pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
175pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
176pub const __have_pthread_attr_t: u32 = 1;
177pub const _ALLOCA_H: u32 = 1;
178pub const _SETJMP_H: u32 = 1;
179pub const _BITS_SETJMP_H: u32 = 1;
180pub const __jmp_buf_tag_defined: u32 = 1;
181pub const CST_VAL_TYPE_CONS: u32 = 0;
182pub const CST_VAL_TYPE_INT: u32 = 1;
183pub const CST_VAL_TYPE_FLOAT: u32 = 3;
184pub const CST_VAL_TYPE_STRING: u32 = 5;
185pub const CST_VAL_TYPE_FIRST_FREE: u32 = 7;
186pub const CST_VAL_TYPE_MAX: u32 = 54;
187pub const CST_CONST_INT_MAX: u32 = 19;
188pub const BYTE_ORDER_BIG: &[u8; 3usize] = b"10\0";
189pub const BYTE_ORDER_LITTLE: &[u8; 3usize] = b"01\0";
190pub const RIFF_FORMAT_PCM: u32 = 1;
191pub const RIFF_FORMAT_ADPCM: u32 = 2;
192pub const RIFF_FORMAT_MULAW: u32 = 6;
193pub const RIFF_FORMAT_ALAW: u32 = 7;
194pub const CST_SND_ULAW: u32 = 1;
195pub const CST_SND_UCHAR: u32 = 2;
196pub const CST_SND_SHORT: u32 = 3;
197pub const CST_G721_LEADIN: u32 = 8;
198pub const CST_CART_OP_NONE: u32 = 255;
199pub const CST_CART_OP_LEAF: u32 = 255;
200pub const CST_CART_OP_IS: u32 = 0;
201pub const CST_CART_OP_IN: u32 = 1;
202pub const CST_CART_OP_LESS: u32 = 2;
203pub const CST_CART_OP_GREATER: u32 = 3;
204pub const CST_CART_OP_MATCHES: u32 = 4;
205pub const CST_CART_OP_EQUALS: u32 = 5;
206pub const CST_LTS_EOR: u32 = 255;
207pub const CST_AUDIOBUFFSIZE: u32 = 128;
208pub const CST_AUDIO_DEFAULT_PORT: u32 = 1746;
209pub const CST_AUDIO_DEFAULT_SERVER: &[u8; 10usize] = b"localhost\0";
210pub const CST_AUDIO_DEFAULT_ENCODING: &[u8; 6usize] = b"short\0";
211pub const CST_AUDIO_STREAM_STOP: i32 = -1;
212pub const CST_AUDIO_STREAM_CONT: u32 = 0;
213pub const TS_CHARCLASS_NONE: u32 = 0;
214pub const TS_CHARCLASS_WHITESPACE: u32 = 2;
215pub const TS_CHARCLASS_SINGLECHAR: u32 = 4;
216pub const TS_CHARCLASS_PREPUNCT: u32 = 8;
217pub const TS_CHARCLASS_POSTPUNCT: u32 = 16;
218pub const TS_CHARCLASS_QUOTE: u32 = 32;
219extern "C" {
220 pub fn memcpy(
221 __dest: *mut ::std::os::raw::c_void,
222 __src: *const ::std::os::raw::c_void,
223 __n: ::std::os::raw::c_ulong,
224 ) -> *mut ::std::os::raw::c_void;
225}
226extern "C" {
227 pub fn memmove(
228 __dest: *mut ::std::os::raw::c_void,
229 __src: *const ::std::os::raw::c_void,
230 __n: ::std::os::raw::c_ulong,
231 ) -> *mut ::std::os::raw::c_void;
232}
233extern "C" {
234 pub fn memccpy(
235 __dest: *mut ::std::os::raw::c_void,
236 __src: *const ::std::os::raw::c_void,
237 __c: ::std::os::raw::c_int,
238 __n: ::std::os::raw::c_ulong,
239 ) -> *mut ::std::os::raw::c_void;
240}
241extern "C" {
242 pub fn memset(
243 __s: *mut ::std::os::raw::c_void,
244 __c: ::std::os::raw::c_int,
245 __n: ::std::os::raw::c_ulong,
246 ) -> *mut ::std::os::raw::c_void;
247}
248extern "C" {
249 pub fn memcmp(
250 __s1: *const ::std::os::raw::c_void,
251 __s2: *const ::std::os::raw::c_void,
252 __n: ::std::os::raw::c_ulong,
253 ) -> ::std::os::raw::c_int;
254}
255extern "C" {
256 pub fn __memcmpeq(
257 __s1: *const ::std::os::raw::c_void,
258 __s2: *const ::std::os::raw::c_void,
259 __n: usize,
260 ) -> ::std::os::raw::c_int;
261}
262extern "C" {
263 pub fn memchr(
264 __s: *const ::std::os::raw::c_void,
265 __c: ::std::os::raw::c_int,
266 __n: ::std::os::raw::c_ulong,
267 ) -> *mut ::std::os::raw::c_void;
268}
269extern "C" {
270 pub fn strcpy(
271 __dest: *mut ::std::os::raw::c_char,
272 __src: *const ::std::os::raw::c_char,
273 ) -> *mut ::std::os::raw::c_char;
274}
275extern "C" {
276 pub fn strncpy(
277 __dest: *mut ::std::os::raw::c_char,
278 __src: *const ::std::os::raw::c_char,
279 __n: ::std::os::raw::c_ulong,
280 ) -> *mut ::std::os::raw::c_char;
281}
282extern "C" {
283 pub fn strcat(
284 __dest: *mut ::std::os::raw::c_char,
285 __src: *const ::std::os::raw::c_char,
286 ) -> *mut ::std::os::raw::c_char;
287}
288extern "C" {
289 pub fn strncat(
290 __dest: *mut ::std::os::raw::c_char,
291 __src: *const ::std::os::raw::c_char,
292 __n: ::std::os::raw::c_ulong,
293 ) -> *mut ::std::os::raw::c_char;
294}
295extern "C" {
296 pub fn strcmp(
297 __s1: *const ::std::os::raw::c_char,
298 __s2: *const ::std::os::raw::c_char,
299 ) -> ::std::os::raw::c_int;
300}
301extern "C" {
302 pub fn strncmp(
303 __s1: *const ::std::os::raw::c_char,
304 __s2: *const ::std::os::raw::c_char,
305 __n: ::std::os::raw::c_ulong,
306 ) -> ::std::os::raw::c_int;
307}
308extern "C" {
309 pub fn strcoll(
310 __s1: *const ::std::os::raw::c_char,
311 __s2: *const ::std::os::raw::c_char,
312 ) -> ::std::os::raw::c_int;
313}
314extern "C" {
315 pub fn strxfrm(
316 __dest: *mut ::std::os::raw::c_char,
317 __src: *const ::std::os::raw::c_char,
318 __n: ::std::os::raw::c_ulong,
319 ) -> ::std::os::raw::c_ulong;
320}
321#[repr(C)]
322#[derive(Debug, Copy, Clone)]
323pub struct __locale_struct {
324 pub __locales: [*mut __locale_data; 13usize],
325 pub __ctype_b: *const ::std::os::raw::c_ushort,
326 pub __ctype_tolower: *const ::std::os::raw::c_int,
327 pub __ctype_toupper: *const ::std::os::raw::c_int,
328 pub __names: [*const ::std::os::raw::c_char; 13usize],
329}
330#[test]
331fn bindgen_test_layout___locale_struct() {
332 const UNINIT: ::std::mem::MaybeUninit<__locale_struct> = ::std::mem::MaybeUninit::uninit();
333 let ptr = UNINIT.as_ptr();
334 assert_eq!(
335 ::std::mem::size_of::<__locale_struct>(),
336 232usize,
337 concat!("Size of: ", stringify!(__locale_struct))
338 );
339 assert_eq!(
340 ::std::mem::align_of::<__locale_struct>(),
341 8usize,
342 concat!("Alignment of ", stringify!(__locale_struct))
343 );
344 assert_eq!(
345 unsafe { ::std::ptr::addr_of!((*ptr).__locales) as usize - ptr as usize },
346 0usize,
347 concat!(
348 "Offset of field: ",
349 stringify!(__locale_struct),
350 "::",
351 stringify!(__locales)
352 )
353 );
354 assert_eq!(
355 unsafe { ::std::ptr::addr_of!((*ptr).__ctype_b) as usize - ptr as usize },
356 104usize,
357 concat!(
358 "Offset of field: ",
359 stringify!(__locale_struct),
360 "::",
361 stringify!(__ctype_b)
362 )
363 );
364 assert_eq!(
365 unsafe { ::std::ptr::addr_of!((*ptr).__ctype_tolower) as usize - ptr as usize },
366 112usize,
367 concat!(
368 "Offset of field: ",
369 stringify!(__locale_struct),
370 "::",
371 stringify!(__ctype_tolower)
372 )
373 );
374 assert_eq!(
375 unsafe { ::std::ptr::addr_of!((*ptr).__ctype_toupper) as usize - ptr as usize },
376 120usize,
377 concat!(
378 "Offset of field: ",
379 stringify!(__locale_struct),
380 "::",
381 stringify!(__ctype_toupper)
382 )
383 );
384 assert_eq!(
385 unsafe { ::std::ptr::addr_of!((*ptr).__names) as usize - ptr as usize },
386 128usize,
387 concat!(
388 "Offset of field: ",
389 stringify!(__locale_struct),
390 "::",
391 stringify!(__names)
392 )
393 );
394}
395pub type __locale_t = *mut __locale_struct;
396pub type locale_t = __locale_t;
397extern "C" {
398 pub fn strcoll_l(
399 __s1: *const ::std::os::raw::c_char,
400 __s2: *const ::std::os::raw::c_char,
401 __l: locale_t,
402 ) -> ::std::os::raw::c_int;
403}
404extern "C" {
405 pub fn strxfrm_l(
406 __dest: *mut ::std::os::raw::c_char,
407 __src: *const ::std::os::raw::c_char,
408 __n: usize,
409 __l: locale_t,
410 ) -> usize;
411}
412extern "C" {
413 pub fn strdup(__s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
414}
415extern "C" {
416 pub fn strndup(
417 __string: *const ::std::os::raw::c_char,
418 __n: ::std::os::raw::c_ulong,
419 ) -> *mut ::std::os::raw::c_char;
420}
421extern "C" {
422 pub fn strchr(
423 __s: *const ::std::os::raw::c_char,
424 __c: ::std::os::raw::c_int,
425 ) -> *mut ::std::os::raw::c_char;
426}
427extern "C" {
428 pub fn strrchr(
429 __s: *const ::std::os::raw::c_char,
430 __c: ::std::os::raw::c_int,
431 ) -> *mut ::std::os::raw::c_char;
432}
433extern "C" {
434 pub fn strcspn(
435 __s: *const ::std::os::raw::c_char,
436 __reject: *const ::std::os::raw::c_char,
437 ) -> ::std::os::raw::c_ulong;
438}
439extern "C" {
440 pub fn strspn(
441 __s: *const ::std::os::raw::c_char,
442 __accept: *const ::std::os::raw::c_char,
443 ) -> ::std::os::raw::c_ulong;
444}
445extern "C" {
446 pub fn strpbrk(
447 __s: *const ::std::os::raw::c_char,
448 __accept: *const ::std::os::raw::c_char,
449 ) -> *mut ::std::os::raw::c_char;
450}
451extern "C" {
452 pub fn strstr(
453 __haystack: *const ::std::os::raw::c_char,
454 __needle: *const ::std::os::raw::c_char,
455 ) -> *mut ::std::os::raw::c_char;
456}
457extern "C" {
458 pub fn strtok(
459 __s: *mut ::std::os::raw::c_char,
460 __delim: *const ::std::os::raw::c_char,
461 ) -> *mut ::std::os::raw::c_char;
462}
463extern "C" {
464 pub fn __strtok_r(
465 __s: *mut ::std::os::raw::c_char,
466 __delim: *const ::std::os::raw::c_char,
467 __save_ptr: *mut *mut ::std::os::raw::c_char,
468 ) -> *mut ::std::os::raw::c_char;
469}
470extern "C" {
471 pub fn strtok_r(
472 __s: *mut ::std::os::raw::c_char,
473 __delim: *const ::std::os::raw::c_char,
474 __save_ptr: *mut *mut ::std::os::raw::c_char,
475 ) -> *mut ::std::os::raw::c_char;
476}
477extern "C" {
478 pub fn strlen(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
479}
480extern "C" {
481 pub fn strnlen(__string: *const ::std::os::raw::c_char, __maxlen: usize) -> usize;
482}
483extern "C" {
484 pub fn strerror(__errnum: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
485}
486extern "C" {
487 #[link_name = "\u{1}__xpg_strerror_r"]
488 pub fn strerror_r(
489 __errnum: ::std::os::raw::c_int,
490 __buf: *mut ::std::os::raw::c_char,
491 __buflen: usize,
492 ) -> ::std::os::raw::c_int;
493}
494extern "C" {
495 pub fn strerror_l(
496 __errnum: ::std::os::raw::c_int,
497 __l: locale_t,
498 ) -> *mut ::std::os::raw::c_char;
499}
500extern "C" {
501 pub fn bcmp(
502 __s1: *const ::std::os::raw::c_void,
503 __s2: *const ::std::os::raw::c_void,
504 __n: ::std::os::raw::c_ulong,
505 ) -> ::std::os::raw::c_int;
506}
507extern "C" {
508 pub fn bcopy(
509 __src: *const ::std::os::raw::c_void,
510 __dest: *mut ::std::os::raw::c_void,
511 __n: usize,
512 );
513}
514extern "C" {
515 pub fn bzero(__s: *mut ::std::os::raw::c_void, __n: ::std::os::raw::c_ulong);
516}
517extern "C" {
518 pub fn index(
519 __s: *const ::std::os::raw::c_char,
520 __c: ::std::os::raw::c_int,
521 ) -> *mut ::std::os::raw::c_char;
522}
523extern "C" {
524 pub fn rindex(
525 __s: *const ::std::os::raw::c_char,
526 __c: ::std::os::raw::c_int,
527 ) -> *mut ::std::os::raw::c_char;
528}
529extern "C" {
530 pub fn ffs(__i: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
531}
532extern "C" {
533 pub fn ffsl(__l: ::std::os::raw::c_long) -> ::std::os::raw::c_int;
534}
535extern "C" {
536 pub fn ffsll(__ll: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int;
537}
538extern "C" {
539 pub fn strcasecmp(
540 __s1: *const ::std::os::raw::c_char,
541 __s2: *const ::std::os::raw::c_char,
542 ) -> ::std::os::raw::c_int;
543}
544extern "C" {
545 pub fn strncasecmp(
546 __s1: *const ::std::os::raw::c_char,
547 __s2: *const ::std::os::raw::c_char,
548 __n: ::std::os::raw::c_ulong,
549 ) -> ::std::os::raw::c_int;
550}
551extern "C" {
552 pub fn strcasecmp_l(
553 __s1: *const ::std::os::raw::c_char,
554 __s2: *const ::std::os::raw::c_char,
555 __loc: locale_t,
556 ) -> ::std::os::raw::c_int;
557}
558extern "C" {
559 pub fn strncasecmp_l(
560 __s1: *const ::std::os::raw::c_char,
561 __s2: *const ::std::os::raw::c_char,
562 __n: usize,
563 __loc: locale_t,
564 ) -> ::std::os::raw::c_int;
565}
566extern "C" {
567 pub fn explicit_bzero(__s: *mut ::std::os::raw::c_void, __n: usize);
568}
569extern "C" {
570 pub fn strsep(
571 __stringp: *mut *mut ::std::os::raw::c_char,
572 __delim: *const ::std::os::raw::c_char,
573 ) -> *mut ::std::os::raw::c_char;
574}
575extern "C" {
576 pub fn strsignal(__sig: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
577}
578extern "C" {
579 pub fn __stpcpy(
580 __dest: *mut ::std::os::raw::c_char,
581 __src: *const ::std::os::raw::c_char,
582 ) -> *mut ::std::os::raw::c_char;
583}
584extern "C" {
585 pub fn stpcpy(
586 __dest: *mut ::std::os::raw::c_char,
587 __src: *const ::std::os::raw::c_char,
588 ) -> *mut ::std::os::raw::c_char;
589}
590extern "C" {
591 pub fn __stpncpy(
592 __dest: *mut ::std::os::raw::c_char,
593 __src: *const ::std::os::raw::c_char,
594 __n: usize,
595 ) -> *mut ::std::os::raw::c_char;
596}
597extern "C" {
598 pub fn stpncpy(
599 __dest: *mut ::std::os::raw::c_char,
600 __src: *const ::std::os::raw::c_char,
601 __n: ::std::os::raw::c_ulong,
602 ) -> *mut ::std::os::raw::c_char;
603}
604pub type cst_string = ::std::os::raw::c_char;
605extern "C" {
606 pub fn cst_atof(str_: *const ::std::os::raw::c_char) -> f64;
607}
608extern "C" {
609 pub fn cst_strdup(s: *const cst_string) -> *mut cst_string;
610}
611extern "C" {
612 pub fn cst_strchr(s: *const cst_string, c: ::std::os::raw::c_int) -> *mut cst_string;
613}
614extern "C" {
615 pub fn cst_strrchr(str_: *const cst_string, c: ::std::os::raw::c_int) -> *mut cst_string;
616}
617extern "C" {
618 pub fn cst_member_string(
619 str_: *const ::std::os::raw::c_char,
620 slist: *const *const ::std::os::raw::c_char,
621 ) -> ::std::os::raw::c_int;
622}
623extern "C" {
624 pub fn cst_substr(
625 str_: *const ::std::os::raw::c_char,
626 start: ::std::os::raw::c_int,
627 length: ::std::os::raw::c_int,
628 ) -> *mut ::std::os::raw::c_char;
629}
630extern "C" {
631 pub fn cst_string_before(
632 s: *const ::std::os::raw::c_char,
633 c: *const ::std::os::raw::c_char,
634 ) -> *mut ::std::os::raw::c_char;
635}
636extern "C" {
637 pub fn cst_strcat(
638 a: *const ::std::os::raw::c_char,
639 b: *const ::std::os::raw::c_char,
640 ) -> *mut ::std::os::raw::c_char;
641}
642extern "C" {
643 pub fn cst_strcat3(
644 a: *const ::std::os::raw::c_char,
645 b: *const ::std::os::raw::c_char,
646 c: *const ::std::os::raw::c_char,
647 ) -> *mut ::std::os::raw::c_char;
648}
649extern "C" {
650 pub fn cst_downcase(str_: *const cst_string) -> *mut cst_string;
651}
652extern "C" {
653 pub fn cst_upcase(str_: *const cst_string) -> *mut cst_string;
654}
655pub type va_list = __builtin_va_list;
656pub type __gnuc_va_list = __builtin_va_list;
657pub type __u_char = ::std::os::raw::c_uchar;
658pub type __u_short = ::std::os::raw::c_ushort;
659pub type __u_int = ::std::os::raw::c_uint;
660pub type __u_long = ::std::os::raw::c_ulong;
661pub type __int8_t = ::std::os::raw::c_schar;
662pub type __uint8_t = ::std::os::raw::c_uchar;
663pub type __int16_t = ::std::os::raw::c_short;
664pub type __uint16_t = ::std::os::raw::c_ushort;
665pub type __int32_t = ::std::os::raw::c_int;
666pub type __uint32_t = ::std::os::raw::c_uint;
667pub type __int64_t = ::std::os::raw::c_long;
668pub type __uint64_t = ::std::os::raw::c_ulong;
669pub type __int_least8_t = __int8_t;
670pub type __uint_least8_t = __uint8_t;
671pub type __int_least16_t = __int16_t;
672pub type __uint_least16_t = __uint16_t;
673pub type __int_least32_t = __int32_t;
674pub type __uint_least32_t = __uint32_t;
675pub type __int_least64_t = __int64_t;
676pub type __uint_least64_t = __uint64_t;
677pub type __quad_t = ::std::os::raw::c_long;
678pub type __u_quad_t = ::std::os::raw::c_ulong;
679pub type __intmax_t = ::std::os::raw::c_long;
680pub type __uintmax_t = ::std::os::raw::c_ulong;
681pub type __dev_t = ::std::os::raw::c_ulong;
682pub type __uid_t = ::std::os::raw::c_uint;
683pub type __gid_t = ::std::os::raw::c_uint;
684pub type __ino_t = ::std::os::raw::c_ulong;
685pub type __ino64_t = ::std::os::raw::c_ulong;
686pub type __mode_t = ::std::os::raw::c_uint;
687pub type __nlink_t = ::std::os::raw::c_ulong;
688pub type __off_t = ::std::os::raw::c_long;
689pub type __off64_t = ::std::os::raw::c_long;
690pub type __pid_t = ::std::os::raw::c_int;
691#[repr(C)]
692#[derive(Debug, Copy, Clone)]
693pub struct __fsid_t {
694 pub __val: [::std::os::raw::c_int; 2usize],
695}
696#[test]
697fn bindgen_test_layout___fsid_t() {
698 const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
699 let ptr = UNINIT.as_ptr();
700 assert_eq!(
701 ::std::mem::size_of::<__fsid_t>(),
702 8usize,
703 concat!("Size of: ", stringify!(__fsid_t))
704 );
705 assert_eq!(
706 ::std::mem::align_of::<__fsid_t>(),
707 4usize,
708 concat!("Alignment of ", stringify!(__fsid_t))
709 );
710 assert_eq!(
711 unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
712 0usize,
713 concat!(
714 "Offset of field: ",
715 stringify!(__fsid_t),
716 "::",
717 stringify!(__val)
718 )
719 );
720}
721pub type __clock_t = ::std::os::raw::c_long;
722pub type __rlim_t = ::std::os::raw::c_ulong;
723pub type __rlim64_t = ::std::os::raw::c_ulong;
724pub type __id_t = ::std::os::raw::c_uint;
725pub type __time_t = ::std::os::raw::c_long;
726pub type __useconds_t = ::std::os::raw::c_uint;
727pub type __suseconds_t = ::std::os::raw::c_long;
728pub type __suseconds64_t = ::std::os::raw::c_long;
729pub type __daddr_t = ::std::os::raw::c_int;
730pub type __key_t = ::std::os::raw::c_int;
731pub type __clockid_t = ::std::os::raw::c_int;
732pub type __timer_t = *mut ::std::os::raw::c_void;
733pub type __blksize_t = ::std::os::raw::c_long;
734pub type __blkcnt_t = ::std::os::raw::c_long;
735pub type __blkcnt64_t = ::std::os::raw::c_long;
736pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
737pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
738pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
739pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
740pub type __fsword_t = ::std::os::raw::c_long;
741pub type __ssize_t = ::std::os::raw::c_long;
742pub type __syscall_slong_t = ::std::os::raw::c_long;
743pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
744pub type __loff_t = __off64_t;
745pub type __caddr_t = *mut ::std::os::raw::c_char;
746pub type __intptr_t = ::std::os::raw::c_long;
747pub type __socklen_t = ::std::os::raw::c_uint;
748pub type __sig_atomic_t = ::std::os::raw::c_int;
749#[repr(C)]
750#[derive(Copy, Clone)]
751pub struct __mbstate_t {
752 pub __count: ::std::os::raw::c_int,
753 pub __value: __mbstate_t__bindgen_ty_1,
754}
755#[repr(C)]
756#[derive(Copy, Clone)]
757pub union __mbstate_t__bindgen_ty_1 {
758 pub __wch: ::std::os::raw::c_uint,
759 pub __wchb: [::std::os::raw::c_char; 4usize],
760}
761#[test]
762fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
763 const UNINIT: ::std::mem::MaybeUninit<__mbstate_t__bindgen_ty_1> =
764 ::std::mem::MaybeUninit::uninit();
765 let ptr = UNINIT.as_ptr();
766 assert_eq!(
767 ::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
768 4usize,
769 concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
770 );
771 assert_eq!(
772 ::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
773 4usize,
774 concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
775 );
776 assert_eq!(
777 unsafe { ::std::ptr::addr_of!((*ptr).__wch) as usize - ptr as usize },
778 0usize,
779 concat!(
780 "Offset of field: ",
781 stringify!(__mbstate_t__bindgen_ty_1),
782 "::",
783 stringify!(__wch)
784 )
785 );
786 assert_eq!(
787 unsafe { ::std::ptr::addr_of!((*ptr).__wchb) as usize - ptr as usize },
788 0usize,
789 concat!(
790 "Offset of field: ",
791 stringify!(__mbstate_t__bindgen_ty_1),
792 "::",
793 stringify!(__wchb)
794 )
795 );
796}
797#[test]
798fn bindgen_test_layout___mbstate_t() {
799 const UNINIT: ::std::mem::MaybeUninit<__mbstate_t> = ::std::mem::MaybeUninit::uninit();
800 let ptr = UNINIT.as_ptr();
801 assert_eq!(
802 ::std::mem::size_of::<__mbstate_t>(),
803 8usize,
804 concat!("Size of: ", stringify!(__mbstate_t))
805 );
806 assert_eq!(
807 ::std::mem::align_of::<__mbstate_t>(),
808 4usize,
809 concat!("Alignment of ", stringify!(__mbstate_t))
810 );
811 assert_eq!(
812 unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
813 0usize,
814 concat!(
815 "Offset of field: ",
816 stringify!(__mbstate_t),
817 "::",
818 stringify!(__count)
819 )
820 );
821 assert_eq!(
822 unsafe { ::std::ptr::addr_of!((*ptr).__value) as usize - ptr as usize },
823 4usize,
824 concat!(
825 "Offset of field: ",
826 stringify!(__mbstate_t),
827 "::",
828 stringify!(__value)
829 )
830 );
831}
832#[repr(C)]
833#[derive(Copy, Clone)]
834pub struct _G_fpos_t {
835 pub __pos: __off_t,
836 pub __state: __mbstate_t,
837}
838#[test]
839fn bindgen_test_layout__G_fpos_t() {
840 const UNINIT: ::std::mem::MaybeUninit<_G_fpos_t> = ::std::mem::MaybeUninit::uninit();
841 let ptr = UNINIT.as_ptr();
842 assert_eq!(
843 ::std::mem::size_of::<_G_fpos_t>(),
844 16usize,
845 concat!("Size of: ", stringify!(_G_fpos_t))
846 );
847 assert_eq!(
848 ::std::mem::align_of::<_G_fpos_t>(),
849 8usize,
850 concat!("Alignment of ", stringify!(_G_fpos_t))
851 );
852 assert_eq!(
853 unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
854 0usize,
855 concat!(
856 "Offset of field: ",
857 stringify!(_G_fpos_t),
858 "::",
859 stringify!(__pos)
860 )
861 );
862 assert_eq!(
863 unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
864 8usize,
865 concat!(
866 "Offset of field: ",
867 stringify!(_G_fpos_t),
868 "::",
869 stringify!(__state)
870 )
871 );
872}
873pub type __fpos_t = _G_fpos_t;
874#[repr(C)]
875#[derive(Copy, Clone)]
876pub struct _G_fpos64_t {
877 pub __pos: __off64_t,
878 pub __state: __mbstate_t,
879}
880#[test]
881fn bindgen_test_layout__G_fpos64_t() {
882 const UNINIT: ::std::mem::MaybeUninit<_G_fpos64_t> = ::std::mem::MaybeUninit::uninit();
883 let ptr = UNINIT.as_ptr();
884 assert_eq!(
885 ::std::mem::size_of::<_G_fpos64_t>(),
886 16usize,
887 concat!("Size of: ", stringify!(_G_fpos64_t))
888 );
889 assert_eq!(
890 ::std::mem::align_of::<_G_fpos64_t>(),
891 8usize,
892 concat!("Alignment of ", stringify!(_G_fpos64_t))
893 );
894 assert_eq!(
895 unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
896 0usize,
897 concat!(
898 "Offset of field: ",
899 stringify!(_G_fpos64_t),
900 "::",
901 stringify!(__pos)
902 )
903 );
904 assert_eq!(
905 unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
906 8usize,
907 concat!(
908 "Offset of field: ",
909 stringify!(_G_fpos64_t),
910 "::",
911 stringify!(__state)
912 )
913 );
914}
915pub type __fpos64_t = _G_fpos64_t;
916pub type __FILE = _IO_FILE;
917pub type FILE = _IO_FILE;
918#[repr(C)]
919#[derive(Debug, Copy, Clone)]
920pub struct _IO_marker {
921 _unused: [u8; 0],
922}
923#[repr(C)]
924#[derive(Debug, Copy, Clone)]
925pub struct _IO_codecvt {
926 _unused: [u8; 0],
927}
928#[repr(C)]
929#[derive(Debug, Copy, Clone)]
930pub struct _IO_wide_data {
931 _unused: [u8; 0],
932}
933pub type _IO_lock_t = ::std::os::raw::c_void;
934#[repr(C)]
935#[derive(Debug, Copy, Clone)]
936pub struct _IO_FILE {
937 pub _flags: ::std::os::raw::c_int,
938 pub _IO_read_ptr: *mut ::std::os::raw::c_char,
939 pub _IO_read_end: *mut ::std::os::raw::c_char,
940 pub _IO_read_base: *mut ::std::os::raw::c_char,
941 pub _IO_write_base: *mut ::std::os::raw::c_char,
942 pub _IO_write_ptr: *mut ::std::os::raw::c_char,
943 pub _IO_write_end: *mut ::std::os::raw::c_char,
944 pub _IO_buf_base: *mut ::std::os::raw::c_char,
945 pub _IO_buf_end: *mut ::std::os::raw::c_char,
946 pub _IO_save_base: *mut ::std::os::raw::c_char,
947 pub _IO_backup_base: *mut ::std::os::raw::c_char,
948 pub _IO_save_end: *mut ::std::os::raw::c_char,
949 pub _markers: *mut _IO_marker,
950 pub _chain: *mut _IO_FILE,
951 pub _fileno: ::std::os::raw::c_int,
952 pub _flags2: ::std::os::raw::c_int,
953 pub _old_offset: __off_t,
954 pub _cur_column: ::std::os::raw::c_ushort,
955 pub _vtable_offset: ::std::os::raw::c_schar,
956 pub _shortbuf: [::std::os::raw::c_char; 1usize],
957 pub _lock: *mut _IO_lock_t,
958 pub _offset: __off64_t,
959 pub _codecvt: *mut _IO_codecvt,
960 pub _wide_data: *mut _IO_wide_data,
961 pub _freeres_list: *mut _IO_FILE,
962 pub _freeres_buf: *mut ::std::os::raw::c_void,
963 pub __pad5: usize,
964 pub _mode: ::std::os::raw::c_int,
965 pub _unused2: [::std::os::raw::c_char; 20usize],
966}
967#[test]
968fn bindgen_test_layout__IO_FILE() {
969 const UNINIT: ::std::mem::MaybeUninit<_IO_FILE> = ::std::mem::MaybeUninit::uninit();
970 let ptr = UNINIT.as_ptr();
971 assert_eq!(
972 ::std::mem::size_of::<_IO_FILE>(),
973 216usize,
974 concat!("Size of: ", stringify!(_IO_FILE))
975 );
976 assert_eq!(
977 ::std::mem::align_of::<_IO_FILE>(),
978 8usize,
979 concat!("Alignment of ", stringify!(_IO_FILE))
980 );
981 assert_eq!(
982 unsafe { ::std::ptr::addr_of!((*ptr)._flags) as usize - ptr as usize },
983 0usize,
984 concat!(
985 "Offset of field: ",
986 stringify!(_IO_FILE),
987 "::",
988 stringify!(_flags)
989 )
990 );
991 assert_eq!(
992 unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_ptr) as usize - ptr as usize },
993 8usize,
994 concat!(
995 "Offset of field: ",
996 stringify!(_IO_FILE),
997 "::",
998 stringify!(_IO_read_ptr)
999 )
1000 );
1001 assert_eq!(
1002 unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_end) as usize - ptr as usize },
1003 16usize,
1004 concat!(
1005 "Offset of field: ",
1006 stringify!(_IO_FILE),
1007 "::",
1008 stringify!(_IO_read_end)
1009 )
1010 );
1011 assert_eq!(
1012 unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_base) as usize - ptr as usize },
1013 24usize,
1014 concat!(
1015 "Offset of field: ",
1016 stringify!(_IO_FILE),
1017 "::",
1018 stringify!(_IO_read_base)
1019 )
1020 );
1021 assert_eq!(
1022 unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_base) as usize - ptr as usize },
1023 32usize,
1024 concat!(
1025 "Offset of field: ",
1026 stringify!(_IO_FILE),
1027 "::",
1028 stringify!(_IO_write_base)
1029 )
1030 );
1031 assert_eq!(
1032 unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_ptr) as usize - ptr as usize },
1033 40usize,
1034 concat!(
1035 "Offset of field: ",
1036 stringify!(_IO_FILE),
1037 "::",
1038 stringify!(_IO_write_ptr)
1039 )
1040 );
1041 assert_eq!(
1042 unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_end) as usize - ptr as usize },
1043 48usize,
1044 concat!(
1045 "Offset of field: ",
1046 stringify!(_IO_FILE),
1047 "::",
1048 stringify!(_IO_write_end)
1049 )
1050 );
1051 assert_eq!(
1052 unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_base) as usize - ptr as usize },
1053 56usize,
1054 concat!(
1055 "Offset of field: ",
1056 stringify!(_IO_FILE),
1057 "::",
1058 stringify!(_IO_buf_base)
1059 )
1060 );
1061 assert_eq!(
1062 unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_end) as usize - ptr as usize },
1063 64usize,
1064 concat!(
1065 "Offset of field: ",
1066 stringify!(_IO_FILE),
1067 "::",
1068 stringify!(_IO_buf_end)
1069 )
1070 );
1071 assert_eq!(
1072 unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_base) as usize - ptr as usize },
1073 72usize,
1074 concat!(
1075 "Offset of field: ",
1076 stringify!(_IO_FILE),
1077 "::",
1078 stringify!(_IO_save_base)
1079 )
1080 );
1081 assert_eq!(
1082 unsafe { ::std::ptr::addr_of!((*ptr)._IO_backup_base) as usize - ptr as usize },
1083 80usize,
1084 concat!(
1085 "Offset of field: ",
1086 stringify!(_IO_FILE),
1087 "::",
1088 stringify!(_IO_backup_base)
1089 )
1090 );
1091 assert_eq!(
1092 unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_end) as usize - ptr as usize },
1093 88usize,
1094 concat!(
1095 "Offset of field: ",
1096 stringify!(_IO_FILE),
1097 "::",
1098 stringify!(_IO_save_end)
1099 )
1100 );
1101 assert_eq!(
1102 unsafe { ::std::ptr::addr_of!((*ptr)._markers) as usize - ptr as usize },
1103 96usize,
1104 concat!(
1105 "Offset of field: ",
1106 stringify!(_IO_FILE),
1107 "::",
1108 stringify!(_markers)
1109 )
1110 );
1111 assert_eq!(
1112 unsafe { ::std::ptr::addr_of!((*ptr)._chain) as usize - ptr as usize },
1113 104usize,
1114 concat!(
1115 "Offset of field: ",
1116 stringify!(_IO_FILE),
1117 "::",
1118 stringify!(_chain)
1119 )
1120 );
1121 assert_eq!(
1122 unsafe { ::std::ptr::addr_of!((*ptr)._fileno) as usize - ptr as usize },
1123 112usize,
1124 concat!(
1125 "Offset of field: ",
1126 stringify!(_IO_FILE),
1127 "::",
1128 stringify!(_fileno)
1129 )
1130 );
1131 assert_eq!(
1132 unsafe { ::std::ptr::addr_of!((*ptr)._flags2) as usize - ptr as usize },
1133 116usize,
1134 concat!(
1135 "Offset of field: ",
1136 stringify!(_IO_FILE),
1137 "::",
1138 stringify!(_flags2)
1139 )
1140 );
1141 assert_eq!(
1142 unsafe { ::std::ptr::addr_of!((*ptr)._old_offset) as usize - ptr as usize },
1143 120usize,
1144 concat!(
1145 "Offset of field: ",
1146 stringify!(_IO_FILE),
1147 "::",
1148 stringify!(_old_offset)
1149 )
1150 );
1151 assert_eq!(
1152 unsafe { ::std::ptr::addr_of!((*ptr)._cur_column) as usize - ptr as usize },
1153 128usize,
1154 concat!(
1155 "Offset of field: ",
1156 stringify!(_IO_FILE),
1157 "::",
1158 stringify!(_cur_column)
1159 )
1160 );
1161 assert_eq!(
1162 unsafe { ::std::ptr::addr_of!((*ptr)._vtable_offset) as usize - ptr as usize },
1163 130usize,
1164 concat!(
1165 "Offset of field: ",
1166 stringify!(_IO_FILE),
1167 "::",
1168 stringify!(_vtable_offset)
1169 )
1170 );
1171 assert_eq!(
1172 unsafe { ::std::ptr::addr_of!((*ptr)._shortbuf) as usize - ptr as usize },
1173 131usize,
1174 concat!(
1175 "Offset of field: ",
1176 stringify!(_IO_FILE),
1177 "::",
1178 stringify!(_shortbuf)
1179 )
1180 );
1181 assert_eq!(
1182 unsafe { ::std::ptr::addr_of!((*ptr)._lock) as usize - ptr as usize },
1183 136usize,
1184 concat!(
1185 "Offset of field: ",
1186 stringify!(_IO_FILE),
1187 "::",
1188 stringify!(_lock)
1189 )
1190 );
1191 assert_eq!(
1192 unsafe { ::std::ptr::addr_of!((*ptr)._offset) as usize - ptr as usize },
1193 144usize,
1194 concat!(
1195 "Offset of field: ",
1196 stringify!(_IO_FILE),
1197 "::",
1198 stringify!(_offset)
1199 )
1200 );
1201 assert_eq!(
1202 unsafe { ::std::ptr::addr_of!((*ptr)._codecvt) as usize - ptr as usize },
1203 152usize,
1204 concat!(
1205 "Offset of field: ",
1206 stringify!(_IO_FILE),
1207 "::",
1208 stringify!(_codecvt)
1209 )
1210 );
1211 assert_eq!(
1212 unsafe { ::std::ptr::addr_of!((*ptr)._wide_data) as usize - ptr as usize },
1213 160usize,
1214 concat!(
1215 "Offset of field: ",
1216 stringify!(_IO_FILE),
1217 "::",
1218 stringify!(_wide_data)
1219 )
1220 );
1221 assert_eq!(
1222 unsafe { ::std::ptr::addr_of!((*ptr)._freeres_list) as usize - ptr as usize },
1223 168usize,
1224 concat!(
1225 "Offset of field: ",
1226 stringify!(_IO_FILE),
1227 "::",
1228 stringify!(_freeres_list)
1229 )
1230 );
1231 assert_eq!(
1232 unsafe { ::std::ptr::addr_of!((*ptr)._freeres_buf) as usize - ptr as usize },
1233 176usize,
1234 concat!(
1235 "Offset of field: ",
1236 stringify!(_IO_FILE),
1237 "::",
1238 stringify!(_freeres_buf)
1239 )
1240 );
1241 assert_eq!(
1242 unsafe { ::std::ptr::addr_of!((*ptr).__pad5) as usize - ptr as usize },
1243 184usize,
1244 concat!(
1245 "Offset of field: ",
1246 stringify!(_IO_FILE),
1247 "::",
1248 stringify!(__pad5)
1249 )
1250 );
1251 assert_eq!(
1252 unsafe { ::std::ptr::addr_of!((*ptr)._mode) as usize - ptr as usize },
1253 192usize,
1254 concat!(
1255 "Offset of field: ",
1256 stringify!(_IO_FILE),
1257 "::",
1258 stringify!(_mode)
1259 )
1260 );
1261 assert_eq!(
1262 unsafe { ::std::ptr::addr_of!((*ptr)._unused2) as usize - ptr as usize },
1263 196usize,
1264 concat!(
1265 "Offset of field: ",
1266 stringify!(_IO_FILE),
1267 "::",
1268 stringify!(_unused2)
1269 )
1270 );
1271}
1272pub type off_t = __off_t;
1273pub type fpos_t = __fpos_t;
1274extern "C" {
1275 pub static mut stdin: *mut FILE;
1276}
1277extern "C" {
1278 pub static mut stdout: *mut FILE;
1279}
1280extern "C" {
1281 pub static mut stderr: *mut FILE;
1282}
1283extern "C" {
1284 pub fn remove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1285}
1286extern "C" {
1287 pub fn rename(
1288 __old: *const ::std::os::raw::c_char,
1289 __new: *const ::std::os::raw::c_char,
1290 ) -> ::std::os::raw::c_int;
1291}
1292extern "C" {
1293 pub fn renameat(
1294 __oldfd: ::std::os::raw::c_int,
1295 __old: *const ::std::os::raw::c_char,
1296 __newfd: ::std::os::raw::c_int,
1297 __new: *const ::std::os::raw::c_char,
1298 ) -> ::std::os::raw::c_int;
1299}
1300extern "C" {
1301 pub fn fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
1302}
1303extern "C" {
1304 pub fn tmpfile() -> *mut FILE;
1305}
1306extern "C" {
1307 pub fn tmpnam(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1308}
1309extern "C" {
1310 pub fn tmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1311}
1312extern "C" {
1313 pub fn tempnam(
1314 __dir: *const ::std::os::raw::c_char,
1315 __pfx: *const ::std::os::raw::c_char,
1316 ) -> *mut ::std::os::raw::c_char;
1317}
1318extern "C" {
1319 pub fn fflush(__stream: *mut FILE) -> ::std::os::raw::c_int;
1320}
1321extern "C" {
1322 pub fn fflush_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
1323}
1324extern "C" {
1325 pub fn fopen(
1326 __filename: *const ::std::os::raw::c_char,
1327 __modes: *const ::std::os::raw::c_char,
1328 ) -> *mut FILE;
1329}
1330extern "C" {
1331 pub fn freopen(
1332 __filename: *const ::std::os::raw::c_char,
1333 __modes: *const ::std::os::raw::c_char,
1334 __stream: *mut FILE,
1335 ) -> *mut FILE;
1336}
1337extern "C" {
1338 pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
1339 -> *mut FILE;
1340}
1341extern "C" {
1342 pub fn fmemopen(
1343 __s: *mut ::std::os::raw::c_void,
1344 __len: usize,
1345 __modes: *const ::std::os::raw::c_char,
1346 ) -> *mut FILE;
1347}
1348extern "C" {
1349 pub fn open_memstream(
1350 __bufloc: *mut *mut ::std::os::raw::c_char,
1351 __sizeloc: *mut usize,
1352 ) -> *mut FILE;
1353}
1354extern "C" {
1355 pub fn setbuf(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char);
1356}
1357extern "C" {
1358 pub fn setvbuf(
1359 __stream: *mut FILE,
1360 __buf: *mut ::std::os::raw::c_char,
1361 __modes: ::std::os::raw::c_int,
1362 __n: usize,
1363 ) -> ::std::os::raw::c_int;
1364}
1365extern "C" {
1366 pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: usize);
1367}
1368extern "C" {
1369 pub fn setlinebuf(__stream: *mut FILE);
1370}
1371extern "C" {
1372 pub fn fprintf(
1373 __stream: *mut FILE,
1374 __format: *const ::std::os::raw::c_char,
1375 ...
1376 ) -> ::std::os::raw::c_int;
1377}
1378extern "C" {
1379 pub fn printf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
1380}
1381extern "C" {
1382 pub fn sprintf(
1383 __s: *mut ::std::os::raw::c_char,
1384 __format: *const ::std::os::raw::c_char,
1385 ...
1386 ) -> ::std::os::raw::c_int;
1387}
1388extern "C" {
1389 pub fn vfprintf(
1390 __s: *mut FILE,
1391 __format: *const ::std::os::raw::c_char,
1392 __arg: *mut __va_list_tag,
1393 ) -> ::std::os::raw::c_int;
1394}
1395extern "C" {
1396 pub fn vprintf(
1397 __format: *const ::std::os::raw::c_char,
1398 __arg: *mut __va_list_tag,
1399 ) -> ::std::os::raw::c_int;
1400}
1401extern "C" {
1402 pub fn vsprintf(
1403 __s: *mut ::std::os::raw::c_char,
1404 __format: *const ::std::os::raw::c_char,
1405 __arg: *mut __va_list_tag,
1406 ) -> ::std::os::raw::c_int;
1407}
1408extern "C" {
1409 pub fn snprintf(
1410 __s: *mut ::std::os::raw::c_char,
1411 __maxlen: ::std::os::raw::c_ulong,
1412 __format: *const ::std::os::raw::c_char,
1413 ...
1414 ) -> ::std::os::raw::c_int;
1415}
1416extern "C" {
1417 pub fn vsnprintf(
1418 __s: *mut ::std::os::raw::c_char,
1419 __maxlen: ::std::os::raw::c_ulong,
1420 __format: *const ::std::os::raw::c_char,
1421 __arg: *mut __va_list_tag,
1422 ) -> ::std::os::raw::c_int;
1423}
1424extern "C" {
1425 pub fn vdprintf(
1426 __fd: ::std::os::raw::c_int,
1427 __fmt: *const ::std::os::raw::c_char,
1428 __arg: *mut __va_list_tag,
1429 ) -> ::std::os::raw::c_int;
1430}
1431extern "C" {
1432 pub fn dprintf(
1433 __fd: ::std::os::raw::c_int,
1434 __fmt: *const ::std::os::raw::c_char,
1435 ...
1436 ) -> ::std::os::raw::c_int;
1437}
1438extern "C" {
1439 pub fn fscanf(
1440 __stream: *mut FILE,
1441 __format: *const ::std::os::raw::c_char,
1442 ...
1443 ) -> ::std::os::raw::c_int;
1444}
1445extern "C" {
1446 pub fn scanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
1447}
1448extern "C" {
1449 pub fn sscanf(
1450 __s: *const ::std::os::raw::c_char,
1451 __format: *const ::std::os::raw::c_char,
1452 ...
1453 ) -> ::std::os::raw::c_int;
1454}
1455pub type _Float32 = f32;
1456pub type _Float64 = f64;
1457pub type _Float32x = f64;
1458pub type _Float64x = u128;
1459extern "C" {
1460 #[link_name = "\u{1}__isoc99_fscanf"]
1461 pub fn fscanf1(
1462 __stream: *mut FILE,
1463 __format: *const ::std::os::raw::c_char,
1464 ...
1465 ) -> ::std::os::raw::c_int;
1466}
1467extern "C" {
1468 #[link_name = "\u{1}__isoc99_scanf"]
1469 pub fn scanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
1470}
1471extern "C" {
1472 #[link_name = "\u{1}__isoc99_sscanf"]
1473 pub fn sscanf1(
1474 __s: *const ::std::os::raw::c_char,
1475 __format: *const ::std::os::raw::c_char,
1476 ...
1477 ) -> ::std::os::raw::c_int;
1478}
1479extern "C" {
1480 pub fn vfscanf(
1481 __s: *mut FILE,
1482 __format: *const ::std::os::raw::c_char,
1483 __arg: *mut __va_list_tag,
1484 ) -> ::std::os::raw::c_int;
1485}
1486extern "C" {
1487 pub fn vscanf(
1488 __format: *const ::std::os::raw::c_char,
1489 __arg: *mut __va_list_tag,
1490 ) -> ::std::os::raw::c_int;
1491}
1492extern "C" {
1493 pub fn vsscanf(
1494 __s: *const ::std::os::raw::c_char,
1495 __format: *const ::std::os::raw::c_char,
1496 __arg: *mut __va_list_tag,
1497 ) -> ::std::os::raw::c_int;
1498}
1499extern "C" {
1500 #[link_name = "\u{1}__isoc99_vfscanf"]
1501 pub fn vfscanf1(
1502 __s: *mut FILE,
1503 __format: *const ::std::os::raw::c_char,
1504 __arg: *mut __va_list_tag,
1505 ) -> ::std::os::raw::c_int;
1506}
1507extern "C" {
1508 #[link_name = "\u{1}__isoc99_vscanf"]
1509 pub fn vscanf1(
1510 __format: *const ::std::os::raw::c_char,
1511 __arg: *mut __va_list_tag,
1512 ) -> ::std::os::raw::c_int;
1513}
1514extern "C" {
1515 #[link_name = "\u{1}__isoc99_vsscanf"]
1516 pub fn vsscanf1(
1517 __s: *const ::std::os::raw::c_char,
1518 __format: *const ::std::os::raw::c_char,
1519 __arg: *mut __va_list_tag,
1520 ) -> ::std::os::raw::c_int;
1521}
1522extern "C" {
1523 pub fn fgetc(__stream: *mut FILE) -> ::std::os::raw::c_int;
1524}
1525extern "C" {
1526 pub fn getc(__stream: *mut FILE) -> ::std::os::raw::c_int;
1527}
1528extern "C" {
1529 pub fn getchar() -> ::std::os::raw::c_int;
1530}
1531extern "C" {
1532 pub fn getc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
1533}
1534extern "C" {
1535 pub fn getchar_unlocked() -> ::std::os::raw::c_int;
1536}
1537extern "C" {
1538 pub fn fgetc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
1539}
1540extern "C" {
1541 pub fn fputc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
1542}
1543extern "C" {
1544 pub fn putc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
1545}
1546extern "C" {
1547 pub fn putchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1548}
1549extern "C" {
1550 pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE)
1551 -> ::std::os::raw::c_int;
1552}
1553extern "C" {
1554 pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
1555}
1556extern "C" {
1557 pub fn putchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1558}
1559extern "C" {
1560 pub fn getw(__stream: *mut FILE) -> ::std::os::raw::c_int;
1561}
1562extern "C" {
1563 pub fn putw(__w: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
1564}
1565extern "C" {
1566 pub fn fgets(
1567 __s: *mut ::std::os::raw::c_char,
1568 __n: ::std::os::raw::c_int,
1569 __stream: *mut FILE,
1570 ) -> *mut ::std::os::raw::c_char;
1571}
1572extern "C" {
1573 pub fn __getdelim(
1574 __lineptr: *mut *mut ::std::os::raw::c_char,
1575 __n: *mut usize,
1576 __delimiter: ::std::os::raw::c_int,
1577 __stream: *mut FILE,
1578 ) -> __ssize_t;
1579}
1580extern "C" {
1581 pub fn getdelim(
1582 __lineptr: *mut *mut ::std::os::raw::c_char,
1583 __n: *mut usize,
1584 __delimiter: ::std::os::raw::c_int,
1585 __stream: *mut FILE,
1586 ) -> __ssize_t;
1587}
1588extern "C" {
1589 pub fn getline(
1590 __lineptr: *mut *mut ::std::os::raw::c_char,
1591 __n: *mut usize,
1592 __stream: *mut FILE,
1593 ) -> __ssize_t;
1594}
1595extern "C" {
1596 pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
1597}
1598extern "C" {
1599 pub fn puts(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1600}
1601extern "C" {
1602 pub fn ungetc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
1603}
1604extern "C" {
1605 pub fn fread(
1606 __ptr: *mut ::std::os::raw::c_void,
1607 __size: ::std::os::raw::c_ulong,
1608 __n: ::std::os::raw::c_ulong,
1609 __stream: *mut FILE,
1610 ) -> ::std::os::raw::c_ulong;
1611}
1612extern "C" {
1613 pub fn fwrite(
1614 __ptr: *const ::std::os::raw::c_void,
1615 __size: ::std::os::raw::c_ulong,
1616 __n: ::std::os::raw::c_ulong,
1617 __s: *mut FILE,
1618 ) -> ::std::os::raw::c_ulong;
1619}
1620extern "C" {
1621 pub fn fread_unlocked(
1622 __ptr: *mut ::std::os::raw::c_void,
1623 __size: usize,
1624 __n: usize,
1625 __stream: *mut FILE,
1626 ) -> usize;
1627}
1628extern "C" {
1629 pub fn fwrite_unlocked(
1630 __ptr: *const ::std::os::raw::c_void,
1631 __size: usize,
1632 __n: usize,
1633 __stream: *mut FILE,
1634 ) -> usize;
1635}
1636extern "C" {
1637 pub fn fseek(
1638 __stream: *mut FILE,
1639 __off: ::std::os::raw::c_long,
1640 __whence: ::std::os::raw::c_int,
1641 ) -> ::std::os::raw::c_int;
1642}
1643extern "C" {
1644 pub fn ftell(__stream: *mut FILE) -> ::std::os::raw::c_long;
1645}
1646extern "C" {
1647 pub fn rewind(__stream: *mut FILE);
1648}
1649extern "C" {
1650 pub fn fseeko(
1651 __stream: *mut FILE,
1652 __off: __off_t,
1653 __whence: ::std::os::raw::c_int,
1654 ) -> ::std::os::raw::c_int;
1655}
1656extern "C" {
1657 pub fn ftello(__stream: *mut FILE) -> __off_t;
1658}
1659extern "C" {
1660 pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int;
1661}
1662extern "C" {
1663 pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int;
1664}
1665extern "C" {
1666 pub fn clearerr(__stream: *mut FILE);
1667}
1668extern "C" {
1669 pub fn feof(__stream: *mut FILE) -> ::std::os::raw::c_int;
1670}
1671extern "C" {
1672 pub fn ferror(__stream: *mut FILE) -> ::std::os::raw::c_int;
1673}
1674extern "C" {
1675 pub fn clearerr_unlocked(__stream: *mut FILE);
1676}
1677extern "C" {
1678 pub fn feof_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
1679}
1680extern "C" {
1681 pub fn ferror_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
1682}
1683extern "C" {
1684 pub fn perror(__s: *const ::std::os::raw::c_char);
1685}
1686extern "C" {
1687 pub fn fileno(__stream: *mut FILE) -> ::std::os::raw::c_int;
1688}
1689extern "C" {
1690 pub fn fileno_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
1691}
1692extern "C" {
1693 pub fn pclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
1694}
1695extern "C" {
1696 pub fn popen(
1697 __command: *const ::std::os::raw::c_char,
1698 __modes: *const ::std::os::raw::c_char,
1699 ) -> *mut FILE;
1700}
1701extern "C" {
1702 pub fn ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1703}
1704extern "C" {
1705 pub fn flockfile(__stream: *mut FILE);
1706}
1707extern "C" {
1708 pub fn ftrylockfile(__stream: *mut FILE) -> ::std::os::raw::c_int;
1709}
1710extern "C" {
1711 pub fn funlockfile(__stream: *mut FILE);
1712}
1713extern "C" {
1714 pub fn __uflow(arg1: *mut FILE) -> ::std::os::raw::c_int;
1715}
1716extern "C" {
1717 pub fn __overflow(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1718}
1719pub type cst_file = *mut FILE;
1720#[repr(C)]
1721#[derive(Debug, Copy, Clone)]
1722pub struct cst_filemap_struct {
1723 pub mem: *mut ::std::os::raw::c_void,
1724 pub fh: cst_file,
1725 pub mapsize: usize,
1726 pub fd: ::std::os::raw::c_int,
1727}
1728#[test]
1729fn bindgen_test_layout_cst_filemap_struct() {
1730 const UNINIT: ::std::mem::MaybeUninit<cst_filemap_struct> = ::std::mem::MaybeUninit::uninit();
1731 let ptr = UNINIT.as_ptr();
1732 assert_eq!(
1733 ::std::mem::size_of::<cst_filemap_struct>(),
1734 32usize,
1735 concat!("Size of: ", stringify!(cst_filemap_struct))
1736 );
1737 assert_eq!(
1738 ::std::mem::align_of::<cst_filemap_struct>(),
1739 8usize,
1740 concat!("Alignment of ", stringify!(cst_filemap_struct))
1741 );
1742 assert_eq!(
1743 unsafe { ::std::ptr::addr_of!((*ptr).mem) as usize - ptr as usize },
1744 0usize,
1745 concat!(
1746 "Offset of field: ",
1747 stringify!(cst_filemap_struct),
1748 "::",
1749 stringify!(mem)
1750 )
1751 );
1752 assert_eq!(
1753 unsafe { ::std::ptr::addr_of!((*ptr).fh) as usize - ptr as usize },
1754 8usize,
1755 concat!(
1756 "Offset of field: ",
1757 stringify!(cst_filemap_struct),
1758 "::",
1759 stringify!(fh)
1760 )
1761 );
1762 assert_eq!(
1763 unsafe { ::std::ptr::addr_of!((*ptr).mapsize) as usize - ptr as usize },
1764 16usize,
1765 concat!(
1766 "Offset of field: ",
1767 stringify!(cst_filemap_struct),
1768 "::",
1769 stringify!(mapsize)
1770 )
1771 );
1772 assert_eq!(
1773 unsafe { ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
1774 24usize,
1775 concat!(
1776 "Offset of field: ",
1777 stringify!(cst_filemap_struct),
1778 "::",
1779 stringify!(fd)
1780 )
1781 );
1782}
1783pub type cst_filemap = cst_filemap_struct;
1784extern "C" {
1785 pub fn cst_fopen(path: *const ::std::os::raw::c_char, mode: ::std::os::raw::c_int) -> cst_file;
1786}
1787extern "C" {
1788 pub fn cst_fwrite(
1789 fh: cst_file,
1790 buf: *const ::std::os::raw::c_void,
1791 size: ::std::os::raw::c_long,
1792 count: ::std::os::raw::c_long,
1793 ) -> ::std::os::raw::c_long;
1794}
1795extern "C" {
1796 pub fn cst_fread(
1797 fh: cst_file,
1798 buf: *mut ::std::os::raw::c_void,
1799 size: ::std::os::raw::c_long,
1800 count: ::std::os::raw::c_long,
1801 ) -> ::std::os::raw::c_long;
1802}
1803extern "C" {
1804 pub fn cst_fprintf(
1805 fh: cst_file,
1806 fmt: *const ::std::os::raw::c_char,
1807 ...
1808 ) -> ::std::os::raw::c_int;
1809}
1810extern "C" {
1811 pub fn cst_sprintf(
1812 s: *mut ::std::os::raw::c_char,
1813 fmt: *const ::std::os::raw::c_char,
1814 ...
1815 ) -> ::std::os::raw::c_int;
1816}
1817extern "C" {
1818 pub fn cst_fclose(fh: cst_file) -> ::std::os::raw::c_int;
1819}
1820extern "C" {
1821 pub fn cst_fgetc(fh: cst_file) -> ::std::os::raw::c_int;
1822}
1823extern "C" {
1824 pub fn cst_ftell(fh: cst_file) -> ::std::os::raw::c_long;
1825}
1826extern "C" {
1827 pub fn cst_fseek(
1828 fh: cst_file,
1829 pos: ::std::os::raw::c_long,
1830 whence: ::std::os::raw::c_int,
1831 ) -> ::std::os::raw::c_long;
1832}
1833extern "C" {
1834 pub fn cst_filesize(fh: cst_file) -> ::std::os::raw::c_long;
1835}
1836extern "C" {
1837 pub fn cst_mmap_file(path: *const ::std::os::raw::c_char) -> *mut cst_filemap;
1838}
1839extern "C" {
1840 pub fn cst_munmap_file(map: *mut cst_filemap) -> ::std::os::raw::c_int;
1841}
1842extern "C" {
1843 pub fn cst_read_whole_file(path: *const ::std::os::raw::c_char) -> *mut cst_filemap;
1844}
1845extern "C" {
1846 pub fn cst_free_whole_file(map: *mut cst_filemap) -> ::std::os::raw::c_int;
1847}
1848extern "C" {
1849 pub fn cst_read_part_file(path: *const ::std::os::raw::c_char) -> *mut cst_filemap;
1850}
1851extern "C" {
1852 pub fn cst_free_part_file(map: *mut cst_filemap) -> ::std::os::raw::c_int;
1853}
1854extern "C" {
1855 pub fn cst_urlp(url: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1856}
1857extern "C" {
1858 pub fn cst_url_open(url: *const ::std::os::raw::c_char) -> cst_file;
1859}
1860#[repr(C)]
1861#[derive(Debug, Copy, Clone)]
1862pub struct cst_regex_struct {
1863 pub regstart: ::std::os::raw::c_char,
1864 pub reganch: ::std::os::raw::c_char,
1865 pub regmust: *mut ::std::os::raw::c_char,
1866 pub regmlen: ::std::os::raw::c_int,
1867 pub regsize: ::std::os::raw::c_int,
1868 pub program: *mut ::std::os::raw::c_char,
1869}
1870#[test]
1871fn bindgen_test_layout_cst_regex_struct() {
1872 const UNINIT: ::std::mem::MaybeUninit<cst_regex_struct> = ::std::mem::MaybeUninit::uninit();
1873 let ptr = UNINIT.as_ptr();
1874 assert_eq!(
1875 ::std::mem::size_of::<cst_regex_struct>(),
1876 32usize,
1877 concat!("Size of: ", stringify!(cst_regex_struct))
1878 );
1879 assert_eq!(
1880 ::std::mem::align_of::<cst_regex_struct>(),
1881 8usize,
1882 concat!("Alignment of ", stringify!(cst_regex_struct))
1883 );
1884 assert_eq!(
1885 unsafe { ::std::ptr::addr_of!((*ptr).regstart) as usize - ptr as usize },
1886 0usize,
1887 concat!(
1888 "Offset of field: ",
1889 stringify!(cst_regex_struct),
1890 "::",
1891 stringify!(regstart)
1892 )
1893 );
1894 assert_eq!(
1895 unsafe { ::std::ptr::addr_of!((*ptr).reganch) as usize - ptr as usize },
1896 1usize,
1897 concat!(
1898 "Offset of field: ",
1899 stringify!(cst_regex_struct),
1900 "::",
1901 stringify!(reganch)
1902 )
1903 );
1904 assert_eq!(
1905 unsafe { ::std::ptr::addr_of!((*ptr).regmust) as usize - ptr as usize },
1906 8usize,
1907 concat!(
1908 "Offset of field: ",
1909 stringify!(cst_regex_struct),
1910 "::",
1911 stringify!(regmust)
1912 )
1913 );
1914 assert_eq!(
1915 unsafe { ::std::ptr::addr_of!((*ptr).regmlen) as usize - ptr as usize },
1916 16usize,
1917 concat!(
1918 "Offset of field: ",
1919 stringify!(cst_regex_struct),
1920 "::",
1921 stringify!(regmlen)
1922 )
1923 );
1924 assert_eq!(
1925 unsafe { ::std::ptr::addr_of!((*ptr).regsize) as usize - ptr as usize },
1926 20usize,
1927 concat!(
1928 "Offset of field: ",
1929 stringify!(cst_regex_struct),
1930 "::",
1931 stringify!(regsize)
1932 )
1933 );
1934 assert_eq!(
1935 unsafe { ::std::ptr::addr_of!((*ptr).program) as usize - ptr as usize },
1936 24usize,
1937 concat!(
1938 "Offset of field: ",
1939 stringify!(cst_regex_struct),
1940 "::",
1941 stringify!(program)
1942 )
1943 );
1944}
1945pub type cst_regex = cst_regex_struct;
1946#[repr(C)]
1947#[derive(Debug, Copy, Clone)]
1948pub struct cst_regstate_struct {
1949 pub startp: [*const ::std::os::raw::c_char; 10usize],
1950 pub endp: [*const ::std::os::raw::c_char; 10usize],
1951 pub input: *const ::std::os::raw::c_char,
1952 pub bol: *const ::std::os::raw::c_char,
1953}
1954#[test]
1955fn bindgen_test_layout_cst_regstate_struct() {
1956 const UNINIT: ::std::mem::MaybeUninit<cst_regstate_struct> = ::std::mem::MaybeUninit::uninit();
1957 let ptr = UNINIT.as_ptr();
1958 assert_eq!(
1959 ::std::mem::size_of::<cst_regstate_struct>(),
1960 176usize,
1961 concat!("Size of: ", stringify!(cst_regstate_struct))
1962 );
1963 assert_eq!(
1964 ::std::mem::align_of::<cst_regstate_struct>(),
1965 8usize,
1966 concat!("Alignment of ", stringify!(cst_regstate_struct))
1967 );
1968 assert_eq!(
1969 unsafe { ::std::ptr::addr_of!((*ptr).startp) as usize - ptr as usize },
1970 0usize,
1971 concat!(
1972 "Offset of field: ",
1973 stringify!(cst_regstate_struct),
1974 "::",
1975 stringify!(startp)
1976 )
1977 );
1978 assert_eq!(
1979 unsafe { ::std::ptr::addr_of!((*ptr).endp) as usize - ptr as usize },
1980 80usize,
1981 concat!(
1982 "Offset of field: ",
1983 stringify!(cst_regstate_struct),
1984 "::",
1985 stringify!(endp)
1986 )
1987 );
1988 assert_eq!(
1989 unsafe { ::std::ptr::addr_of!((*ptr).input) as usize - ptr as usize },
1990 160usize,
1991 concat!(
1992 "Offset of field: ",
1993 stringify!(cst_regstate_struct),
1994 "::",
1995 stringify!(input)
1996 )
1997 );
1998 assert_eq!(
1999 unsafe { ::std::ptr::addr_of!((*ptr).bol) as usize - ptr as usize },
2000 168usize,
2001 concat!(
2002 "Offset of field: ",
2003 stringify!(cst_regstate_struct),
2004 "::",
2005 stringify!(bol)
2006 )
2007 );
2008}
2009pub type cst_regstate = cst_regstate_struct;
2010extern "C" {
2011 pub fn new_cst_regex(str_: *const ::std::os::raw::c_char) -> *mut cst_regex;
2012}
2013extern "C" {
2014 pub fn delete_cst_regex(r: *mut cst_regex);
2015}
2016extern "C" {
2017 pub fn cst_regex_match(
2018 r: *const cst_regex,
2019 str_: *const ::std::os::raw::c_char,
2020 ) -> ::std::os::raw::c_int;
2021}
2022extern "C" {
2023 pub fn cst_regex_match_return(
2024 r: *const cst_regex,
2025 str_: *const ::std::os::raw::c_char,
2026 ) -> *mut cst_regstate;
2027}
2028extern "C" {
2029 pub fn hs_regcomp(arg1: *const ::std::os::raw::c_char) -> *mut cst_regex;
2030}
2031extern "C" {
2032 pub fn hs_regexec(
2033 arg1: *const cst_regex,
2034 arg2: *const ::std::os::raw::c_char,
2035 ) -> *mut cst_regstate;
2036}
2037extern "C" {
2038 pub fn hs_regdelete(arg1: *mut cst_regex);
2039}
2040extern "C" {
2041 pub fn cst_regsub(
2042 r: *const cst_regstate,
2043 in_: *const ::std::os::raw::c_char,
2044 out: *mut ::std::os::raw::c_char,
2045 max: usize,
2046 ) -> usize;
2047}
2048extern "C" {
2049 pub fn cst_regex_init();
2050}
2051extern "C" {
2052 pub static cst_rx_white: *const cst_regex;
2053}
2054extern "C" {
2055 pub static cst_rx_alpha: *const cst_regex;
2056}
2057extern "C" {
2058 pub static cst_rx_uppercase: *const cst_regex;
2059}
2060extern "C" {
2061 pub static cst_rx_lowercase: *const cst_regex;
2062}
2063extern "C" {
2064 pub static cst_rx_alphanum: *const cst_regex;
2065}
2066extern "C" {
2067 pub static cst_rx_identifier: *const cst_regex;
2068}
2069extern "C" {
2070 pub static cst_rx_int: *const cst_regex;
2071}
2072extern "C" {
2073 pub static cst_rx_double: *const cst_regex;
2074}
2075extern "C" {
2076 pub static cst_rx_commaint: *const cst_regex;
2077}
2078extern "C" {
2079 pub static cst_rx_digits: *const cst_regex;
2080}
2081extern "C" {
2082 pub static cst_rx_dotted_abbrev: *const cst_regex;
2083}
2084extern "C" {
2085 pub static cst_regex_table: [*const cst_regex; 0usize];
2086}
2087pub type wchar_t = ::std::os::raw::c_int;
2088#[repr(C)]
2089#[derive(Debug, Copy, Clone)]
2090pub struct div_t {
2091 pub quot: ::std::os::raw::c_int,
2092 pub rem: ::std::os::raw::c_int,
2093}
2094#[test]
2095fn bindgen_test_layout_div_t() {
2096 const UNINIT: ::std::mem::MaybeUninit<div_t> = ::std::mem::MaybeUninit::uninit();
2097 let ptr = UNINIT.as_ptr();
2098 assert_eq!(
2099 ::std::mem::size_of::<div_t>(),
2100 8usize,
2101 concat!("Size of: ", stringify!(div_t))
2102 );
2103 assert_eq!(
2104 ::std::mem::align_of::<div_t>(),
2105 4usize,
2106 concat!("Alignment of ", stringify!(div_t))
2107 );
2108 assert_eq!(
2109 unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
2110 0usize,
2111 concat!(
2112 "Offset of field: ",
2113 stringify!(div_t),
2114 "::",
2115 stringify!(quot)
2116 )
2117 );
2118 assert_eq!(
2119 unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
2120 4usize,
2121 concat!(
2122 "Offset of field: ",
2123 stringify!(div_t),
2124 "::",
2125 stringify!(rem)
2126 )
2127 );
2128}
2129#[repr(C)]
2130#[derive(Debug, Copy, Clone)]
2131pub struct ldiv_t {
2132 pub quot: ::std::os::raw::c_long,
2133 pub rem: ::std::os::raw::c_long,
2134}
2135#[test]
2136fn bindgen_test_layout_ldiv_t() {
2137 const UNINIT: ::std::mem::MaybeUninit<ldiv_t> = ::std::mem::MaybeUninit::uninit();
2138 let ptr = UNINIT.as_ptr();
2139 assert_eq!(
2140 ::std::mem::size_of::<ldiv_t>(),
2141 16usize,
2142 concat!("Size of: ", stringify!(ldiv_t))
2143 );
2144 assert_eq!(
2145 ::std::mem::align_of::<ldiv_t>(),
2146 8usize,
2147 concat!("Alignment of ", stringify!(ldiv_t))
2148 );
2149 assert_eq!(
2150 unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
2151 0usize,
2152 concat!(
2153 "Offset of field: ",
2154 stringify!(ldiv_t),
2155 "::",
2156 stringify!(quot)
2157 )
2158 );
2159 assert_eq!(
2160 unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
2161 8usize,
2162 concat!(
2163 "Offset of field: ",
2164 stringify!(ldiv_t),
2165 "::",
2166 stringify!(rem)
2167 )
2168 );
2169}
2170#[repr(C)]
2171#[derive(Debug, Copy, Clone)]
2172pub struct lldiv_t {
2173 pub quot: ::std::os::raw::c_longlong,
2174 pub rem: ::std::os::raw::c_longlong,
2175}
2176#[test]
2177fn bindgen_test_layout_lldiv_t() {
2178 const UNINIT: ::std::mem::MaybeUninit<lldiv_t> = ::std::mem::MaybeUninit::uninit();
2179 let ptr = UNINIT.as_ptr();
2180 assert_eq!(
2181 ::std::mem::size_of::<lldiv_t>(),
2182 16usize,
2183 concat!("Size of: ", stringify!(lldiv_t))
2184 );
2185 assert_eq!(
2186 ::std::mem::align_of::<lldiv_t>(),
2187 8usize,
2188 concat!("Alignment of ", stringify!(lldiv_t))
2189 );
2190 assert_eq!(
2191 unsafe { ::std::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
2192 0usize,
2193 concat!(
2194 "Offset of field: ",
2195 stringify!(lldiv_t),
2196 "::",
2197 stringify!(quot)
2198 )
2199 );
2200 assert_eq!(
2201 unsafe { ::std::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
2202 8usize,
2203 concat!(
2204 "Offset of field: ",
2205 stringify!(lldiv_t),
2206 "::",
2207 stringify!(rem)
2208 )
2209 );
2210}
2211extern "C" {
2212 pub fn __ctype_get_mb_cur_max() -> usize;
2213}
2214extern "C" {
2215 pub fn atof(__nptr: *const ::std::os::raw::c_char) -> f64;
2216}
2217extern "C" {
2218 pub fn atoi(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2219}
2220extern "C" {
2221 pub fn atol(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
2222}
2223extern "C" {
2224 pub fn atoll(__nptr: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
2225}
2226extern "C" {
2227 pub fn strtod(
2228 __nptr: *const ::std::os::raw::c_char,
2229 __endptr: *mut *mut ::std::os::raw::c_char,
2230 ) -> f64;
2231}
2232extern "C" {
2233 pub fn strtof(
2234 __nptr: *const ::std::os::raw::c_char,
2235 __endptr: *mut *mut ::std::os::raw::c_char,
2236 ) -> f32;
2237}
2238extern "C" {
2239 pub fn strtold(
2240 __nptr: *const ::std::os::raw::c_char,
2241 __endptr: *mut *mut ::std::os::raw::c_char,
2242 ) -> u128;
2243}
2244extern "C" {
2245 pub fn strtol(
2246 __nptr: *const ::std::os::raw::c_char,
2247 __endptr: *mut *mut ::std::os::raw::c_char,
2248 __base: ::std::os::raw::c_int,
2249 ) -> ::std::os::raw::c_long;
2250}
2251extern "C" {
2252 pub fn strtoul(
2253 __nptr: *const ::std::os::raw::c_char,
2254 __endptr: *mut *mut ::std::os::raw::c_char,
2255 __base: ::std::os::raw::c_int,
2256 ) -> ::std::os::raw::c_ulong;
2257}
2258extern "C" {
2259 pub fn strtoq(
2260 __nptr: *const ::std::os::raw::c_char,
2261 __endptr: *mut *mut ::std::os::raw::c_char,
2262 __base: ::std::os::raw::c_int,
2263 ) -> ::std::os::raw::c_longlong;
2264}
2265extern "C" {
2266 pub fn strtouq(
2267 __nptr: *const ::std::os::raw::c_char,
2268 __endptr: *mut *mut ::std::os::raw::c_char,
2269 __base: ::std::os::raw::c_int,
2270 ) -> ::std::os::raw::c_ulonglong;
2271}
2272extern "C" {
2273 pub fn strtoll(
2274 __nptr: *const ::std::os::raw::c_char,
2275 __endptr: *mut *mut ::std::os::raw::c_char,
2276 __base: ::std::os::raw::c_int,
2277 ) -> ::std::os::raw::c_longlong;
2278}
2279extern "C" {
2280 pub fn strtoull(
2281 __nptr: *const ::std::os::raw::c_char,
2282 __endptr: *mut *mut ::std::os::raw::c_char,
2283 __base: ::std::os::raw::c_int,
2284 ) -> ::std::os::raw::c_ulonglong;
2285}
2286extern "C" {
2287 pub fn l64a(__n: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
2288}
2289extern "C" {
2290 pub fn a64l(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
2291}
2292pub type u_char = __u_char;
2293pub type u_short = __u_short;
2294pub type u_int = __u_int;
2295pub type u_long = __u_long;
2296pub type quad_t = __quad_t;
2297pub type u_quad_t = __u_quad_t;
2298pub type fsid_t = __fsid_t;
2299pub type loff_t = __loff_t;
2300pub type ino_t = __ino_t;
2301pub type dev_t = __dev_t;
2302pub type gid_t = __gid_t;
2303pub type mode_t = __mode_t;
2304pub type nlink_t = __nlink_t;
2305pub type uid_t = __uid_t;
2306pub type pid_t = __pid_t;
2307pub type id_t = __id_t;
2308pub type daddr_t = __daddr_t;
2309pub type caddr_t = __caddr_t;
2310pub type key_t = __key_t;
2311pub type clock_t = __clock_t;
2312pub type clockid_t = __clockid_t;
2313pub type time_t = __time_t;
2314pub type timer_t = __timer_t;
2315pub type ulong = ::std::os::raw::c_ulong;
2316pub type ushort = ::std::os::raw::c_ushort;
2317pub type uint = ::std::os::raw::c_uint;
2318pub type u_int8_t = __uint8_t;
2319pub type u_int16_t = __uint16_t;
2320pub type u_int32_t = __uint32_t;
2321pub type u_int64_t = __uint64_t;
2322pub type register_t = ::std::os::raw::c_long;
2323#[repr(C)]
2324#[derive(Debug, Copy, Clone)]
2325pub struct __sigset_t {
2326 pub __val: [::std::os::raw::c_ulong; 16usize],
2327}
2328#[test]
2329fn bindgen_test_layout___sigset_t() {
2330 const UNINIT: ::std::mem::MaybeUninit<__sigset_t> = ::std::mem::MaybeUninit::uninit();
2331 let ptr = UNINIT.as_ptr();
2332 assert_eq!(
2333 ::std::mem::size_of::<__sigset_t>(),
2334 128usize,
2335 concat!("Size of: ", stringify!(__sigset_t))
2336 );
2337 assert_eq!(
2338 ::std::mem::align_of::<__sigset_t>(),
2339 8usize,
2340 concat!("Alignment of ", stringify!(__sigset_t))
2341 );
2342 assert_eq!(
2343 unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
2344 0usize,
2345 concat!(
2346 "Offset of field: ",
2347 stringify!(__sigset_t),
2348 "::",
2349 stringify!(__val)
2350 )
2351 );
2352}
2353pub type sigset_t = __sigset_t;
2354#[repr(C)]
2355#[derive(Debug, Copy, Clone)]
2356pub struct timeval {
2357 pub tv_sec: __time_t,
2358 pub tv_usec: __suseconds_t,
2359}
2360#[test]
2361fn bindgen_test_layout_timeval() {
2362 const UNINIT: ::std::mem::MaybeUninit<timeval> = ::std::mem::MaybeUninit::uninit();
2363 let ptr = UNINIT.as_ptr();
2364 assert_eq!(
2365 ::std::mem::size_of::<timeval>(),
2366 16usize,
2367 concat!("Size of: ", stringify!(timeval))
2368 );
2369 assert_eq!(
2370 ::std::mem::align_of::<timeval>(),
2371 8usize,
2372 concat!("Alignment of ", stringify!(timeval))
2373 );
2374 assert_eq!(
2375 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
2376 0usize,
2377 concat!(
2378 "Offset of field: ",
2379 stringify!(timeval),
2380 "::",
2381 stringify!(tv_sec)
2382 )
2383 );
2384 assert_eq!(
2385 unsafe { ::std::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize },
2386 8usize,
2387 concat!(
2388 "Offset of field: ",
2389 stringify!(timeval),
2390 "::",
2391 stringify!(tv_usec)
2392 )
2393 );
2394}
2395#[repr(C)]
2396#[derive(Debug, Copy, Clone)]
2397pub struct timespec {
2398 pub tv_sec: __time_t,
2399 pub tv_nsec: __syscall_slong_t,
2400}
2401#[test]
2402fn bindgen_test_layout_timespec() {
2403 const UNINIT: ::std::mem::MaybeUninit<timespec> = ::std::mem::MaybeUninit::uninit();
2404 let ptr = UNINIT.as_ptr();
2405 assert_eq!(
2406 ::std::mem::size_of::<timespec>(),
2407 16usize,
2408 concat!("Size of: ", stringify!(timespec))
2409 );
2410 assert_eq!(
2411 ::std::mem::align_of::<timespec>(),
2412 8usize,
2413 concat!("Alignment of ", stringify!(timespec))
2414 );
2415 assert_eq!(
2416 unsafe { ::std::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
2417 0usize,
2418 concat!(
2419 "Offset of field: ",
2420 stringify!(timespec),
2421 "::",
2422 stringify!(tv_sec)
2423 )
2424 );
2425 assert_eq!(
2426 unsafe { ::std::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
2427 8usize,
2428 concat!(
2429 "Offset of field: ",
2430 stringify!(timespec),
2431 "::",
2432 stringify!(tv_nsec)
2433 )
2434 );
2435}
2436pub type suseconds_t = __suseconds_t;
2437pub type __fd_mask = ::std::os::raw::c_long;
2438#[repr(C)]
2439#[derive(Debug, Copy, Clone)]
2440pub struct fd_set {
2441 pub __fds_bits: [__fd_mask; 16usize],
2442}
2443#[test]
2444fn bindgen_test_layout_fd_set() {
2445 const UNINIT: ::std::mem::MaybeUninit<fd_set> = ::std::mem::MaybeUninit::uninit();
2446 let ptr = UNINIT.as_ptr();
2447 assert_eq!(
2448 ::std::mem::size_of::<fd_set>(),
2449 128usize,
2450 concat!("Size of: ", stringify!(fd_set))
2451 );
2452 assert_eq!(
2453 ::std::mem::align_of::<fd_set>(),
2454 8usize,
2455 concat!("Alignment of ", stringify!(fd_set))
2456 );
2457 assert_eq!(
2458 unsafe { ::std::ptr::addr_of!((*ptr).__fds_bits) as usize - ptr as usize },
2459 0usize,
2460 concat!(
2461 "Offset of field: ",
2462 stringify!(fd_set),
2463 "::",
2464 stringify!(__fds_bits)
2465 )
2466 );
2467}
2468pub type fd_mask = __fd_mask;
2469extern "C" {
2470 pub fn select(
2471 __nfds: ::std::os::raw::c_int,
2472 __readfds: *mut fd_set,
2473 __writefds: *mut fd_set,
2474 __exceptfds: *mut fd_set,
2475 __timeout: *mut timeval,
2476 ) -> ::std::os::raw::c_int;
2477}
2478extern "C" {
2479 pub fn pselect(
2480 __nfds: ::std::os::raw::c_int,
2481 __readfds: *mut fd_set,
2482 __writefds: *mut fd_set,
2483 __exceptfds: *mut fd_set,
2484 __timeout: *const timespec,
2485 __sigmask: *const __sigset_t,
2486 ) -> ::std::os::raw::c_int;
2487}
2488pub type blksize_t = __blksize_t;
2489pub type blkcnt_t = __blkcnt_t;
2490pub type fsblkcnt_t = __fsblkcnt_t;
2491pub type fsfilcnt_t = __fsfilcnt_t;
2492#[repr(C)]
2493#[derive(Copy, Clone)]
2494pub union __atomic_wide_counter {
2495 pub __value64: ::std::os::raw::c_ulonglong,
2496 pub __value32: __atomic_wide_counter__bindgen_ty_1,
2497}
2498#[repr(C)]
2499#[derive(Debug, Copy, Clone)]
2500pub struct __atomic_wide_counter__bindgen_ty_1 {
2501 pub __low: ::std::os::raw::c_uint,
2502 pub __high: ::std::os::raw::c_uint,
2503}
2504#[test]
2505fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
2506 const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter__bindgen_ty_1> =
2507 ::std::mem::MaybeUninit::uninit();
2508 let ptr = UNINIT.as_ptr();
2509 assert_eq!(
2510 ::std::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(),
2511 8usize,
2512 concat!("Size of: ", stringify!(__atomic_wide_counter__bindgen_ty_1))
2513 );
2514 assert_eq!(
2515 ::std::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>(),
2516 4usize,
2517 concat!(
2518 "Alignment of ",
2519 stringify!(__atomic_wide_counter__bindgen_ty_1)
2520 )
2521 );
2522 assert_eq!(
2523 unsafe { ::std::ptr::addr_of!((*ptr).__low) as usize - ptr as usize },
2524 0usize,
2525 concat!(
2526 "Offset of field: ",
2527 stringify!(__atomic_wide_counter__bindgen_ty_1),
2528 "::",
2529 stringify!(__low)
2530 )
2531 );
2532 assert_eq!(
2533 unsafe { ::std::ptr::addr_of!((*ptr).__high) as usize - ptr as usize },
2534 4usize,
2535 concat!(
2536 "Offset of field: ",
2537 stringify!(__atomic_wide_counter__bindgen_ty_1),
2538 "::",
2539 stringify!(__high)
2540 )
2541 );
2542}
2543#[test]
2544fn bindgen_test_layout___atomic_wide_counter() {
2545 const UNINIT: ::std::mem::MaybeUninit<__atomic_wide_counter> =
2546 ::std::mem::MaybeUninit::uninit();
2547 let ptr = UNINIT.as_ptr();
2548 assert_eq!(
2549 ::std::mem::size_of::<__atomic_wide_counter>(),
2550 8usize,
2551 concat!("Size of: ", stringify!(__atomic_wide_counter))
2552 );
2553 assert_eq!(
2554 ::std::mem::align_of::<__atomic_wide_counter>(),
2555 8usize,
2556 concat!("Alignment of ", stringify!(__atomic_wide_counter))
2557 );
2558 assert_eq!(
2559 unsafe { ::std::ptr::addr_of!((*ptr).__value64) as usize - ptr as usize },
2560 0usize,
2561 concat!(
2562 "Offset of field: ",
2563 stringify!(__atomic_wide_counter),
2564 "::",
2565 stringify!(__value64)
2566 )
2567 );
2568 assert_eq!(
2569 unsafe { ::std::ptr::addr_of!((*ptr).__value32) as usize - ptr as usize },
2570 0usize,
2571 concat!(
2572 "Offset of field: ",
2573 stringify!(__atomic_wide_counter),
2574 "::",
2575 stringify!(__value32)
2576 )
2577 );
2578}
2579#[repr(C)]
2580#[derive(Debug, Copy, Clone)]
2581pub struct __pthread_internal_list {
2582 pub __prev: *mut __pthread_internal_list,
2583 pub __next: *mut __pthread_internal_list,
2584}
2585#[test]
2586fn bindgen_test_layout___pthread_internal_list() {
2587 const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_list> =
2588 ::std::mem::MaybeUninit::uninit();
2589 let ptr = UNINIT.as_ptr();
2590 assert_eq!(
2591 ::std::mem::size_of::<__pthread_internal_list>(),
2592 16usize,
2593 concat!("Size of: ", stringify!(__pthread_internal_list))
2594 );
2595 assert_eq!(
2596 ::std::mem::align_of::<__pthread_internal_list>(),
2597 8usize,
2598 concat!("Alignment of ", stringify!(__pthread_internal_list))
2599 );
2600 assert_eq!(
2601 unsafe { ::std::ptr::addr_of!((*ptr).__prev) as usize - ptr as usize },
2602 0usize,
2603 concat!(
2604 "Offset of field: ",
2605 stringify!(__pthread_internal_list),
2606 "::",
2607 stringify!(__prev)
2608 )
2609 );
2610 assert_eq!(
2611 unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
2612 8usize,
2613 concat!(
2614 "Offset of field: ",
2615 stringify!(__pthread_internal_list),
2616 "::",
2617 stringify!(__next)
2618 )
2619 );
2620}
2621pub type __pthread_list_t = __pthread_internal_list;
2622#[repr(C)]
2623#[derive(Debug, Copy, Clone)]
2624pub struct __pthread_internal_slist {
2625 pub __next: *mut __pthread_internal_slist,
2626}
2627#[test]
2628fn bindgen_test_layout___pthread_internal_slist() {
2629 const UNINIT: ::std::mem::MaybeUninit<__pthread_internal_slist> =
2630 ::std::mem::MaybeUninit::uninit();
2631 let ptr = UNINIT.as_ptr();
2632 assert_eq!(
2633 ::std::mem::size_of::<__pthread_internal_slist>(),
2634 8usize,
2635 concat!("Size of: ", stringify!(__pthread_internal_slist))
2636 );
2637 assert_eq!(
2638 ::std::mem::align_of::<__pthread_internal_slist>(),
2639 8usize,
2640 concat!("Alignment of ", stringify!(__pthread_internal_slist))
2641 );
2642 assert_eq!(
2643 unsafe { ::std::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
2644 0usize,
2645 concat!(
2646 "Offset of field: ",
2647 stringify!(__pthread_internal_slist),
2648 "::",
2649 stringify!(__next)
2650 )
2651 );
2652}
2653pub type __pthread_slist_t = __pthread_internal_slist;
2654#[repr(C)]
2655#[derive(Debug, Copy, Clone)]
2656pub struct __pthread_mutex_s {
2657 pub __lock: ::std::os::raw::c_int,
2658 pub __count: ::std::os::raw::c_uint,
2659 pub __owner: ::std::os::raw::c_int,
2660 pub __nusers: ::std::os::raw::c_uint,
2661 pub __kind: ::std::os::raw::c_int,
2662 pub __spins: ::std::os::raw::c_short,
2663 pub __elision: ::std::os::raw::c_short,
2664 pub __list: __pthread_list_t,
2665}
2666#[test]
2667fn bindgen_test_layout___pthread_mutex_s() {
2668 const UNINIT: ::std::mem::MaybeUninit<__pthread_mutex_s> = ::std::mem::MaybeUninit::uninit();
2669 let ptr = UNINIT.as_ptr();
2670 assert_eq!(
2671 ::std::mem::size_of::<__pthread_mutex_s>(),
2672 40usize,
2673 concat!("Size of: ", stringify!(__pthread_mutex_s))
2674 );
2675 assert_eq!(
2676 ::std::mem::align_of::<__pthread_mutex_s>(),
2677 8usize,
2678 concat!("Alignment of ", stringify!(__pthread_mutex_s))
2679 );
2680 assert_eq!(
2681 unsafe { ::std::ptr::addr_of!((*ptr).__lock) as usize - ptr as usize },
2682 0usize,
2683 concat!(
2684 "Offset of field: ",
2685 stringify!(__pthread_mutex_s),
2686 "::",
2687 stringify!(__lock)
2688 )
2689 );
2690 assert_eq!(
2691 unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
2692 4usize,
2693 concat!(
2694 "Offset of field: ",
2695 stringify!(__pthread_mutex_s),
2696 "::",
2697 stringify!(__count)
2698 )
2699 );
2700 assert_eq!(
2701 unsafe { ::std::ptr::addr_of!((*ptr).__owner) as usize - ptr as usize },
2702 8usize,
2703 concat!(
2704 "Offset of field: ",
2705 stringify!(__pthread_mutex_s),
2706 "::",
2707 stringify!(__owner)
2708 )
2709 );
2710 assert_eq!(
2711 unsafe { ::std::ptr::addr_of!((*ptr).__nusers) as usize - ptr as usize },
2712 12usize,
2713 concat!(
2714 "Offset of field: ",
2715 stringify!(__pthread_mutex_s),
2716 "::",
2717 stringify!(__nusers)
2718 )
2719 );
2720 assert_eq!(
2721 unsafe { ::std::ptr::addr_of!((*ptr).__kind) as usize - ptr as usize },
2722 16usize,
2723 concat!(
2724 "Offset of field: ",
2725 stringify!(__pthread_mutex_s),
2726 "::",
2727 stringify!(__kind)
2728 )
2729 );
2730 assert_eq!(
2731 unsafe { ::std::ptr::addr_of!((*ptr).__spins) as usize - ptr as usize },
2732 20usize,
2733 concat!(
2734 "Offset of field: ",
2735 stringify!(__pthread_mutex_s),
2736 "::",
2737 stringify!(__spins)
2738 )
2739 );
2740 assert_eq!(
2741 unsafe { ::std::ptr::addr_of!((*ptr).__elision) as usize - ptr as usize },
2742 22usize,
2743 concat!(
2744 "Offset of field: ",
2745 stringify!(__pthread_mutex_s),
2746 "::",
2747 stringify!(__elision)
2748 )
2749 );
2750 assert_eq!(
2751 unsafe { ::std::ptr::addr_of!((*ptr).__list) as usize - ptr as usize },
2752 24usize,
2753 concat!(
2754 "Offset of field: ",
2755 stringify!(__pthread_mutex_s),
2756 "::",
2757 stringify!(__list)
2758 )
2759 );
2760}
2761#[repr(C)]
2762#[derive(Debug, Copy, Clone)]
2763pub struct __pthread_rwlock_arch_t {
2764 pub __readers: ::std::os::raw::c_uint,
2765 pub __writers: ::std::os::raw::c_uint,
2766 pub __wrphase_futex: ::std::os::raw::c_uint,
2767 pub __writers_futex: ::std::os::raw::c_uint,
2768 pub __pad3: ::std::os::raw::c_uint,
2769 pub __pad4: ::std::os::raw::c_uint,
2770 pub __cur_writer: ::std::os::raw::c_int,
2771 pub __shared: ::std::os::raw::c_int,
2772 pub __rwelision: ::std::os::raw::c_schar,
2773 pub __pad1: [::std::os::raw::c_uchar; 7usize],
2774 pub __pad2: ::std::os::raw::c_ulong,
2775 pub __flags: ::std::os::raw::c_uint,
2776}
2777#[test]
2778fn bindgen_test_layout___pthread_rwlock_arch_t() {
2779 const UNINIT: ::std::mem::MaybeUninit<__pthread_rwlock_arch_t> =
2780 ::std::mem::MaybeUninit::uninit();
2781 let ptr = UNINIT.as_ptr();
2782 assert_eq!(
2783 ::std::mem::size_of::<__pthread_rwlock_arch_t>(),
2784 56usize,
2785 concat!("Size of: ", stringify!(__pthread_rwlock_arch_t))
2786 );
2787 assert_eq!(
2788 ::std::mem::align_of::<__pthread_rwlock_arch_t>(),
2789 8usize,
2790 concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
2791 );
2792 assert_eq!(
2793 unsafe { ::std::ptr::addr_of!((*ptr).__readers) as usize - ptr as usize },
2794 0usize,
2795 concat!(
2796 "Offset of field: ",
2797 stringify!(__pthread_rwlock_arch_t),
2798 "::",
2799 stringify!(__readers)
2800 )
2801 );
2802 assert_eq!(
2803 unsafe { ::std::ptr::addr_of!((*ptr).__writers) as usize - ptr as usize },
2804 4usize,
2805 concat!(
2806 "Offset of field: ",
2807 stringify!(__pthread_rwlock_arch_t),
2808 "::",
2809 stringify!(__writers)
2810 )
2811 );
2812 assert_eq!(
2813 unsafe { ::std::ptr::addr_of!((*ptr).__wrphase_futex) as usize - ptr as usize },
2814 8usize,
2815 concat!(
2816 "Offset of field: ",
2817 stringify!(__pthread_rwlock_arch_t),
2818 "::",
2819 stringify!(__wrphase_futex)
2820 )
2821 );
2822 assert_eq!(
2823 unsafe { ::std::ptr::addr_of!((*ptr).__writers_futex) as usize - ptr as usize },
2824 12usize,
2825 concat!(
2826 "Offset of field: ",
2827 stringify!(__pthread_rwlock_arch_t),
2828 "::",
2829 stringify!(__writers_futex)
2830 )
2831 );
2832 assert_eq!(
2833 unsafe { ::std::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize },
2834 16usize,
2835 concat!(
2836 "Offset of field: ",
2837 stringify!(__pthread_rwlock_arch_t),
2838 "::",
2839 stringify!(__pad3)
2840 )
2841 );
2842 assert_eq!(
2843 unsafe { ::std::ptr::addr_of!((*ptr).__pad4) as usize - ptr as usize },
2844 20usize,
2845 concat!(
2846 "Offset of field: ",
2847 stringify!(__pthread_rwlock_arch_t),
2848 "::",
2849 stringify!(__pad4)
2850 )
2851 );
2852 assert_eq!(
2853 unsafe { ::std::ptr::addr_of!((*ptr).__cur_writer) as usize - ptr as usize },
2854 24usize,
2855 concat!(
2856 "Offset of field: ",
2857 stringify!(__pthread_rwlock_arch_t),
2858 "::",
2859 stringify!(__cur_writer)
2860 )
2861 );
2862 assert_eq!(
2863 unsafe { ::std::ptr::addr_of!((*ptr).__shared) as usize - ptr as usize },
2864 28usize,
2865 concat!(
2866 "Offset of field: ",
2867 stringify!(__pthread_rwlock_arch_t),
2868 "::",
2869 stringify!(__shared)
2870 )
2871 );
2872 assert_eq!(
2873 unsafe { ::std::ptr::addr_of!((*ptr).__rwelision) as usize - ptr as usize },
2874 32usize,
2875 concat!(
2876 "Offset of field: ",
2877 stringify!(__pthread_rwlock_arch_t),
2878 "::",
2879 stringify!(__rwelision)
2880 )
2881 );
2882 assert_eq!(
2883 unsafe { ::std::ptr::addr_of!((*ptr).__pad1) as usize - ptr as usize },
2884 33usize,
2885 concat!(
2886 "Offset of field: ",
2887 stringify!(__pthread_rwlock_arch_t),
2888 "::",
2889 stringify!(__pad1)
2890 )
2891 );
2892 assert_eq!(
2893 unsafe { ::std::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize },
2894 40usize,
2895 concat!(
2896 "Offset of field: ",
2897 stringify!(__pthread_rwlock_arch_t),
2898 "::",
2899 stringify!(__pad2)
2900 )
2901 );
2902 assert_eq!(
2903 unsafe { ::std::ptr::addr_of!((*ptr).__flags) as usize - ptr as usize },
2904 48usize,
2905 concat!(
2906 "Offset of field: ",
2907 stringify!(__pthread_rwlock_arch_t),
2908 "::",
2909 stringify!(__flags)
2910 )
2911 );
2912}
2913#[repr(C)]
2914#[derive(Copy, Clone)]
2915pub struct __pthread_cond_s {
2916 pub __wseq: __atomic_wide_counter,
2917 pub __g1_start: __atomic_wide_counter,
2918 pub __g_refs: [::std::os::raw::c_uint; 2usize],
2919 pub __g_size: [::std::os::raw::c_uint; 2usize],
2920 pub __g1_orig_size: ::std::os::raw::c_uint,
2921 pub __wrefs: ::std::os::raw::c_uint,
2922 pub __g_signals: [::std::os::raw::c_uint; 2usize],
2923}
2924#[test]
2925fn bindgen_test_layout___pthread_cond_s() {
2926 const UNINIT: ::std::mem::MaybeUninit<__pthread_cond_s> = ::std::mem::MaybeUninit::uninit();
2927 let ptr = UNINIT.as_ptr();
2928 assert_eq!(
2929 ::std::mem::size_of::<__pthread_cond_s>(),
2930 48usize,
2931 concat!("Size of: ", stringify!(__pthread_cond_s))
2932 );
2933 assert_eq!(
2934 ::std::mem::align_of::<__pthread_cond_s>(),
2935 8usize,
2936 concat!("Alignment of ", stringify!(__pthread_cond_s))
2937 );
2938 assert_eq!(
2939 unsafe { ::std::ptr::addr_of!((*ptr).__wseq) as usize - ptr as usize },
2940 0usize,
2941 concat!(
2942 "Offset of field: ",
2943 stringify!(__pthread_cond_s),
2944 "::",
2945 stringify!(__wseq)
2946 )
2947 );
2948 assert_eq!(
2949 unsafe { ::std::ptr::addr_of!((*ptr).__g1_start) as usize - ptr as usize },
2950 8usize,
2951 concat!(
2952 "Offset of field: ",
2953 stringify!(__pthread_cond_s),
2954 "::",
2955 stringify!(__g1_start)
2956 )
2957 );
2958 assert_eq!(
2959 unsafe { ::std::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as usize },
2960 16usize,
2961 concat!(
2962 "Offset of field: ",
2963 stringify!(__pthread_cond_s),
2964 "::",
2965 stringify!(__g_refs)
2966 )
2967 );
2968 assert_eq!(
2969 unsafe { ::std::ptr::addr_of!((*ptr).__g_size) as usize - ptr as usize },
2970 24usize,
2971 concat!(
2972 "Offset of field: ",
2973 stringify!(__pthread_cond_s),
2974 "::",
2975 stringify!(__g_size)
2976 )
2977 );
2978 assert_eq!(
2979 unsafe { ::std::ptr::addr_of!((*ptr).__g1_orig_size) as usize - ptr as usize },
2980 32usize,
2981 concat!(
2982 "Offset of field: ",
2983 stringify!(__pthread_cond_s),
2984 "::",
2985 stringify!(__g1_orig_size)
2986 )
2987 );
2988 assert_eq!(
2989 unsafe { ::std::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as usize },
2990 36usize,
2991 concat!(
2992 "Offset of field: ",
2993 stringify!(__pthread_cond_s),
2994 "::",
2995 stringify!(__wrefs)
2996 )
2997 );
2998 assert_eq!(
2999 unsafe { ::std::ptr::addr_of!((*ptr).__g_signals) as usize - ptr as usize },
3000 40usize,
3001 concat!(
3002 "Offset of field: ",
3003 stringify!(__pthread_cond_s),
3004 "::",
3005 stringify!(__g_signals)
3006 )
3007 );
3008}
3009pub type __tss_t = ::std::os::raw::c_uint;
3010pub type __thrd_t = ::std::os::raw::c_ulong;
3011#[repr(C)]
3012#[derive(Debug, Copy, Clone)]
3013pub struct __once_flag {
3014 pub __data: ::std::os::raw::c_int,
3015}
3016#[test]
3017fn bindgen_test_layout___once_flag() {
3018 const UNINIT: ::std::mem::MaybeUninit<__once_flag> = ::std::mem::MaybeUninit::uninit();
3019 let ptr = UNINIT.as_ptr();
3020 assert_eq!(
3021 ::std::mem::size_of::<__once_flag>(),
3022 4usize,
3023 concat!("Size of: ", stringify!(__once_flag))
3024 );
3025 assert_eq!(
3026 ::std::mem::align_of::<__once_flag>(),
3027 4usize,
3028 concat!("Alignment of ", stringify!(__once_flag))
3029 );
3030 assert_eq!(
3031 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
3032 0usize,
3033 concat!(
3034 "Offset of field: ",
3035 stringify!(__once_flag),
3036 "::",
3037 stringify!(__data)
3038 )
3039 );
3040}
3041pub type pthread_t = ::std::os::raw::c_ulong;
3042#[repr(C)]
3043#[derive(Copy, Clone)]
3044pub union pthread_mutexattr_t {
3045 pub __size: [::std::os::raw::c_char; 4usize],
3046 pub __align: ::std::os::raw::c_int,
3047}
3048#[test]
3049fn bindgen_test_layout_pthread_mutexattr_t() {
3050 const UNINIT: ::std::mem::MaybeUninit<pthread_mutexattr_t> = ::std::mem::MaybeUninit::uninit();
3051 let ptr = UNINIT.as_ptr();
3052 assert_eq!(
3053 ::std::mem::size_of::<pthread_mutexattr_t>(),
3054 4usize,
3055 concat!("Size of: ", stringify!(pthread_mutexattr_t))
3056 );
3057 assert_eq!(
3058 ::std::mem::align_of::<pthread_mutexattr_t>(),
3059 4usize,
3060 concat!("Alignment of ", stringify!(pthread_mutexattr_t))
3061 );
3062 assert_eq!(
3063 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
3064 0usize,
3065 concat!(
3066 "Offset of field: ",
3067 stringify!(pthread_mutexattr_t),
3068 "::",
3069 stringify!(__size)
3070 )
3071 );
3072 assert_eq!(
3073 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
3074 0usize,
3075 concat!(
3076 "Offset of field: ",
3077 stringify!(pthread_mutexattr_t),
3078 "::",
3079 stringify!(__align)
3080 )
3081 );
3082}
3083#[repr(C)]
3084#[derive(Copy, Clone)]
3085pub union pthread_condattr_t {
3086 pub __size: [::std::os::raw::c_char; 4usize],
3087 pub __align: ::std::os::raw::c_int,
3088}
3089#[test]
3090fn bindgen_test_layout_pthread_condattr_t() {
3091 const UNINIT: ::std::mem::MaybeUninit<pthread_condattr_t> = ::std::mem::MaybeUninit::uninit();
3092 let ptr = UNINIT.as_ptr();
3093 assert_eq!(
3094 ::std::mem::size_of::<pthread_condattr_t>(),
3095 4usize,
3096 concat!("Size of: ", stringify!(pthread_condattr_t))
3097 );
3098 assert_eq!(
3099 ::std::mem::align_of::<pthread_condattr_t>(),
3100 4usize,
3101 concat!("Alignment of ", stringify!(pthread_condattr_t))
3102 );
3103 assert_eq!(
3104 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
3105 0usize,
3106 concat!(
3107 "Offset of field: ",
3108 stringify!(pthread_condattr_t),
3109 "::",
3110 stringify!(__size)
3111 )
3112 );
3113 assert_eq!(
3114 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
3115 0usize,
3116 concat!(
3117 "Offset of field: ",
3118 stringify!(pthread_condattr_t),
3119 "::",
3120 stringify!(__align)
3121 )
3122 );
3123}
3124pub type pthread_key_t = ::std::os::raw::c_uint;
3125pub type pthread_once_t = ::std::os::raw::c_int;
3126#[repr(C)]
3127#[derive(Copy, Clone)]
3128pub union pthread_attr_t {
3129 pub __size: [::std::os::raw::c_char; 56usize],
3130 pub __align: ::std::os::raw::c_long,
3131}
3132#[test]
3133fn bindgen_test_layout_pthread_attr_t() {
3134 const UNINIT: ::std::mem::MaybeUninit<pthread_attr_t> = ::std::mem::MaybeUninit::uninit();
3135 let ptr = UNINIT.as_ptr();
3136 assert_eq!(
3137 ::std::mem::size_of::<pthread_attr_t>(),
3138 56usize,
3139 concat!("Size of: ", stringify!(pthread_attr_t))
3140 );
3141 assert_eq!(
3142 ::std::mem::align_of::<pthread_attr_t>(),
3143 8usize,
3144 concat!("Alignment of ", stringify!(pthread_attr_t))
3145 );
3146 assert_eq!(
3147 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
3148 0usize,
3149 concat!(
3150 "Offset of field: ",
3151 stringify!(pthread_attr_t),
3152 "::",
3153 stringify!(__size)
3154 )
3155 );
3156 assert_eq!(
3157 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
3158 0usize,
3159 concat!(
3160 "Offset of field: ",
3161 stringify!(pthread_attr_t),
3162 "::",
3163 stringify!(__align)
3164 )
3165 );
3166}
3167#[repr(C)]
3168#[derive(Copy, Clone)]
3169pub union pthread_mutex_t {
3170 pub __data: __pthread_mutex_s,
3171 pub __size: [::std::os::raw::c_char; 40usize],
3172 pub __align: ::std::os::raw::c_long,
3173}
3174#[test]
3175fn bindgen_test_layout_pthread_mutex_t() {
3176 const UNINIT: ::std::mem::MaybeUninit<pthread_mutex_t> = ::std::mem::MaybeUninit::uninit();
3177 let ptr = UNINIT.as_ptr();
3178 assert_eq!(
3179 ::std::mem::size_of::<pthread_mutex_t>(),
3180 40usize,
3181 concat!("Size of: ", stringify!(pthread_mutex_t))
3182 );
3183 assert_eq!(
3184 ::std::mem::align_of::<pthread_mutex_t>(),
3185 8usize,
3186 concat!("Alignment of ", stringify!(pthread_mutex_t))
3187 );
3188 assert_eq!(
3189 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
3190 0usize,
3191 concat!(
3192 "Offset of field: ",
3193 stringify!(pthread_mutex_t),
3194 "::",
3195 stringify!(__data)
3196 )
3197 );
3198 assert_eq!(
3199 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
3200 0usize,
3201 concat!(
3202 "Offset of field: ",
3203 stringify!(pthread_mutex_t),
3204 "::",
3205 stringify!(__size)
3206 )
3207 );
3208 assert_eq!(
3209 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
3210 0usize,
3211 concat!(
3212 "Offset of field: ",
3213 stringify!(pthread_mutex_t),
3214 "::",
3215 stringify!(__align)
3216 )
3217 );
3218}
3219#[repr(C)]
3220#[derive(Copy, Clone)]
3221pub union pthread_cond_t {
3222 pub __data: __pthread_cond_s,
3223 pub __size: [::std::os::raw::c_char; 48usize],
3224 pub __align: ::std::os::raw::c_longlong,
3225}
3226#[test]
3227fn bindgen_test_layout_pthread_cond_t() {
3228 const UNINIT: ::std::mem::MaybeUninit<pthread_cond_t> = ::std::mem::MaybeUninit::uninit();
3229 let ptr = UNINIT.as_ptr();
3230 assert_eq!(
3231 ::std::mem::size_of::<pthread_cond_t>(),
3232 48usize,
3233 concat!("Size of: ", stringify!(pthread_cond_t))
3234 );
3235 assert_eq!(
3236 ::std::mem::align_of::<pthread_cond_t>(),
3237 8usize,
3238 concat!("Alignment of ", stringify!(pthread_cond_t))
3239 );
3240 assert_eq!(
3241 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
3242 0usize,
3243 concat!(
3244 "Offset of field: ",
3245 stringify!(pthread_cond_t),
3246 "::",
3247 stringify!(__data)
3248 )
3249 );
3250 assert_eq!(
3251 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
3252 0usize,
3253 concat!(
3254 "Offset of field: ",
3255 stringify!(pthread_cond_t),
3256 "::",
3257 stringify!(__size)
3258 )
3259 );
3260 assert_eq!(
3261 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
3262 0usize,
3263 concat!(
3264 "Offset of field: ",
3265 stringify!(pthread_cond_t),
3266 "::",
3267 stringify!(__align)
3268 )
3269 );
3270}
3271#[repr(C)]
3272#[derive(Copy, Clone)]
3273pub union pthread_rwlock_t {
3274 pub __data: __pthread_rwlock_arch_t,
3275 pub __size: [::std::os::raw::c_char; 56usize],
3276 pub __align: ::std::os::raw::c_long,
3277}
3278#[test]
3279fn bindgen_test_layout_pthread_rwlock_t() {
3280 const UNINIT: ::std::mem::MaybeUninit<pthread_rwlock_t> = ::std::mem::MaybeUninit::uninit();
3281 let ptr = UNINIT.as_ptr();
3282 assert_eq!(
3283 ::std::mem::size_of::<pthread_rwlock_t>(),
3284 56usize,
3285 concat!("Size of: ", stringify!(pthread_rwlock_t))
3286 );
3287 assert_eq!(
3288 ::std::mem::align_of::<pthread_rwlock_t>(),
3289 8usize,
3290 concat!("Alignment of ", stringify!(pthread_rwlock_t))
3291 );
3292 assert_eq!(
3293 unsafe { ::std::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
3294 0usize,
3295 concat!(
3296 "Offset of field: ",
3297 stringify!(pthread_rwlock_t),
3298 "::",
3299 stringify!(__data)
3300 )
3301 );
3302 assert_eq!(
3303 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
3304 0usize,
3305 concat!(
3306 "Offset of field: ",
3307 stringify!(pthread_rwlock_t),
3308 "::",
3309 stringify!(__size)
3310 )
3311 );
3312 assert_eq!(
3313 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
3314 0usize,
3315 concat!(
3316 "Offset of field: ",
3317 stringify!(pthread_rwlock_t),
3318 "::",
3319 stringify!(__align)
3320 )
3321 );
3322}
3323#[repr(C)]
3324#[derive(Copy, Clone)]
3325pub union pthread_rwlockattr_t {
3326 pub __size: [::std::os::raw::c_char; 8usize],
3327 pub __align: ::std::os::raw::c_long,
3328}
3329#[test]
3330fn bindgen_test_layout_pthread_rwlockattr_t() {
3331 const UNINIT: ::std::mem::MaybeUninit<pthread_rwlockattr_t> = ::std::mem::MaybeUninit::uninit();
3332 let ptr = UNINIT.as_ptr();
3333 assert_eq!(
3334 ::std::mem::size_of::<pthread_rwlockattr_t>(),
3335 8usize,
3336 concat!("Size of: ", stringify!(pthread_rwlockattr_t))
3337 );
3338 assert_eq!(
3339 ::std::mem::align_of::<pthread_rwlockattr_t>(),
3340 8usize,
3341 concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
3342 );
3343 assert_eq!(
3344 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
3345 0usize,
3346 concat!(
3347 "Offset of field: ",
3348 stringify!(pthread_rwlockattr_t),
3349 "::",
3350 stringify!(__size)
3351 )
3352 );
3353 assert_eq!(
3354 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
3355 0usize,
3356 concat!(
3357 "Offset of field: ",
3358 stringify!(pthread_rwlockattr_t),
3359 "::",
3360 stringify!(__align)
3361 )
3362 );
3363}
3364pub type pthread_spinlock_t = ::std::os::raw::c_int;
3365#[repr(C)]
3366#[derive(Copy, Clone)]
3367pub union pthread_barrier_t {
3368 pub __size: [::std::os::raw::c_char; 32usize],
3369 pub __align: ::std::os::raw::c_long,
3370}
3371#[test]
3372fn bindgen_test_layout_pthread_barrier_t() {
3373 const UNINIT: ::std::mem::MaybeUninit<pthread_barrier_t> = ::std::mem::MaybeUninit::uninit();
3374 let ptr = UNINIT.as_ptr();
3375 assert_eq!(
3376 ::std::mem::size_of::<pthread_barrier_t>(),
3377 32usize,
3378 concat!("Size of: ", stringify!(pthread_barrier_t))
3379 );
3380 assert_eq!(
3381 ::std::mem::align_of::<pthread_barrier_t>(),
3382 8usize,
3383 concat!("Alignment of ", stringify!(pthread_barrier_t))
3384 );
3385 assert_eq!(
3386 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
3387 0usize,
3388 concat!(
3389 "Offset of field: ",
3390 stringify!(pthread_barrier_t),
3391 "::",
3392 stringify!(__size)
3393 )
3394 );
3395 assert_eq!(
3396 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
3397 0usize,
3398 concat!(
3399 "Offset of field: ",
3400 stringify!(pthread_barrier_t),
3401 "::",
3402 stringify!(__align)
3403 )
3404 );
3405}
3406#[repr(C)]
3407#[derive(Copy, Clone)]
3408pub union pthread_barrierattr_t {
3409 pub __size: [::std::os::raw::c_char; 4usize],
3410 pub __align: ::std::os::raw::c_int,
3411}
3412#[test]
3413fn bindgen_test_layout_pthread_barrierattr_t() {
3414 const UNINIT: ::std::mem::MaybeUninit<pthread_barrierattr_t> =
3415 ::std::mem::MaybeUninit::uninit();
3416 let ptr = UNINIT.as_ptr();
3417 assert_eq!(
3418 ::std::mem::size_of::<pthread_barrierattr_t>(),
3419 4usize,
3420 concat!("Size of: ", stringify!(pthread_barrierattr_t))
3421 );
3422 assert_eq!(
3423 ::std::mem::align_of::<pthread_barrierattr_t>(),
3424 4usize,
3425 concat!("Alignment of ", stringify!(pthread_barrierattr_t))
3426 );
3427 assert_eq!(
3428 unsafe { ::std::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
3429 0usize,
3430 concat!(
3431 "Offset of field: ",
3432 stringify!(pthread_barrierattr_t),
3433 "::",
3434 stringify!(__size)
3435 )
3436 );
3437 assert_eq!(
3438 unsafe { ::std::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
3439 0usize,
3440 concat!(
3441 "Offset of field: ",
3442 stringify!(pthread_barrierattr_t),
3443 "::",
3444 stringify!(__align)
3445 )
3446 );
3447}
3448extern "C" {
3449 pub fn random() -> ::std::os::raw::c_long;
3450}
3451extern "C" {
3452 pub fn srandom(__seed: ::std::os::raw::c_uint);
3453}
3454extern "C" {
3455 pub fn initstate(
3456 __seed: ::std::os::raw::c_uint,
3457 __statebuf: *mut ::std::os::raw::c_char,
3458 __statelen: usize,
3459 ) -> *mut ::std::os::raw::c_char;
3460}
3461extern "C" {
3462 pub fn setstate(__statebuf: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
3463}
3464#[repr(C)]
3465#[derive(Debug, Copy, Clone)]
3466pub struct random_data {
3467 pub fptr: *mut i32,
3468 pub rptr: *mut i32,
3469 pub state: *mut i32,
3470 pub rand_type: ::std::os::raw::c_int,
3471 pub rand_deg: ::std::os::raw::c_int,
3472 pub rand_sep: ::std::os::raw::c_int,
3473 pub end_ptr: *mut i32,
3474}
3475#[test]
3476fn bindgen_test_layout_random_data() {
3477 const UNINIT: ::std::mem::MaybeUninit<random_data> = ::std::mem::MaybeUninit::uninit();
3478 let ptr = UNINIT.as_ptr();
3479 assert_eq!(
3480 ::std::mem::size_of::<random_data>(),
3481 48usize,
3482 concat!("Size of: ", stringify!(random_data))
3483 );
3484 assert_eq!(
3485 ::std::mem::align_of::<random_data>(),
3486 8usize,
3487 concat!("Alignment of ", stringify!(random_data))
3488 );
3489 assert_eq!(
3490 unsafe { ::std::ptr::addr_of!((*ptr).fptr) as usize - ptr as usize },
3491 0usize,
3492 concat!(
3493 "Offset of field: ",
3494 stringify!(random_data),
3495 "::",
3496 stringify!(fptr)
3497 )
3498 );
3499 assert_eq!(
3500 unsafe { ::std::ptr::addr_of!((*ptr).rptr) as usize - ptr as usize },
3501 8usize,
3502 concat!(
3503 "Offset of field: ",
3504 stringify!(random_data),
3505 "::",
3506 stringify!(rptr)
3507 )
3508 );
3509 assert_eq!(
3510 unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
3511 16usize,
3512 concat!(
3513 "Offset of field: ",
3514 stringify!(random_data),
3515 "::",
3516 stringify!(state)
3517 )
3518 );
3519 assert_eq!(
3520 unsafe { ::std::ptr::addr_of!((*ptr).rand_type) as usize - ptr as usize },
3521 24usize,
3522 concat!(
3523 "Offset of field: ",
3524 stringify!(random_data),
3525 "::",
3526 stringify!(rand_type)
3527 )
3528 );
3529 assert_eq!(
3530 unsafe { ::std::ptr::addr_of!((*ptr).rand_deg) as usize - ptr as usize },
3531 28usize,
3532 concat!(
3533 "Offset of field: ",
3534 stringify!(random_data),
3535 "::",
3536 stringify!(rand_deg)
3537 )
3538 );
3539 assert_eq!(
3540 unsafe { ::std::ptr::addr_of!((*ptr).rand_sep) as usize - ptr as usize },
3541 32usize,
3542 concat!(
3543 "Offset of field: ",
3544 stringify!(random_data),
3545 "::",
3546 stringify!(rand_sep)
3547 )
3548 );
3549 assert_eq!(
3550 unsafe { ::std::ptr::addr_of!((*ptr).end_ptr) as usize - ptr as usize },
3551 40usize,
3552 concat!(
3553 "Offset of field: ",
3554 stringify!(random_data),
3555 "::",
3556 stringify!(end_ptr)
3557 )
3558 );
3559}
3560extern "C" {
3561 pub fn random_r(__buf: *mut random_data, __result: *mut i32) -> ::std::os::raw::c_int;
3562}
3563extern "C" {
3564 pub fn srandom_r(
3565 __seed: ::std::os::raw::c_uint,
3566 __buf: *mut random_data,
3567 ) -> ::std::os::raw::c_int;
3568}
3569extern "C" {
3570 pub fn initstate_r(
3571 __seed: ::std::os::raw::c_uint,
3572 __statebuf: *mut ::std::os::raw::c_char,
3573 __statelen: usize,
3574 __buf: *mut random_data,
3575 ) -> ::std::os::raw::c_int;
3576}
3577extern "C" {
3578 pub fn setstate_r(
3579 __statebuf: *mut ::std::os::raw::c_char,
3580 __buf: *mut random_data,
3581 ) -> ::std::os::raw::c_int;
3582}
3583extern "C" {
3584 pub fn rand() -> ::std::os::raw::c_int;
3585}
3586extern "C" {
3587 pub fn srand(__seed: ::std::os::raw::c_uint);
3588}
3589extern "C" {
3590 pub fn rand_r(__seed: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
3591}
3592extern "C" {
3593 pub fn drand48() -> f64;
3594}
3595extern "C" {
3596 pub fn erand48(__xsubi: *mut ::std::os::raw::c_ushort) -> f64;
3597}
3598extern "C" {
3599 pub fn lrand48() -> ::std::os::raw::c_long;
3600}
3601extern "C" {
3602 pub fn nrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
3603}
3604extern "C" {
3605 pub fn mrand48() -> ::std::os::raw::c_long;
3606}
3607extern "C" {
3608 pub fn jrand48(__xsubi: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
3609}
3610extern "C" {
3611 pub fn srand48(__seedval: ::std::os::raw::c_long);
3612}
3613extern "C" {
3614 pub fn seed48(__seed16v: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
3615}
3616extern "C" {
3617 pub fn lcong48(__param: *mut ::std::os::raw::c_ushort);
3618}
3619#[repr(C)]
3620#[derive(Debug, Copy, Clone)]
3621pub struct drand48_data {
3622 pub __x: [::std::os::raw::c_ushort; 3usize],
3623 pub __old_x: [::std::os::raw::c_ushort; 3usize],
3624 pub __c: ::std::os::raw::c_ushort,
3625 pub __init: ::std::os::raw::c_ushort,
3626 pub __a: ::std::os::raw::c_ulonglong,
3627}
3628#[test]
3629fn bindgen_test_layout_drand48_data() {
3630 const UNINIT: ::std::mem::MaybeUninit<drand48_data> = ::std::mem::MaybeUninit::uninit();
3631 let ptr = UNINIT.as_ptr();
3632 assert_eq!(
3633 ::std::mem::size_of::<drand48_data>(),
3634 24usize,
3635 concat!("Size of: ", stringify!(drand48_data))
3636 );
3637 assert_eq!(
3638 ::std::mem::align_of::<drand48_data>(),
3639 8usize,
3640 concat!("Alignment of ", stringify!(drand48_data))
3641 );
3642 assert_eq!(
3643 unsafe { ::std::ptr::addr_of!((*ptr).__x) as usize - ptr as usize },
3644 0usize,
3645 concat!(
3646 "Offset of field: ",
3647 stringify!(drand48_data),
3648 "::",
3649 stringify!(__x)
3650 )
3651 );
3652 assert_eq!(
3653 unsafe { ::std::ptr::addr_of!((*ptr).__old_x) as usize - ptr as usize },
3654 6usize,
3655 concat!(
3656 "Offset of field: ",
3657 stringify!(drand48_data),
3658 "::",
3659 stringify!(__old_x)
3660 )
3661 );
3662 assert_eq!(
3663 unsafe { ::std::ptr::addr_of!((*ptr).__c) as usize - ptr as usize },
3664 12usize,
3665 concat!(
3666 "Offset of field: ",
3667 stringify!(drand48_data),
3668 "::",
3669 stringify!(__c)
3670 )
3671 );
3672 assert_eq!(
3673 unsafe { ::std::ptr::addr_of!((*ptr).__init) as usize - ptr as usize },
3674 14usize,
3675 concat!(
3676 "Offset of field: ",
3677 stringify!(drand48_data),
3678 "::",
3679 stringify!(__init)
3680 )
3681 );
3682 assert_eq!(
3683 unsafe { ::std::ptr::addr_of!((*ptr).__a) as usize - ptr as usize },
3684 16usize,
3685 concat!(
3686 "Offset of field: ",
3687 stringify!(drand48_data),
3688 "::",
3689 stringify!(__a)
3690 )
3691 );
3692}
3693extern "C" {
3694 pub fn drand48_r(__buffer: *mut drand48_data, __result: *mut f64) -> ::std::os::raw::c_int;
3695}
3696extern "C" {
3697 pub fn erand48_r(
3698 __xsubi: *mut ::std::os::raw::c_ushort,
3699 __buffer: *mut drand48_data,
3700 __result: *mut f64,
3701 ) -> ::std::os::raw::c_int;
3702}
3703extern "C" {
3704 pub fn lrand48_r(
3705 __buffer: *mut drand48_data,
3706 __result: *mut ::std::os::raw::c_long,
3707 ) -> ::std::os::raw::c_int;
3708}
3709extern "C" {
3710 pub fn nrand48_r(
3711 __xsubi: *mut ::std::os::raw::c_ushort,
3712 __buffer: *mut drand48_data,
3713 __result: *mut ::std::os::raw::c_long,
3714 ) -> ::std::os::raw::c_int;
3715}
3716extern "C" {
3717 pub fn mrand48_r(
3718 __buffer: *mut drand48_data,
3719 __result: *mut ::std::os::raw::c_long,
3720 ) -> ::std::os::raw::c_int;
3721}
3722extern "C" {
3723 pub fn jrand48_r(
3724 __xsubi: *mut ::std::os::raw::c_ushort,
3725 __buffer: *mut drand48_data,
3726 __result: *mut ::std::os::raw::c_long,
3727 ) -> ::std::os::raw::c_int;
3728}
3729extern "C" {
3730 pub fn srand48_r(
3731 __seedval: ::std::os::raw::c_long,
3732 __buffer: *mut drand48_data,
3733 ) -> ::std::os::raw::c_int;
3734}
3735extern "C" {
3736 pub fn seed48_r(
3737 __seed16v: *mut ::std::os::raw::c_ushort,
3738 __buffer: *mut drand48_data,
3739 ) -> ::std::os::raw::c_int;
3740}
3741extern "C" {
3742 pub fn lcong48_r(
3743 __param: *mut ::std::os::raw::c_ushort,
3744 __buffer: *mut drand48_data,
3745 ) -> ::std::os::raw::c_int;
3746}
3747extern "C" {
3748 pub fn arc4random() -> __uint32_t;
3749}
3750extern "C" {
3751 pub fn arc4random_buf(__buf: *mut ::std::os::raw::c_void, __size: usize);
3752}
3753extern "C" {
3754 pub fn arc4random_uniform(__upper_bound: __uint32_t) -> __uint32_t;
3755}
3756extern "C" {
3757 pub fn malloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
3758}
3759extern "C" {
3760 pub fn calloc(
3761 __nmemb: ::std::os::raw::c_ulong,
3762 __size: ::std::os::raw::c_ulong,
3763 ) -> *mut ::std::os::raw::c_void;
3764}
3765extern "C" {
3766 pub fn realloc(
3767 __ptr: *mut ::std::os::raw::c_void,
3768 __size: ::std::os::raw::c_ulong,
3769 ) -> *mut ::std::os::raw::c_void;
3770}
3771extern "C" {
3772 pub fn free(__ptr: *mut ::std::os::raw::c_void);
3773}
3774extern "C" {
3775 pub fn reallocarray(
3776 __ptr: *mut ::std::os::raw::c_void,
3777 __nmemb: usize,
3778 __size: usize,
3779 ) -> *mut ::std::os::raw::c_void;
3780}
3781extern "C" {
3782 pub fn alloca(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
3783}
3784extern "C" {
3785 pub fn valloc(__size: usize) -> *mut ::std::os::raw::c_void;
3786}
3787extern "C" {
3788 pub fn posix_memalign(
3789 __memptr: *mut *mut ::std::os::raw::c_void,
3790 __alignment: usize,
3791 __size: usize,
3792 ) -> ::std::os::raw::c_int;
3793}
3794extern "C" {
3795 pub fn aligned_alloc(
3796 __alignment: ::std::os::raw::c_ulong,
3797 __size: ::std::os::raw::c_ulong,
3798 ) -> *mut ::std::os::raw::c_void;
3799}
3800extern "C" {
3801 pub fn abort() -> !;
3802}
3803extern "C" {
3804 pub fn atexit(__func: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
3805}
3806extern "C" {
3807 pub fn at_quick_exit(
3808 __func: ::std::option::Option<unsafe extern "C" fn()>,
3809 ) -> ::std::os::raw::c_int;
3810}
3811extern "C" {
3812 pub fn on_exit(
3813 __func: ::std::option::Option<
3814 unsafe extern "C" fn(
3815 __status: ::std::os::raw::c_int,
3816 __arg: *mut ::std::os::raw::c_void,
3817 ),
3818 >,
3819 __arg: *mut ::std::os::raw::c_void,
3820 ) -> ::std::os::raw::c_int;
3821}
3822extern "C" {
3823 pub fn exit(__status: ::std::os::raw::c_int) -> !;
3824}
3825extern "C" {
3826 pub fn quick_exit(__status: ::std::os::raw::c_int) -> !;
3827}
3828extern "C" {
3829 pub fn _Exit(__status: ::std::os::raw::c_int) -> !;
3830}
3831extern "C" {
3832 pub fn getenv(__name: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
3833}
3834extern "C" {
3835 pub fn putenv(__string: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
3836}
3837extern "C" {
3838 pub fn setenv(
3839 __name: *const ::std::os::raw::c_char,
3840 __value: *const ::std::os::raw::c_char,
3841 __replace: ::std::os::raw::c_int,
3842 ) -> ::std::os::raw::c_int;
3843}
3844extern "C" {
3845 pub fn unsetenv(__name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
3846}
3847extern "C" {
3848 pub fn clearenv() -> ::std::os::raw::c_int;
3849}
3850extern "C" {
3851 pub fn mktemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
3852}
3853extern "C" {
3854 pub fn mkstemp(__template: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
3855}
3856extern "C" {
3857 pub fn mkstemps(
3858 __template: *mut ::std::os::raw::c_char,
3859 __suffixlen: ::std::os::raw::c_int,
3860 ) -> ::std::os::raw::c_int;
3861}
3862extern "C" {
3863 pub fn mkdtemp(__template: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
3864}
3865extern "C" {
3866 pub fn system(__command: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
3867}
3868extern "C" {
3869 pub fn realpath(
3870 __name: *const ::std::os::raw::c_char,
3871 __resolved: *mut ::std::os::raw::c_char,
3872 ) -> *mut ::std::os::raw::c_char;
3873}
3874pub type __compar_fn_t = ::std::option::Option<
3875 unsafe extern "C" fn(
3876 arg1: *const ::std::os::raw::c_void,
3877 arg2: *const ::std::os::raw::c_void,
3878 ) -> ::std::os::raw::c_int,
3879>;
3880extern "C" {
3881 pub fn bsearch(
3882 __key: *const ::std::os::raw::c_void,
3883 __base: *const ::std::os::raw::c_void,
3884 __nmemb: usize,
3885 __size: usize,
3886 __compar: __compar_fn_t,
3887 ) -> *mut ::std::os::raw::c_void;
3888}
3889extern "C" {
3890 pub fn qsort(
3891 __base: *mut ::std::os::raw::c_void,
3892 __nmemb: usize,
3893 __size: usize,
3894 __compar: __compar_fn_t,
3895 );
3896}
3897extern "C" {
3898 pub fn abs(__x: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
3899}
3900extern "C" {
3901 pub fn labs(__x: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
3902}
3903extern "C" {
3904 pub fn llabs(__x: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
3905}
3906extern "C" {
3907 pub fn div(__numer: ::std::os::raw::c_int, __denom: ::std::os::raw::c_int) -> div_t;
3908}
3909extern "C" {
3910 pub fn ldiv(__numer: ::std::os::raw::c_long, __denom: ::std::os::raw::c_long) -> ldiv_t;
3911}
3912extern "C" {
3913 pub fn lldiv(
3914 __numer: ::std::os::raw::c_longlong,
3915 __denom: ::std::os::raw::c_longlong,
3916 ) -> lldiv_t;
3917}
3918extern "C" {
3919 pub fn ecvt(
3920 __value: f64,
3921 __ndigit: ::std::os::raw::c_int,
3922 __decpt: *mut ::std::os::raw::c_int,
3923 __sign: *mut ::std::os::raw::c_int,
3924 ) -> *mut ::std::os::raw::c_char;
3925}
3926extern "C" {
3927 pub fn fcvt(
3928 __value: f64,
3929 __ndigit: ::std::os::raw::c_int,
3930 __decpt: *mut ::std::os::raw::c_int,
3931 __sign: *mut ::std::os::raw::c_int,
3932 ) -> *mut ::std::os::raw::c_char;
3933}
3934extern "C" {
3935 pub fn gcvt(
3936 __value: f64,
3937 __ndigit: ::std::os::raw::c_int,
3938 __buf: *mut ::std::os::raw::c_char,
3939 ) -> *mut ::std::os::raw::c_char;
3940}
3941extern "C" {
3942 pub fn qecvt(
3943 __value: u128,
3944 __ndigit: ::std::os::raw::c_int,
3945 __decpt: *mut ::std::os::raw::c_int,
3946 __sign: *mut ::std::os::raw::c_int,
3947 ) -> *mut ::std::os::raw::c_char;
3948}
3949extern "C" {
3950 pub fn qfcvt(
3951 __value: u128,
3952 __ndigit: ::std::os::raw::c_int,
3953 __decpt: *mut ::std::os::raw::c_int,
3954 __sign: *mut ::std::os::raw::c_int,
3955 ) -> *mut ::std::os::raw::c_char;
3956}
3957extern "C" {
3958 pub fn qgcvt(
3959 __value: u128,
3960 __ndigit: ::std::os::raw::c_int,
3961 __buf: *mut ::std::os::raw::c_char,
3962 ) -> *mut ::std::os::raw::c_char;
3963}
3964extern "C" {
3965 pub fn ecvt_r(
3966 __value: f64,
3967 __ndigit: ::std::os::raw::c_int,
3968 __decpt: *mut ::std::os::raw::c_int,
3969 __sign: *mut ::std::os::raw::c_int,
3970 __buf: *mut ::std::os::raw::c_char,
3971 __len: usize,
3972 ) -> ::std::os::raw::c_int;
3973}
3974extern "C" {
3975 pub fn fcvt_r(
3976 __value: f64,
3977 __ndigit: ::std::os::raw::c_int,
3978 __decpt: *mut ::std::os::raw::c_int,
3979 __sign: *mut ::std::os::raw::c_int,
3980 __buf: *mut ::std::os::raw::c_char,
3981 __len: usize,
3982 ) -> ::std::os::raw::c_int;
3983}
3984extern "C" {
3985 pub fn qecvt_r(
3986 __value: u128,
3987 __ndigit: ::std::os::raw::c_int,
3988 __decpt: *mut ::std::os::raw::c_int,
3989 __sign: *mut ::std::os::raw::c_int,
3990 __buf: *mut ::std::os::raw::c_char,
3991 __len: usize,
3992 ) -> ::std::os::raw::c_int;
3993}
3994extern "C" {
3995 pub fn qfcvt_r(
3996 __value: u128,
3997 __ndigit: ::std::os::raw::c_int,
3998 __decpt: *mut ::std::os::raw::c_int,
3999 __sign: *mut ::std::os::raw::c_int,
4000 __buf: *mut ::std::os::raw::c_char,
4001 __len: usize,
4002 ) -> ::std::os::raw::c_int;
4003}
4004extern "C" {
4005 pub fn mblen(__s: *const ::std::os::raw::c_char, __n: usize) -> ::std::os::raw::c_int;
4006}
4007extern "C" {
4008 pub fn mbtowc(
4009 __pwc: *mut wchar_t,
4010 __s: *const ::std::os::raw::c_char,
4011 __n: usize,
4012 ) -> ::std::os::raw::c_int;
4013}
4014extern "C" {
4015 pub fn wctomb(__s: *mut ::std::os::raw::c_char, __wchar: wchar_t) -> ::std::os::raw::c_int;
4016}
4017extern "C" {
4018 pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const ::std::os::raw::c_char, __n: usize) -> usize;
4019}
4020extern "C" {
4021 pub fn wcstombs(__s: *mut ::std::os::raw::c_char, __pwcs: *const wchar_t, __n: usize) -> usize;
4022}
4023extern "C" {
4024 pub fn rpmatch(__response: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4025}
4026extern "C" {
4027 pub fn getsubopt(
4028 __optionp: *mut *mut ::std::os::raw::c_char,
4029 __tokens: *const *mut ::std::os::raw::c_char,
4030 __valuep: *mut *mut ::std::os::raw::c_char,
4031 ) -> ::std::os::raw::c_int;
4032}
4033extern "C" {
4034 pub fn getloadavg(__loadavg: *mut f64, __nelem: ::std::os::raw::c_int)
4035 -> ::std::os::raw::c_int;
4036}
4037pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
4038#[repr(C)]
4039#[derive(Debug, Copy, Clone)]
4040pub struct __jmp_buf_tag {
4041 pub __jmpbuf: __jmp_buf,
4042 pub __mask_was_saved: ::std::os::raw::c_int,
4043 pub __saved_mask: __sigset_t,
4044}
4045#[test]
4046fn bindgen_test_layout___jmp_buf_tag() {
4047 const UNINIT: ::std::mem::MaybeUninit<__jmp_buf_tag> = ::std::mem::MaybeUninit::uninit();
4048 let ptr = UNINIT.as_ptr();
4049 assert_eq!(
4050 ::std::mem::size_of::<__jmp_buf_tag>(),
4051 200usize,
4052 concat!("Size of: ", stringify!(__jmp_buf_tag))
4053 );
4054 assert_eq!(
4055 ::std::mem::align_of::<__jmp_buf_tag>(),
4056 8usize,
4057 concat!("Alignment of ", stringify!(__jmp_buf_tag))
4058 );
4059 assert_eq!(
4060 unsafe { ::std::ptr::addr_of!((*ptr).__jmpbuf) as usize - ptr as usize },
4061 0usize,
4062 concat!(
4063 "Offset of field: ",
4064 stringify!(__jmp_buf_tag),
4065 "::",
4066 stringify!(__jmpbuf)
4067 )
4068 );
4069 assert_eq!(
4070 unsafe { ::std::ptr::addr_of!((*ptr).__mask_was_saved) as usize - ptr as usize },
4071 64usize,
4072 concat!(
4073 "Offset of field: ",
4074 stringify!(__jmp_buf_tag),
4075 "::",
4076 stringify!(__mask_was_saved)
4077 )
4078 );
4079 assert_eq!(
4080 unsafe { ::std::ptr::addr_of!((*ptr).__saved_mask) as usize - ptr as usize },
4081 72usize,
4082 concat!(
4083 "Offset of field: ",
4084 stringify!(__jmp_buf_tag),
4085 "::",
4086 stringify!(__saved_mask)
4087 )
4088 );
4089}
4090pub type jmp_buf = [__jmp_buf_tag; 1usize];
4091extern "C" {
4092 pub fn setjmp(__env: *mut __jmp_buf_tag) -> ::std::os::raw::c_int;
4093}
4094extern "C" {
4095 pub fn __sigsetjmp(
4096 __env: *mut __jmp_buf_tag,
4097 __savemask: ::std::os::raw::c_int,
4098 ) -> ::std::os::raw::c_int;
4099}
4100extern "C" {
4101 pub fn _setjmp(__env: *mut __jmp_buf_tag) -> ::std::os::raw::c_int;
4102}
4103extern "C" {
4104 pub fn longjmp(__env: *mut __jmp_buf_tag, __val: ::std::os::raw::c_int) -> !;
4105}
4106extern "C" {
4107 pub fn _longjmp(__env: *mut __jmp_buf_tag, __val: ::std::os::raw::c_int) -> !;
4108}
4109pub type sigjmp_buf = [__jmp_buf_tag; 1usize];
4110extern "C" {
4111 pub fn siglongjmp(__env: *mut __jmp_buf_tag, __val: ::std::os::raw::c_int) -> !;
4112}
4113extern "C" {
4114 pub static mut cst_errjmp: *mut jmp_buf;
4115}
4116extern "C" {
4117 pub fn cst_errmsg(fmt: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
4118}
4119extern "C" {
4120 pub fn cst_safe_alloc(size: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void;
4121}
4122extern "C" {
4123 pub fn cst_safe_calloc(size: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void;
4124}
4125extern "C" {
4126 pub fn cst_safe_realloc(
4127 p: *mut ::std::os::raw::c_void,
4128 size: ::std::os::raw::c_int,
4129 ) -> *mut ::std::os::raw::c_void;
4130}
4131pub type cst_alloc_context = *mut ::std::os::raw::c_void;
4132extern "C" {
4133 pub fn cst_free(p: *mut ::std::os::raw::c_void);
4134}
4135#[repr(C)]
4136#[derive(Debug, Copy, Clone)]
4137pub struct cst_val_cons_struct {
4138 pub car: *mut cst_val_struct,
4139 pub cdr: *mut cst_val_struct,
4140}
4141#[test]
4142fn bindgen_test_layout_cst_val_cons_struct() {
4143 const UNINIT: ::std::mem::MaybeUninit<cst_val_cons_struct> = ::std::mem::MaybeUninit::uninit();
4144 let ptr = UNINIT.as_ptr();
4145 assert_eq!(
4146 ::std::mem::size_of::<cst_val_cons_struct>(),
4147 16usize,
4148 concat!("Size of: ", stringify!(cst_val_cons_struct))
4149 );
4150 assert_eq!(
4151 ::std::mem::align_of::<cst_val_cons_struct>(),
4152 8usize,
4153 concat!("Alignment of ", stringify!(cst_val_cons_struct))
4154 );
4155 assert_eq!(
4156 unsafe { ::std::ptr::addr_of!((*ptr).car) as usize - ptr as usize },
4157 0usize,
4158 concat!(
4159 "Offset of field: ",
4160 stringify!(cst_val_cons_struct),
4161 "::",
4162 stringify!(car)
4163 )
4164 );
4165 assert_eq!(
4166 unsafe { ::std::ptr::addr_of!((*ptr).cdr) as usize - ptr as usize },
4167 8usize,
4168 concat!(
4169 "Offset of field: ",
4170 stringify!(cst_val_cons_struct),
4171 "::",
4172 stringify!(cdr)
4173 )
4174 );
4175}
4176pub type cst_val_cons = cst_val_cons_struct;
4177#[repr(C)]
4178#[derive(Copy, Clone)]
4179pub struct cst_val_atom_struct {
4180 pub type_: ::std::os::raw::c_int,
4181 pub ref_count: ::std::os::raw::c_int,
4182 pub v: cst_val_atom_struct__bindgen_ty_1,
4183}
4184#[repr(C)]
4185#[derive(Copy, Clone)]
4186pub union cst_val_atom_struct__bindgen_ty_1 {
4187 pub fval: f64,
4188 pub ival: ::std::os::raw::c_longlong,
4189 pub vval: *mut ::std::os::raw::c_void,
4190}
4191#[test]
4192fn bindgen_test_layout_cst_val_atom_struct__bindgen_ty_1() {
4193 const UNINIT: ::std::mem::MaybeUninit<cst_val_atom_struct__bindgen_ty_1> =
4194 ::std::mem::MaybeUninit::uninit();
4195 let ptr = UNINIT.as_ptr();
4196 assert_eq!(
4197 ::std::mem::size_of::<cst_val_atom_struct__bindgen_ty_1>(),
4198 8usize,
4199 concat!("Size of: ", stringify!(cst_val_atom_struct__bindgen_ty_1))
4200 );
4201 assert_eq!(
4202 ::std::mem::align_of::<cst_val_atom_struct__bindgen_ty_1>(),
4203 8usize,
4204 concat!(
4205 "Alignment of ",
4206 stringify!(cst_val_atom_struct__bindgen_ty_1)
4207 )
4208 );
4209 assert_eq!(
4210 unsafe { ::std::ptr::addr_of!((*ptr).fval) as usize - ptr as usize },
4211 0usize,
4212 concat!(
4213 "Offset of field: ",
4214 stringify!(cst_val_atom_struct__bindgen_ty_1),
4215 "::",
4216 stringify!(fval)
4217 )
4218 );
4219 assert_eq!(
4220 unsafe { ::std::ptr::addr_of!((*ptr).ival) as usize - ptr as usize },
4221 0usize,
4222 concat!(
4223 "Offset of field: ",
4224 stringify!(cst_val_atom_struct__bindgen_ty_1),
4225 "::",
4226 stringify!(ival)
4227 )
4228 );
4229 assert_eq!(
4230 unsafe { ::std::ptr::addr_of!((*ptr).vval) as usize - ptr as usize },
4231 0usize,
4232 concat!(
4233 "Offset of field: ",
4234 stringify!(cst_val_atom_struct__bindgen_ty_1),
4235 "::",
4236 stringify!(vval)
4237 )
4238 );
4239}
4240#[test]
4241fn bindgen_test_layout_cst_val_atom_struct() {
4242 const UNINIT: ::std::mem::MaybeUninit<cst_val_atom_struct> = ::std::mem::MaybeUninit::uninit();
4243 let ptr = UNINIT.as_ptr();
4244 assert_eq!(
4245 ::std::mem::size_of::<cst_val_atom_struct>(),
4246 16usize,
4247 concat!("Size of: ", stringify!(cst_val_atom_struct))
4248 );
4249 assert_eq!(
4250 ::std::mem::align_of::<cst_val_atom_struct>(),
4251 8usize,
4252 concat!("Alignment of ", stringify!(cst_val_atom_struct))
4253 );
4254 assert_eq!(
4255 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
4256 0usize,
4257 concat!(
4258 "Offset of field: ",
4259 stringify!(cst_val_atom_struct),
4260 "::",
4261 stringify!(type_)
4262 )
4263 );
4264 assert_eq!(
4265 unsafe { ::std::ptr::addr_of!((*ptr).ref_count) as usize - ptr as usize },
4266 4usize,
4267 concat!(
4268 "Offset of field: ",
4269 stringify!(cst_val_atom_struct),
4270 "::",
4271 stringify!(ref_count)
4272 )
4273 );
4274 assert_eq!(
4275 unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
4276 8usize,
4277 concat!(
4278 "Offset of field: ",
4279 stringify!(cst_val_atom_struct),
4280 "::",
4281 stringify!(v)
4282 )
4283 );
4284}
4285pub type cst_val_atom = cst_val_atom_struct;
4286#[repr(C)]
4287#[derive(Copy, Clone)]
4288pub struct cst_val_struct {
4289 pub c: cst_val_struct__bindgen_ty_1,
4290}
4291#[repr(C)]
4292#[derive(Copy, Clone)]
4293pub union cst_val_struct__bindgen_ty_1 {
4294 pub cc: cst_val_cons,
4295 pub a: cst_val_atom,
4296}
4297#[test]
4298fn bindgen_test_layout_cst_val_struct__bindgen_ty_1() {
4299 const UNINIT: ::std::mem::MaybeUninit<cst_val_struct__bindgen_ty_1> =
4300 ::std::mem::MaybeUninit::uninit();
4301 let ptr = UNINIT.as_ptr();
4302 assert_eq!(
4303 ::std::mem::size_of::<cst_val_struct__bindgen_ty_1>(),
4304 16usize,
4305 concat!("Size of: ", stringify!(cst_val_struct__bindgen_ty_1))
4306 );
4307 assert_eq!(
4308 ::std::mem::align_of::<cst_val_struct__bindgen_ty_1>(),
4309 8usize,
4310 concat!("Alignment of ", stringify!(cst_val_struct__bindgen_ty_1))
4311 );
4312 assert_eq!(
4313 unsafe { ::std::ptr::addr_of!((*ptr).cc) as usize - ptr as usize },
4314 0usize,
4315 concat!(
4316 "Offset of field: ",
4317 stringify!(cst_val_struct__bindgen_ty_1),
4318 "::",
4319 stringify!(cc)
4320 )
4321 );
4322 assert_eq!(
4323 unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
4324 0usize,
4325 concat!(
4326 "Offset of field: ",
4327 stringify!(cst_val_struct__bindgen_ty_1),
4328 "::",
4329 stringify!(a)
4330 )
4331 );
4332}
4333#[test]
4334fn bindgen_test_layout_cst_val_struct() {
4335 const UNINIT: ::std::mem::MaybeUninit<cst_val_struct> = ::std::mem::MaybeUninit::uninit();
4336 let ptr = UNINIT.as_ptr();
4337 assert_eq!(
4338 ::std::mem::size_of::<cst_val_struct>(),
4339 16usize,
4340 concat!("Size of: ", stringify!(cst_val_struct))
4341 );
4342 assert_eq!(
4343 ::std::mem::align_of::<cst_val_struct>(),
4344 8usize,
4345 concat!("Alignment of ", stringify!(cst_val_struct))
4346 );
4347 assert_eq!(
4348 unsafe { ::std::ptr::addr_of!((*ptr).c) as usize - ptr as usize },
4349 0usize,
4350 concat!(
4351 "Offset of field: ",
4352 stringify!(cst_val_struct),
4353 "::",
4354 stringify!(c)
4355 )
4356 );
4357}
4358pub type cst_val = cst_val_struct;
4359#[repr(C)]
4360#[derive(Debug, Copy, Clone)]
4361pub struct cst_val_def_struct {
4362 pub name: *const ::std::os::raw::c_char,
4363 pub delete_function:
4364 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4365}
4366#[test]
4367fn bindgen_test_layout_cst_val_def_struct() {
4368 const UNINIT: ::std::mem::MaybeUninit<cst_val_def_struct> = ::std::mem::MaybeUninit::uninit();
4369 let ptr = UNINIT.as_ptr();
4370 assert_eq!(
4371 ::std::mem::size_of::<cst_val_def_struct>(),
4372 16usize,
4373 concat!("Size of: ", stringify!(cst_val_def_struct))
4374 );
4375 assert_eq!(
4376 ::std::mem::align_of::<cst_val_def_struct>(),
4377 8usize,
4378 concat!("Alignment of ", stringify!(cst_val_def_struct))
4379 );
4380 assert_eq!(
4381 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
4382 0usize,
4383 concat!(
4384 "Offset of field: ",
4385 stringify!(cst_val_def_struct),
4386 "::",
4387 stringify!(name)
4388 )
4389 );
4390 assert_eq!(
4391 unsafe { ::std::ptr::addr_of!((*ptr).delete_function) as usize - ptr as usize },
4392 8usize,
4393 concat!(
4394 "Offset of field: ",
4395 stringify!(cst_val_def_struct),
4396 "::",
4397 stringify!(delete_function)
4398 )
4399 );
4400}
4401pub type cst_val_def = cst_val_def_struct;
4402extern "C" {
4403 pub fn int_val(i: ::std::os::raw::c_int) -> *mut cst_val;
4404}
4405extern "C" {
4406 pub fn float_val(f: f32) -> *mut cst_val;
4407}
4408extern "C" {
4409 pub fn string_val(s: *const ::std::os::raw::c_char) -> *mut cst_val;
4410}
4411extern "C" {
4412 pub fn val_new_typed(
4413 type_: ::std::os::raw::c_int,
4414 vv: *mut ::std::os::raw::c_void,
4415 ) -> *mut cst_val;
4416}
4417extern "C" {
4418 pub fn cons_val(a: *const cst_val, b: *const cst_val) -> *mut cst_val;
4419}
4420extern "C" {
4421 pub fn delete_val(val: *mut cst_val);
4422}
4423extern "C" {
4424 pub fn delete_val_list(val: *mut cst_val);
4425}
4426extern "C" {
4427 pub fn val_int(v: *const cst_val) -> ::std::os::raw::c_int;
4428}
4429extern "C" {
4430 pub fn val_float(v: *const cst_val) -> f32;
4431}
4432extern "C" {
4433 pub fn val_string(v: *const cst_val) -> *const ::std::os::raw::c_char;
4434}
4435extern "C" {
4436 pub fn val_void(v: *const cst_val) -> *mut ::std::os::raw::c_void;
4437}
4438extern "C" {
4439 pub fn val_generic(
4440 v: *const cst_val,
4441 type_: ::std::os::raw::c_int,
4442 stype: *const ::std::os::raw::c_char,
4443 ) -> *mut ::std::os::raw::c_void;
4444}
4445extern "C" {
4446 pub fn val_car(v: *const cst_val) -> *const cst_val;
4447}
4448extern "C" {
4449 pub fn val_cdr(v: *const cst_val) -> *const cst_val;
4450}
4451extern "C" {
4452 pub fn set_cdr(v1: *mut cst_val, v2: *const cst_val) -> *const cst_val;
4453}
4454extern "C" {
4455 pub fn set_car(v1: *mut cst_val, v2: *const cst_val) -> *const cst_val;
4456}
4457extern "C" {
4458 pub fn cst_val_consp(v: *const cst_val) -> ::std::os::raw::c_int;
4459}
4460extern "C" {
4461 pub fn val_equal(a: *const cst_val, b: *const cst_val) -> ::std::os::raw::c_int;
4462}
4463extern "C" {
4464 pub fn val_less(a: *const cst_val, b: *const cst_val) -> ::std::os::raw::c_int;
4465}
4466extern "C" {
4467 pub fn val_greater(a: *const cst_val, b: *const cst_val) -> ::std::os::raw::c_int;
4468}
4469extern "C" {
4470 pub fn val_member(a: *const cst_val, b: *const cst_val) -> ::std::os::raw::c_int;
4471}
4472extern "C" {
4473 pub fn val_member_string(
4474 a: *const ::std::os::raw::c_char,
4475 b: *const cst_val,
4476 ) -> ::std::os::raw::c_int;
4477}
4478extern "C" {
4479 pub fn val_stringp(a: *const cst_val) -> ::std::os::raw::c_int;
4480}
4481extern "C" {
4482 pub fn val_assoc_string(
4483 v1: *const ::std::os::raw::c_char,
4484 al: *const cst_val,
4485 ) -> *const cst_val;
4486}
4487extern "C" {
4488 pub fn val_print(fd: cst_file, v: *const cst_val);
4489}
4490extern "C" {
4491 pub fn val_readlist_string(str_: *const ::std::os::raw::c_char) -> *mut cst_val;
4492}
4493extern "C" {
4494 pub fn val_reverse(v: *mut cst_val) -> *mut cst_val;
4495}
4496extern "C" {
4497 pub fn val_append(a: *mut cst_val, b: *mut cst_val) -> *mut cst_val;
4498}
4499extern "C" {
4500 pub fn val_length(l: *const cst_val) -> ::std::os::raw::c_int;
4501}
4502extern "C" {
4503 pub fn cst_utf8_explode(utf8string: *const cst_string) -> *mut cst_val;
4504}
4505extern "C" {
4506 pub fn cst_implode(string_list: *const cst_val) -> *mut cst_string;
4507}
4508extern "C" {
4509 pub fn cst_utf8_ord(utf8_char: *const cst_val) -> *mut cst_val;
4510}
4511extern "C" {
4512 pub fn cst_utf8_chr(ord: *const cst_val) -> *mut cst_val;
4513}
4514extern "C" {
4515 pub fn cst_utf8_ord_string(utf8_char: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
4516}
4517extern "C" {
4518 pub fn val_dec_refcount(b: *const cst_val) -> ::std::os::raw::c_int;
4519}
4520extern "C" {
4521 pub fn val_inc_refcount(b: *const cst_val) -> *mut cst_val;
4522}
4523extern "C" {
4524 pub static val_int_0: cst_val;
4525}
4526extern "C" {
4527 pub static val_int_1: cst_val;
4528}
4529extern "C" {
4530 pub static val_int_2: cst_val;
4531}
4532extern "C" {
4533 pub static val_int_3: cst_val;
4534}
4535extern "C" {
4536 pub static val_int_4: cst_val;
4537}
4538extern "C" {
4539 pub static val_int_5: cst_val;
4540}
4541extern "C" {
4542 pub static val_int_6: cst_val;
4543}
4544extern "C" {
4545 pub static val_int_7: cst_val;
4546}
4547extern "C" {
4548 pub static val_int_8: cst_val;
4549}
4550extern "C" {
4551 pub static val_int_9: cst_val;
4552}
4553extern "C" {
4554 pub static val_int_10: cst_val;
4555}
4556extern "C" {
4557 pub static val_int_11: cst_val;
4558}
4559extern "C" {
4560 pub static val_int_12: cst_val;
4561}
4562extern "C" {
4563 pub static val_int_13: cst_val;
4564}
4565extern "C" {
4566 pub static val_int_14: cst_val;
4567}
4568extern "C" {
4569 pub static val_int_15: cst_val;
4570}
4571extern "C" {
4572 pub static val_int_16: cst_val;
4573}
4574extern "C" {
4575 pub static val_int_17: cst_val;
4576}
4577extern "C" {
4578 pub static val_int_18: cst_val;
4579}
4580extern "C" {
4581 pub static val_int_19: cst_val;
4582}
4583extern "C" {
4584 pub static val_int_20: cst_val;
4585}
4586extern "C" {
4587 pub static val_int_21: cst_val;
4588}
4589extern "C" {
4590 pub static val_int_22: cst_val;
4591}
4592extern "C" {
4593 pub static val_int_23: cst_val;
4594}
4595extern "C" {
4596 pub static val_int_24: cst_val;
4597}
4598extern "C" {
4599 pub static val_string_0: cst_val;
4600}
4601extern "C" {
4602 pub static val_string_1: cst_val;
4603}
4604extern "C" {
4605 pub static val_string_2: cst_val;
4606}
4607extern "C" {
4608 pub static val_string_3: cst_val;
4609}
4610extern "C" {
4611 pub static val_string_4: cst_val;
4612}
4613extern "C" {
4614 pub static val_string_5: cst_val;
4615}
4616extern "C" {
4617 pub static val_string_6: cst_val;
4618}
4619extern "C" {
4620 pub static val_string_7: cst_val;
4621}
4622extern "C" {
4623 pub static val_string_8: cst_val;
4624}
4625extern "C" {
4626 pub static val_string_9: cst_val;
4627}
4628extern "C" {
4629 pub static val_string_10: cst_val;
4630}
4631extern "C" {
4632 pub static val_string_11: cst_val;
4633}
4634extern "C" {
4635 pub static val_string_12: cst_val;
4636}
4637extern "C" {
4638 pub static val_string_13: cst_val;
4639}
4640extern "C" {
4641 pub static val_string_14: cst_val;
4642}
4643extern "C" {
4644 pub static val_string_15: cst_val;
4645}
4646extern "C" {
4647 pub static val_string_16: cst_val;
4648}
4649extern "C" {
4650 pub static val_string_17: cst_val;
4651}
4652extern "C" {
4653 pub static val_string_18: cst_val;
4654}
4655extern "C" {
4656 pub static val_string_19: cst_val;
4657}
4658extern "C" {
4659 pub static val_string_20: cst_val;
4660}
4661extern "C" {
4662 pub static val_string_21: cst_val;
4663}
4664extern "C" {
4665 pub static val_string_22: cst_val;
4666}
4667extern "C" {
4668 pub static val_string_23: cst_val;
4669}
4670extern "C" {
4671 pub static val_string_24: cst_val;
4672}
4673extern "C" {
4674 pub fn val_int_n(n: ::std::os::raw::c_int) -> *const cst_val;
4675}
4676extern "C" {
4677 pub fn val_string_n(n: ::std::os::raw::c_int) -> *const cst_val;
4678}
4679extern "C" {
4680 pub static cst_val_defs: [cst_val_def; 0usize];
4681}
4682pub type cst_userdata = ::std::os::raw::c_void;
4683extern "C" {
4684 pub static cst_val_type_userdata: ::std::os::raw::c_int;
4685}
4686extern "C" {
4687 pub fn val_userdata(v: *const cst_val) -> *mut cst_userdata;
4688}
4689extern "C" {
4690 pub fn userdata_val(v: *const cst_userdata) -> *mut cst_val;
4691}
4692#[repr(C)]
4693#[derive(Debug, Copy, Clone)]
4694pub struct cst_featvalpair_struct {
4695 pub name: *const ::std::os::raw::c_char,
4696 pub val: *mut cst_val,
4697 pub next: *mut cst_featvalpair_struct,
4698}
4699#[test]
4700fn bindgen_test_layout_cst_featvalpair_struct() {
4701 const UNINIT: ::std::mem::MaybeUninit<cst_featvalpair_struct> =
4702 ::std::mem::MaybeUninit::uninit();
4703 let ptr = UNINIT.as_ptr();
4704 assert_eq!(
4705 ::std::mem::size_of::<cst_featvalpair_struct>(),
4706 24usize,
4707 concat!("Size of: ", stringify!(cst_featvalpair_struct))
4708 );
4709 assert_eq!(
4710 ::std::mem::align_of::<cst_featvalpair_struct>(),
4711 8usize,
4712 concat!("Alignment of ", stringify!(cst_featvalpair_struct))
4713 );
4714 assert_eq!(
4715 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
4716 0usize,
4717 concat!(
4718 "Offset of field: ",
4719 stringify!(cst_featvalpair_struct),
4720 "::",
4721 stringify!(name)
4722 )
4723 );
4724 assert_eq!(
4725 unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
4726 8usize,
4727 concat!(
4728 "Offset of field: ",
4729 stringify!(cst_featvalpair_struct),
4730 "::",
4731 stringify!(val)
4732 )
4733 );
4734 assert_eq!(
4735 unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
4736 16usize,
4737 concat!(
4738 "Offset of field: ",
4739 stringify!(cst_featvalpair_struct),
4740 "::",
4741 stringify!(next)
4742 )
4743 );
4744}
4745pub type cst_featvalpair = cst_featvalpair_struct;
4746#[repr(C)]
4747#[derive(Debug, Copy, Clone)]
4748pub struct cst_features_struct {
4749 pub head: *mut cst_featvalpair_struct,
4750 pub ctx: cst_alloc_context,
4751 pub owned_strings: *mut cst_val,
4752 pub linked: *const cst_features_struct,
4753}
4754#[test]
4755fn bindgen_test_layout_cst_features_struct() {
4756 const UNINIT: ::std::mem::MaybeUninit<cst_features_struct> = ::std::mem::MaybeUninit::uninit();
4757 let ptr = UNINIT.as_ptr();
4758 assert_eq!(
4759 ::std::mem::size_of::<cst_features_struct>(),
4760 32usize,
4761 concat!("Size of: ", stringify!(cst_features_struct))
4762 );
4763 assert_eq!(
4764 ::std::mem::align_of::<cst_features_struct>(),
4765 8usize,
4766 concat!("Alignment of ", stringify!(cst_features_struct))
4767 );
4768 assert_eq!(
4769 unsafe { ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
4770 0usize,
4771 concat!(
4772 "Offset of field: ",
4773 stringify!(cst_features_struct),
4774 "::",
4775 stringify!(head)
4776 )
4777 );
4778 assert_eq!(
4779 unsafe { ::std::ptr::addr_of!((*ptr).ctx) as usize - ptr as usize },
4780 8usize,
4781 concat!(
4782 "Offset of field: ",
4783 stringify!(cst_features_struct),
4784 "::",
4785 stringify!(ctx)
4786 )
4787 );
4788 assert_eq!(
4789 unsafe { ::std::ptr::addr_of!((*ptr).owned_strings) as usize - ptr as usize },
4790 16usize,
4791 concat!(
4792 "Offset of field: ",
4793 stringify!(cst_features_struct),
4794 "::",
4795 stringify!(owned_strings)
4796 )
4797 );
4798 assert_eq!(
4799 unsafe { ::std::ptr::addr_of!((*ptr).linked) as usize - ptr as usize },
4800 24usize,
4801 concat!(
4802 "Offset of field: ",
4803 stringify!(cst_features_struct),
4804 "::",
4805 stringify!(linked)
4806 )
4807 );
4808}
4809pub type cst_features = cst_features_struct;
4810extern "C" {
4811 pub fn new_features() -> *mut cst_features;
4812}
4813extern "C" {
4814 pub fn new_features_local(ctx: cst_alloc_context) -> *mut cst_features;
4815}
4816extern "C" {
4817 pub fn delete_features(f: *mut cst_features);
4818}
4819extern "C" {
4820 pub fn feat_int(
4821 f: *const cst_features,
4822 name: *const ::std::os::raw::c_char,
4823 ) -> ::std::os::raw::c_int;
4824}
4825extern "C" {
4826 pub fn feat_float(f: *const cst_features, name: *const ::std::os::raw::c_char) -> f32;
4827}
4828extern "C" {
4829 pub fn feat_string(
4830 f: *const cst_features,
4831 name: *const ::std::os::raw::c_char,
4832 ) -> *const ::std::os::raw::c_char;
4833}
4834extern "C" {
4835 pub fn feat_val(f: *const cst_features, name: *const ::std::os::raw::c_char) -> *const cst_val;
4836}
4837extern "C" {
4838 pub fn get_param_int(
4839 f: *const cst_features,
4840 name: *const ::std::os::raw::c_char,
4841 def: ::std::os::raw::c_int,
4842 ) -> ::std::os::raw::c_int;
4843}
4844extern "C" {
4845 pub fn get_param_float(
4846 f: *const cst_features,
4847 name: *const ::std::os::raw::c_char,
4848 def: f32,
4849 ) -> f32;
4850}
4851extern "C" {
4852 pub fn get_param_string(
4853 f: *const cst_features,
4854 name: *const ::std::os::raw::c_char,
4855 def: *const ::std::os::raw::c_char,
4856 ) -> *const ::std::os::raw::c_char;
4857}
4858extern "C" {
4859 pub fn get_param_val(
4860 f: *const cst_features,
4861 name: *const ::std::os::raw::c_char,
4862 def: *mut cst_val,
4863 ) -> *const cst_val;
4864}
4865extern "C" {
4866 pub fn feat_set_int(
4867 f: *mut cst_features,
4868 name: *const ::std::os::raw::c_char,
4869 v: ::std::os::raw::c_int,
4870 );
4871}
4872extern "C" {
4873 pub fn feat_set_float(f: *mut cst_features, name: *const ::std::os::raw::c_char, v: f32);
4874}
4875extern "C" {
4876 pub fn feat_set_string(
4877 f: *mut cst_features,
4878 name: *const ::std::os::raw::c_char,
4879 v: *const ::std::os::raw::c_char,
4880 );
4881}
4882extern "C" {
4883 pub fn feat_set(f: *mut cst_features, name: *const ::std::os::raw::c_char, v: *const cst_val);
4884}
4885extern "C" {
4886 pub fn feat_remove(
4887 f: *mut cst_features,
4888 name: *const ::std::os::raw::c_char,
4889 ) -> ::std::os::raw::c_int;
4890}
4891extern "C" {
4892 pub fn feat_present(
4893 f: *const cst_features,
4894 name: *const ::std::os::raw::c_char,
4895 ) -> ::std::os::raw::c_int;
4896}
4897extern "C" {
4898 pub fn feat_length(f: *const cst_features) -> ::std::os::raw::c_int;
4899}
4900extern "C" {
4901 pub fn feat_own_string(
4902 f: *mut cst_features,
4903 name: *const ::std::os::raw::c_char,
4904 ) -> *const ::std::os::raw::c_char;
4905}
4906extern "C" {
4907 pub static cst_val_type_features: ::std::os::raw::c_int;
4908}
4909extern "C" {
4910 pub fn val_features(v: *const cst_val) -> *mut cst_features;
4911}
4912extern "C" {
4913 pub fn features_val(v: *const cst_features) -> *mut cst_val;
4914}
4915extern "C" {
4916 pub fn feat_copy_into(
4917 from: *const cst_features,
4918 to: *mut cst_features,
4919 ) -> ::std::os::raw::c_int;
4920}
4921extern "C" {
4922 pub fn feat_link_into(
4923 from: *const cst_features,
4924 to: *mut cst_features,
4925 ) -> ::std::os::raw::c_int;
4926}
4927extern "C" {
4928 pub fn cst_feat_print(fd: cst_file, f: *const cst_features) -> ::std::os::raw::c_int;
4929}
4930pub type cst_relation = cst_relation_struct;
4931pub type cst_utterance = cst_utterance_struct;
4932pub type cst_item = cst_item_struct;
4933extern "C" {
4934 pub static cst_val_type_relation: ::std::os::raw::c_int;
4935}
4936extern "C" {
4937 pub fn val_relation(v: *const cst_val) -> *mut cst_relation;
4938}
4939extern "C" {
4940 pub fn relation_val(v: *const cst_relation) -> *mut cst_val;
4941}
4942extern "C" {
4943 pub static cst_val_type_item: ::std::os::raw::c_int;
4944}
4945extern "C" {
4946 pub fn val_item(v: *const cst_val) -> *mut cst_item;
4947}
4948extern "C" {
4949 pub fn item_val(v: *const cst_item) -> *mut cst_val;
4950}
4951extern "C" {
4952 pub static cst_val_type_utterance: ::std::os::raw::c_int;
4953}
4954extern "C" {
4955 pub fn val_utterance(v: *const cst_val) -> *mut cst_utterance;
4956}
4957extern "C" {
4958 pub fn utterance_val(v: *const cst_utterance) -> *mut cst_val;
4959}
4960#[repr(C)]
4961#[derive(Debug, Copy, Clone)]
4962pub struct cst_item_contents_struct {
4963 pub features: *mut cst_features,
4964 pub relations: *mut cst_features,
4965}
4966#[test]
4967fn bindgen_test_layout_cst_item_contents_struct() {
4968 const UNINIT: ::std::mem::MaybeUninit<cst_item_contents_struct> =
4969 ::std::mem::MaybeUninit::uninit();
4970 let ptr = UNINIT.as_ptr();
4971 assert_eq!(
4972 ::std::mem::size_of::<cst_item_contents_struct>(),
4973 16usize,
4974 concat!("Size of: ", stringify!(cst_item_contents_struct))
4975 );
4976 assert_eq!(
4977 ::std::mem::align_of::<cst_item_contents_struct>(),
4978 8usize,
4979 concat!("Alignment of ", stringify!(cst_item_contents_struct))
4980 );
4981 assert_eq!(
4982 unsafe { ::std::ptr::addr_of!((*ptr).features) as usize - ptr as usize },
4983 0usize,
4984 concat!(
4985 "Offset of field: ",
4986 stringify!(cst_item_contents_struct),
4987 "::",
4988 stringify!(features)
4989 )
4990 );
4991 assert_eq!(
4992 unsafe { ::std::ptr::addr_of!((*ptr).relations) as usize - ptr as usize },
4993 8usize,
4994 concat!(
4995 "Offset of field: ",
4996 stringify!(cst_item_contents_struct),
4997 "::",
4998 stringify!(relations)
4999 )
5000 );
5001}
5002pub type cst_item_contents = cst_item_contents_struct;
5003#[repr(C)]
5004#[derive(Debug, Copy, Clone)]
5005pub struct cst_item_struct {
5006 pub contents: *mut cst_item_contents,
5007 pub relation: *mut cst_relation,
5008 pub n: *mut cst_item,
5009 pub p: *mut cst_item,
5010 pub u: *mut cst_item,
5011 pub d: *mut cst_item,
5012}
5013#[test]
5014fn bindgen_test_layout_cst_item_struct() {
5015 const UNINIT: ::std::mem::MaybeUninit<cst_item_struct> = ::std::mem::MaybeUninit::uninit();
5016 let ptr = UNINIT.as_ptr();
5017 assert_eq!(
5018 ::std::mem::size_of::<cst_item_struct>(),
5019 48usize,
5020 concat!("Size of: ", stringify!(cst_item_struct))
5021 );
5022 assert_eq!(
5023 ::std::mem::align_of::<cst_item_struct>(),
5024 8usize,
5025 concat!("Alignment of ", stringify!(cst_item_struct))
5026 );
5027 assert_eq!(
5028 unsafe { ::std::ptr::addr_of!((*ptr).contents) as usize - ptr as usize },
5029 0usize,
5030 concat!(
5031 "Offset of field: ",
5032 stringify!(cst_item_struct),
5033 "::",
5034 stringify!(contents)
5035 )
5036 );
5037 assert_eq!(
5038 unsafe { ::std::ptr::addr_of!((*ptr).relation) as usize - ptr as usize },
5039 8usize,
5040 concat!(
5041 "Offset of field: ",
5042 stringify!(cst_item_struct),
5043 "::",
5044 stringify!(relation)
5045 )
5046 );
5047 assert_eq!(
5048 unsafe { ::std::ptr::addr_of!((*ptr).n) as usize - ptr as usize },
5049 16usize,
5050 concat!(
5051 "Offset of field: ",
5052 stringify!(cst_item_struct),
5053 "::",
5054 stringify!(n)
5055 )
5056 );
5057 assert_eq!(
5058 unsafe { ::std::ptr::addr_of!((*ptr).p) as usize - ptr as usize },
5059 24usize,
5060 concat!(
5061 "Offset of field: ",
5062 stringify!(cst_item_struct),
5063 "::",
5064 stringify!(p)
5065 )
5066 );
5067 assert_eq!(
5068 unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
5069 32usize,
5070 concat!(
5071 "Offset of field: ",
5072 stringify!(cst_item_struct),
5073 "::",
5074 stringify!(u)
5075 )
5076 );
5077 assert_eq!(
5078 unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
5079 40usize,
5080 concat!(
5081 "Offset of field: ",
5082 stringify!(cst_item_struct),
5083 "::",
5084 stringify!(d)
5085 )
5086 );
5087}
5088extern "C" {
5089 pub fn new_item_relation(r: *mut cst_relation, i: *mut cst_item) -> *mut cst_item;
5090}
5091extern "C" {
5092 pub fn new_item_contents(i: *mut cst_item) -> *mut cst_item_contents;
5093}
5094extern "C" {
5095 pub fn delete_item(item: *mut cst_item);
5096}
5097extern "C" {
5098 pub fn item_contents_set(current: *mut cst_item, i: *mut cst_item);
5099}
5100extern "C" {
5101 pub fn item_unref_contents(i: *mut cst_item);
5102}
5103extern "C" {
5104 pub fn item_as(i: *const cst_item, rname: *const ::std::os::raw::c_char) -> *mut cst_item;
5105}
5106extern "C" {
5107 pub fn item_utt(i: *const cst_item) -> *mut cst_utterance;
5108}
5109extern "C" {
5110 pub fn item_next(i: *const cst_item) -> *mut cst_item;
5111}
5112extern "C" {
5113 pub fn item_prev(i: *const cst_item) -> *mut cst_item;
5114}
5115extern "C" {
5116 pub fn item_append(i: *mut cst_item, new_item: *mut cst_item) -> *mut cst_item;
5117}
5118extern "C" {
5119 pub fn item_prepend(i: *mut cst_item, new_item: *mut cst_item) -> *mut cst_item;
5120}
5121extern "C" {
5122 pub fn item_parent(i: *const cst_item) -> *mut cst_item;
5123}
5124extern "C" {
5125 pub fn item_nth_daughter(i: *const cst_item, n: ::std::os::raw::c_int) -> *mut cst_item;
5126}
5127extern "C" {
5128 pub fn item_daughter(i: *const cst_item) -> *mut cst_item;
5129}
5130extern "C" {
5131 pub fn item_last_daughter(i: *const cst_item) -> *mut cst_item;
5132}
5133extern "C" {
5134 pub fn item_first(i: *const cst_item) -> *mut cst_item;
5135}
5136extern "C" {
5137 pub fn item_last(i: *const cst_item) -> *mut cst_item;
5138}
5139extern "C" {
5140 pub fn item_add_daughter(i: *mut cst_item, new_item: *mut cst_item) -> *mut cst_item;
5141}
5142extern "C" {
5143 pub fn item_append_sibling(i: *mut cst_item, new_item: *mut cst_item) -> *mut cst_item;
5144}
5145extern "C" {
5146 pub fn item_prepend_sibling(i: *mut cst_item, new_item: *mut cst_item) -> *mut cst_item;
5147}
5148extern "C" {
5149 pub fn item_feat_present(
5150 i: *const cst_item,
5151 name: *const ::std::os::raw::c_char,
5152 ) -> ::std::os::raw::c_int;
5153}
5154extern "C" {
5155 pub fn item_feat_remove(
5156 i: *const cst_item,
5157 name: *const ::std::os::raw::c_char,
5158 ) -> ::std::os::raw::c_int;
5159}
5160extern "C" {
5161 pub fn item_feats(i: *const cst_item) -> *mut cst_features;
5162}
5163extern "C" {
5164 pub fn item_feat(i: *const cst_item, name: *const ::std::os::raw::c_char) -> *const cst_val;
5165}
5166extern "C" {
5167 pub fn item_feat_int(
5168 i: *const cst_item,
5169 name: *const ::std::os::raw::c_char,
5170 ) -> ::std::os::raw::c_int;
5171}
5172extern "C" {
5173 pub fn item_feat_float(i: *const cst_item, name: *const ::std::os::raw::c_char) -> f32;
5174}
5175extern "C" {
5176 pub fn item_feat_string(
5177 i: *const cst_item,
5178 name: *const ::std::os::raw::c_char,
5179 ) -> *const ::std::os::raw::c_char;
5180}
5181extern "C" {
5182 pub fn item_set(i: *const cst_item, name: *const ::std::os::raw::c_char, val: *const cst_val);
5183}
5184extern "C" {
5185 pub fn item_set_int(
5186 i: *const cst_item,
5187 name: *const ::std::os::raw::c_char,
5188 val: ::std::os::raw::c_int,
5189 );
5190}
5191extern "C" {
5192 pub fn item_set_float(i: *const cst_item, name: *const ::std::os::raw::c_char, val: f32);
5193}
5194extern "C" {
5195 pub fn item_set_string(
5196 i: *const cst_item,
5197 name: *const ::std::os::raw::c_char,
5198 val: *const ::std::os::raw::c_char,
5199 );
5200}
5201extern "C" {
5202 pub fn item_equal(a: *const cst_item, b: *const cst_item) -> ::std::os::raw::c_int;
5203}
5204extern "C" {
5205 pub fn ffeature_string(
5206 item: *const cst_item,
5207 featpath: *const ::std::os::raw::c_char,
5208 ) -> *const ::std::os::raw::c_char;
5209}
5210extern "C" {
5211 pub fn ffeature_int(
5212 item: *const cst_item,
5213 featpath: *const ::std::os::raw::c_char,
5214 ) -> ::std::os::raw::c_int;
5215}
5216extern "C" {
5217 pub fn ffeature_float(item: *const cst_item, featpath: *const ::std::os::raw::c_char) -> f32;
5218}
5219extern "C" {
5220 pub fn ffeature(
5221 item: *const cst_item,
5222 featpath: *const ::std::os::raw::c_char,
5223 ) -> *const cst_val;
5224}
5225extern "C" {
5226 pub fn path_to_item(
5227 item: *const cst_item,
5228 featpath: *const ::std::os::raw::c_char,
5229 ) -> *mut cst_item;
5230}
5231pub type cst_ffunction =
5232 ::std::option::Option<unsafe extern "C" fn(i: *const cst_item) -> *const cst_val>;
5233extern "C" {
5234 pub static cst_val_type_ffunc: ::std::os::raw::c_int;
5235}
5236extern "C" {
5237 pub fn val_ffunc(v: *const cst_val) -> cst_ffunction;
5238}
5239extern "C" {
5240 pub fn ffunc_val(v: cst_ffunction) -> *mut cst_val;
5241}
5242extern "C" {
5243 pub fn ff_register(
5244 ffeatures: *mut cst_features,
5245 name: *const ::std::os::raw::c_char,
5246 f: cst_ffunction,
5247 );
5248}
5249extern "C" {
5250 pub fn ff_unregister(ffeatures: *mut cst_features, name: *const ::std::os::raw::c_char);
5251}
5252pub type cst_itemfunc =
5253 ::std::option::Option<unsafe extern "C" fn(i: *mut cst_item) -> *mut cst_val>;
5254extern "C" {
5255 pub static cst_val_type_itemfunc: ::std::os::raw::c_int;
5256}
5257extern "C" {
5258 pub fn val_itemfunc(v: *const cst_val) -> cst_itemfunc;
5259}
5260extern "C" {
5261 pub fn itemfunc_val(v: cst_itemfunc) -> *mut cst_val;
5262}
5263#[repr(C)]
5264#[derive(Debug, Copy, Clone)]
5265pub struct cst_utterance_struct {
5266 pub features: *mut cst_features,
5267 pub ffunctions: *mut cst_features,
5268 pub relations: *mut cst_features,
5269 pub ctx: cst_alloc_context,
5270}
5271#[test]
5272fn bindgen_test_layout_cst_utterance_struct() {
5273 const UNINIT: ::std::mem::MaybeUninit<cst_utterance_struct> = ::std::mem::MaybeUninit::uninit();
5274 let ptr = UNINIT.as_ptr();
5275 assert_eq!(
5276 ::std::mem::size_of::<cst_utterance_struct>(),
5277 32usize,
5278 concat!("Size of: ", stringify!(cst_utterance_struct))
5279 );
5280 assert_eq!(
5281 ::std::mem::align_of::<cst_utterance_struct>(),
5282 8usize,
5283 concat!("Alignment of ", stringify!(cst_utterance_struct))
5284 );
5285 assert_eq!(
5286 unsafe { ::std::ptr::addr_of!((*ptr).features) as usize - ptr as usize },
5287 0usize,
5288 concat!(
5289 "Offset of field: ",
5290 stringify!(cst_utterance_struct),
5291 "::",
5292 stringify!(features)
5293 )
5294 );
5295 assert_eq!(
5296 unsafe { ::std::ptr::addr_of!((*ptr).ffunctions) as usize - ptr as usize },
5297 8usize,
5298 concat!(
5299 "Offset of field: ",
5300 stringify!(cst_utterance_struct),
5301 "::",
5302 stringify!(ffunctions)
5303 )
5304 );
5305 assert_eq!(
5306 unsafe { ::std::ptr::addr_of!((*ptr).relations) as usize - ptr as usize },
5307 16usize,
5308 concat!(
5309 "Offset of field: ",
5310 stringify!(cst_utterance_struct),
5311 "::",
5312 stringify!(relations)
5313 )
5314 );
5315 assert_eq!(
5316 unsafe { ::std::ptr::addr_of!((*ptr).ctx) as usize - ptr as usize },
5317 24usize,
5318 concat!(
5319 "Offset of field: ",
5320 stringify!(cst_utterance_struct),
5321 "::",
5322 stringify!(ctx)
5323 )
5324 );
5325}
5326extern "C" {
5327 pub fn new_utterance() -> *mut cst_utterance;
5328}
5329extern "C" {
5330 pub fn delete_utterance(u: *mut cst_utterance);
5331}
5332extern "C" {
5333 pub fn utt_relation(
5334 u: *const cst_utterance,
5335 name: *const ::std::os::raw::c_char,
5336 ) -> *mut cst_relation;
5337}
5338extern "C" {
5339 pub fn utt_relation_create(
5340 u: *mut cst_utterance,
5341 name: *const ::std::os::raw::c_char,
5342 ) -> *mut cst_relation;
5343}
5344extern "C" {
5345 pub fn utt_relation_delete(
5346 u: *mut cst_utterance,
5347 name: *const ::std::os::raw::c_char,
5348 ) -> ::std::os::raw::c_int;
5349}
5350extern "C" {
5351 pub fn utt_relation_present(
5352 u: *mut cst_utterance,
5353 name: *const ::std::os::raw::c_char,
5354 ) -> ::std::os::raw::c_int;
5355}
5356pub type cst_uttfunc =
5357 ::std::option::Option<unsafe extern "C" fn(i: *mut cst_utterance) -> *mut cst_utterance>;
5358extern "C" {
5359 pub static cst_val_type_uttfunc: ::std::os::raw::c_int;
5360}
5361extern "C" {
5362 pub fn val_uttfunc(v: *const cst_val) -> cst_uttfunc;
5363}
5364extern "C" {
5365 pub fn uttfunc_val(v: cst_uttfunc) -> *mut cst_val;
5366}
5367#[repr(C)]
5368#[derive(Debug, Copy, Clone)]
5369pub struct cst_relation_struct {
5370 pub name: *mut ::std::os::raw::c_char,
5371 pub features: *mut cst_features,
5372 pub utterance: *mut cst_utterance,
5373 pub head: *mut cst_item,
5374 pub tail: *mut cst_item,
5375}
5376#[test]
5377fn bindgen_test_layout_cst_relation_struct() {
5378 const UNINIT: ::std::mem::MaybeUninit<cst_relation_struct> = ::std::mem::MaybeUninit::uninit();
5379 let ptr = UNINIT.as_ptr();
5380 assert_eq!(
5381 ::std::mem::size_of::<cst_relation_struct>(),
5382 40usize,
5383 concat!("Size of: ", stringify!(cst_relation_struct))
5384 );
5385 assert_eq!(
5386 ::std::mem::align_of::<cst_relation_struct>(),
5387 8usize,
5388 concat!("Alignment of ", stringify!(cst_relation_struct))
5389 );
5390 assert_eq!(
5391 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
5392 0usize,
5393 concat!(
5394 "Offset of field: ",
5395 stringify!(cst_relation_struct),
5396 "::",
5397 stringify!(name)
5398 )
5399 );
5400 assert_eq!(
5401 unsafe { ::std::ptr::addr_of!((*ptr).features) as usize - ptr as usize },
5402 8usize,
5403 concat!(
5404 "Offset of field: ",
5405 stringify!(cst_relation_struct),
5406 "::",
5407 stringify!(features)
5408 )
5409 );
5410 assert_eq!(
5411 unsafe { ::std::ptr::addr_of!((*ptr).utterance) as usize - ptr as usize },
5412 16usize,
5413 concat!(
5414 "Offset of field: ",
5415 stringify!(cst_relation_struct),
5416 "::",
5417 stringify!(utterance)
5418 )
5419 );
5420 assert_eq!(
5421 unsafe { ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize },
5422 24usize,
5423 concat!(
5424 "Offset of field: ",
5425 stringify!(cst_relation_struct),
5426 "::",
5427 stringify!(head)
5428 )
5429 );
5430 assert_eq!(
5431 unsafe { ::std::ptr::addr_of!((*ptr).tail) as usize - ptr as usize },
5432 32usize,
5433 concat!(
5434 "Offset of field: ",
5435 stringify!(cst_relation_struct),
5436 "::",
5437 stringify!(tail)
5438 )
5439 );
5440}
5441extern "C" {
5442 pub fn new_relation(
5443 name: *const ::std::os::raw::c_char,
5444 u: *mut cst_utterance,
5445 ) -> *mut cst_relation;
5446}
5447extern "C" {
5448 pub fn delete_relation(r: *mut cst_relation);
5449}
5450extern "C" {
5451 pub fn relation_head(r: *mut cst_relation) -> *mut cst_item;
5452}
5453extern "C" {
5454 pub fn relation_tail(r: *mut cst_relation) -> *mut cst_item;
5455}
5456extern "C" {
5457 pub fn relation_name(r: *mut cst_relation) -> *const ::std::os::raw::c_char;
5458}
5459extern "C" {
5460 pub fn relation_append(r: *mut cst_relation, i: *mut cst_item) -> *mut cst_item;
5461}
5462extern "C" {
5463 pub fn relation_prepend(r: *mut cst_relation, i: *mut cst_item) -> *mut cst_item;
5464}
5465extern "C" {
5466 pub fn relation_load(
5467 r: *mut cst_relation,
5468 filename: *const ::std::os::raw::c_char,
5469 ) -> ::std::os::raw::c_int;
5470}
5471extern "C" {
5472 pub fn relation_save(
5473 r: *mut cst_relation,
5474 filename: *const ::std::os::raw::c_char,
5475 ) -> ::std::os::raw::c_int;
5476}
5477extern "C" {
5478 pub static cst_endian_loc: ::std::os::raw::c_int;
5479}
5480extern "C" {
5481 pub fn swap_bytes_short(b: *mut ::std::os::raw::c_short, n: ::std::os::raw::c_int);
5482}
5483extern "C" {
5484 pub fn swapdouble(d: *mut f64);
5485}
5486extern "C" {
5487 pub fn swapfloat(f: *mut f32);
5488}
5489#[repr(C)]
5490#[derive(Debug, Copy, Clone)]
5491pub struct cst_wave_struct {
5492 pub type_: *const ::std::os::raw::c_char,
5493 pub sample_rate: ::std::os::raw::c_int,
5494 pub num_samples: ::std::os::raw::c_int,
5495 pub num_channels: ::std::os::raw::c_int,
5496 pub samples: *mut ::std::os::raw::c_short,
5497}
5498#[test]
5499fn bindgen_test_layout_cst_wave_struct() {
5500 const UNINIT: ::std::mem::MaybeUninit<cst_wave_struct> = ::std::mem::MaybeUninit::uninit();
5501 let ptr = UNINIT.as_ptr();
5502 assert_eq!(
5503 ::std::mem::size_of::<cst_wave_struct>(),
5504 32usize,
5505 concat!("Size of: ", stringify!(cst_wave_struct))
5506 );
5507 assert_eq!(
5508 ::std::mem::align_of::<cst_wave_struct>(),
5509 8usize,
5510 concat!("Alignment of ", stringify!(cst_wave_struct))
5511 );
5512 assert_eq!(
5513 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
5514 0usize,
5515 concat!(
5516 "Offset of field: ",
5517 stringify!(cst_wave_struct),
5518 "::",
5519 stringify!(type_)
5520 )
5521 );
5522 assert_eq!(
5523 unsafe { ::std::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
5524 8usize,
5525 concat!(
5526 "Offset of field: ",
5527 stringify!(cst_wave_struct),
5528 "::",
5529 stringify!(sample_rate)
5530 )
5531 );
5532 assert_eq!(
5533 unsafe { ::std::ptr::addr_of!((*ptr).num_samples) as usize - ptr as usize },
5534 12usize,
5535 concat!(
5536 "Offset of field: ",
5537 stringify!(cst_wave_struct),
5538 "::",
5539 stringify!(num_samples)
5540 )
5541 );
5542 assert_eq!(
5543 unsafe { ::std::ptr::addr_of!((*ptr).num_channels) as usize - ptr as usize },
5544 16usize,
5545 concat!(
5546 "Offset of field: ",
5547 stringify!(cst_wave_struct),
5548 "::",
5549 stringify!(num_channels)
5550 )
5551 );
5552 assert_eq!(
5553 unsafe { ::std::ptr::addr_of!((*ptr).samples) as usize - ptr as usize },
5554 24usize,
5555 concat!(
5556 "Offset of field: ",
5557 stringify!(cst_wave_struct),
5558 "::",
5559 stringify!(samples)
5560 )
5561 );
5562}
5563pub type cst_wave = cst_wave_struct;
5564#[repr(C)]
5565#[derive(Debug, Copy, Clone)]
5566pub struct cst_wave_header_struct {
5567 pub type_: *const ::std::os::raw::c_char,
5568 pub hsize: ::std::os::raw::c_int,
5569 pub num_bytes: ::std::os::raw::c_int,
5570 pub sample_rate: ::std::os::raw::c_int,
5571 pub num_samples: ::std::os::raw::c_int,
5572 pub num_channels: ::std::os::raw::c_int,
5573}
5574#[test]
5575fn bindgen_test_layout_cst_wave_header_struct() {
5576 const UNINIT: ::std::mem::MaybeUninit<cst_wave_header_struct> =
5577 ::std::mem::MaybeUninit::uninit();
5578 let ptr = UNINIT.as_ptr();
5579 assert_eq!(
5580 ::std::mem::size_of::<cst_wave_header_struct>(),
5581 32usize,
5582 concat!("Size of: ", stringify!(cst_wave_header_struct))
5583 );
5584 assert_eq!(
5585 ::std::mem::align_of::<cst_wave_header_struct>(),
5586 8usize,
5587 concat!("Alignment of ", stringify!(cst_wave_header_struct))
5588 );
5589 assert_eq!(
5590 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
5591 0usize,
5592 concat!(
5593 "Offset of field: ",
5594 stringify!(cst_wave_header_struct),
5595 "::",
5596 stringify!(type_)
5597 )
5598 );
5599 assert_eq!(
5600 unsafe { ::std::ptr::addr_of!((*ptr).hsize) as usize - ptr as usize },
5601 8usize,
5602 concat!(
5603 "Offset of field: ",
5604 stringify!(cst_wave_header_struct),
5605 "::",
5606 stringify!(hsize)
5607 )
5608 );
5609 assert_eq!(
5610 unsafe { ::std::ptr::addr_of!((*ptr).num_bytes) as usize - ptr as usize },
5611 12usize,
5612 concat!(
5613 "Offset of field: ",
5614 stringify!(cst_wave_header_struct),
5615 "::",
5616 stringify!(num_bytes)
5617 )
5618 );
5619 assert_eq!(
5620 unsafe { ::std::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
5621 16usize,
5622 concat!(
5623 "Offset of field: ",
5624 stringify!(cst_wave_header_struct),
5625 "::",
5626 stringify!(sample_rate)
5627 )
5628 );
5629 assert_eq!(
5630 unsafe { ::std::ptr::addr_of!((*ptr).num_samples) as usize - ptr as usize },
5631 20usize,
5632 concat!(
5633 "Offset of field: ",
5634 stringify!(cst_wave_header_struct),
5635 "::",
5636 stringify!(num_samples)
5637 )
5638 );
5639 assert_eq!(
5640 unsafe { ::std::ptr::addr_of!((*ptr).num_channels) as usize - ptr as usize },
5641 24usize,
5642 concat!(
5643 "Offset of field: ",
5644 stringify!(cst_wave_header_struct),
5645 "::",
5646 stringify!(num_channels)
5647 )
5648 );
5649}
5650pub type cst_wave_header = cst_wave_header_struct;
5651extern "C" {
5652 pub fn new_wave() -> *mut cst_wave;
5653}
5654extern "C" {
5655 pub fn copy_wave(w: *const cst_wave) -> *mut cst_wave;
5656}
5657extern "C" {
5658 pub fn delete_wave(val: *mut cst_wave);
5659}
5660extern "C" {
5661 pub fn concat_wave(dest: *mut cst_wave, src: *const cst_wave) -> *mut cst_wave;
5662}
5663extern "C" {
5664 pub fn cst_wave_save(
5665 w: *mut cst_wave,
5666 filename: *const ::std::os::raw::c_char,
5667 type_: *const ::std::os::raw::c_char,
5668 ) -> ::std::os::raw::c_int;
5669}
5670extern "C" {
5671 pub fn cst_wave_save_riff(
5672 w: *mut cst_wave,
5673 filename: *const ::std::os::raw::c_char,
5674 ) -> ::std::os::raw::c_int;
5675}
5676extern "C" {
5677 pub fn cst_wave_save_raw(
5678 w: *mut cst_wave,
5679 filename: *const ::std::os::raw::c_char,
5680 ) -> ::std::os::raw::c_int;
5681}
5682extern "C" {
5683 pub fn cst_wave_append_riff(
5684 w: *mut cst_wave,
5685 filename: *const ::std::os::raw::c_char,
5686 ) -> ::std::os::raw::c_int;
5687}
5688extern "C" {
5689 pub fn cst_wave_save_riff_fd(w: *mut cst_wave, fd: cst_file) -> ::std::os::raw::c_int;
5690}
5691extern "C" {
5692 pub fn cst_wave_save_raw_fd(w: *mut cst_wave, fd: cst_file) -> ::std::os::raw::c_int;
5693}
5694extern "C" {
5695 pub fn cst_wave_load(
5696 w: *mut cst_wave,
5697 filename: *const ::std::os::raw::c_char,
5698 type_: *const ::std::os::raw::c_char,
5699 ) -> ::std::os::raw::c_int;
5700}
5701extern "C" {
5702 pub fn cst_wave_load_riff(
5703 w: *mut cst_wave,
5704 filename: *const ::std::os::raw::c_char,
5705 ) -> ::std::os::raw::c_int;
5706}
5707extern "C" {
5708 pub fn cst_wave_load_raw(
5709 w: *mut cst_wave,
5710 filename: *const ::std::os::raw::c_char,
5711 bo: *const ::std::os::raw::c_char,
5712 sample_rate: ::std::os::raw::c_int,
5713 ) -> ::std::os::raw::c_int;
5714}
5715extern "C" {
5716 pub fn cst_wave_load_riff_header(
5717 header: *mut cst_wave_header,
5718 fd: cst_file,
5719 ) -> ::std::os::raw::c_int;
5720}
5721extern "C" {
5722 pub fn cst_wave_load_riff_fd(w: *mut cst_wave, fd: cst_file) -> ::std::os::raw::c_int;
5723}
5724extern "C" {
5725 pub fn cst_wave_load_raw_fd(
5726 w: *mut cst_wave,
5727 fd: cst_file,
5728 bo: *const ::std::os::raw::c_char,
5729 sample_rate: ::std::os::raw::c_int,
5730 ) -> ::std::os::raw::c_int;
5731}
5732extern "C" {
5733 pub fn cst_wave_resize(
5734 w: *mut cst_wave,
5735 samples: ::std::os::raw::c_int,
5736 num_channels: ::std::os::raw::c_int,
5737 );
5738}
5739extern "C" {
5740 pub fn cst_wave_resample(w: *mut cst_wave, sample_rate: ::std::os::raw::c_int);
5741}
5742extern "C" {
5743 pub fn cst_wave_rescale(w: *mut cst_wave, factor: ::std::os::raw::c_int);
5744}
5745#[repr(C)]
5746#[derive(Debug, Copy, Clone)]
5747pub struct cst_rateconv_struct {
5748 pub channels: ::std::os::raw::c_int,
5749 pub up: ::std::os::raw::c_int,
5750 pub down: ::std::os::raw::c_int,
5751 pub gain: f64,
5752 pub lag: ::std::os::raw::c_int,
5753 pub sin: *mut ::std::os::raw::c_int,
5754 pub sout: *mut ::std::os::raw::c_int,
5755 pub coep: *mut ::std::os::raw::c_int,
5756 pub insize: ::std::os::raw::c_int,
5757 pub outsize: ::std::os::raw::c_int,
5758 pub incount: ::std::os::raw::c_int,
5759 pub len: ::std::os::raw::c_int,
5760 pub fsin: f64,
5761 pub fgk: f64,
5762 pub fgg: f64,
5763 pub inbaseidx: ::std::os::raw::c_int,
5764 pub inoffset: ::std::os::raw::c_int,
5765 pub cycctr: ::std::os::raw::c_int,
5766 pub outidx: ::std::os::raw::c_int,
5767}
5768#[test]
5769fn bindgen_test_layout_cst_rateconv_struct() {
5770 const UNINIT: ::std::mem::MaybeUninit<cst_rateconv_struct> = ::std::mem::MaybeUninit::uninit();
5771 let ptr = UNINIT.as_ptr();
5772 assert_eq!(
5773 ::std::mem::size_of::<cst_rateconv_struct>(),
5774 112usize,
5775 concat!("Size of: ", stringify!(cst_rateconv_struct))
5776 );
5777 assert_eq!(
5778 ::std::mem::align_of::<cst_rateconv_struct>(),
5779 8usize,
5780 concat!("Alignment of ", stringify!(cst_rateconv_struct))
5781 );
5782 assert_eq!(
5783 unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
5784 0usize,
5785 concat!(
5786 "Offset of field: ",
5787 stringify!(cst_rateconv_struct),
5788 "::",
5789 stringify!(channels)
5790 )
5791 );
5792 assert_eq!(
5793 unsafe { ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize },
5794 4usize,
5795 concat!(
5796 "Offset of field: ",
5797 stringify!(cst_rateconv_struct),
5798 "::",
5799 stringify!(up)
5800 )
5801 );
5802 assert_eq!(
5803 unsafe { ::std::ptr::addr_of!((*ptr).down) as usize - ptr as usize },
5804 8usize,
5805 concat!(
5806 "Offset of field: ",
5807 stringify!(cst_rateconv_struct),
5808 "::",
5809 stringify!(down)
5810 )
5811 );
5812 assert_eq!(
5813 unsafe { ::std::ptr::addr_of!((*ptr).gain) as usize - ptr as usize },
5814 16usize,
5815 concat!(
5816 "Offset of field: ",
5817 stringify!(cst_rateconv_struct),
5818 "::",
5819 stringify!(gain)
5820 )
5821 );
5822 assert_eq!(
5823 unsafe { ::std::ptr::addr_of!((*ptr).lag) as usize - ptr as usize },
5824 24usize,
5825 concat!(
5826 "Offset of field: ",
5827 stringify!(cst_rateconv_struct),
5828 "::",
5829 stringify!(lag)
5830 )
5831 );
5832 assert_eq!(
5833 unsafe { ::std::ptr::addr_of!((*ptr).sin) as usize - ptr as usize },
5834 32usize,
5835 concat!(
5836 "Offset of field: ",
5837 stringify!(cst_rateconv_struct),
5838 "::",
5839 stringify!(sin)
5840 )
5841 );
5842 assert_eq!(
5843 unsafe { ::std::ptr::addr_of!((*ptr).sout) as usize - ptr as usize },
5844 40usize,
5845 concat!(
5846 "Offset of field: ",
5847 stringify!(cst_rateconv_struct),
5848 "::",
5849 stringify!(sout)
5850 )
5851 );
5852 assert_eq!(
5853 unsafe { ::std::ptr::addr_of!((*ptr).coep) as usize - ptr as usize },
5854 48usize,
5855 concat!(
5856 "Offset of field: ",
5857 stringify!(cst_rateconv_struct),
5858 "::",
5859 stringify!(coep)
5860 )
5861 );
5862 assert_eq!(
5863 unsafe { ::std::ptr::addr_of!((*ptr).insize) as usize - ptr as usize },
5864 56usize,
5865 concat!(
5866 "Offset of field: ",
5867 stringify!(cst_rateconv_struct),
5868 "::",
5869 stringify!(insize)
5870 )
5871 );
5872 assert_eq!(
5873 unsafe { ::std::ptr::addr_of!((*ptr).outsize) as usize - ptr as usize },
5874 60usize,
5875 concat!(
5876 "Offset of field: ",
5877 stringify!(cst_rateconv_struct),
5878 "::",
5879 stringify!(outsize)
5880 )
5881 );
5882 assert_eq!(
5883 unsafe { ::std::ptr::addr_of!((*ptr).incount) as usize - ptr as usize },
5884 64usize,
5885 concat!(
5886 "Offset of field: ",
5887 stringify!(cst_rateconv_struct),
5888 "::",
5889 stringify!(incount)
5890 )
5891 );
5892 assert_eq!(
5893 unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
5894 68usize,
5895 concat!(
5896 "Offset of field: ",
5897 stringify!(cst_rateconv_struct),
5898 "::",
5899 stringify!(len)
5900 )
5901 );
5902 assert_eq!(
5903 unsafe { ::std::ptr::addr_of!((*ptr).fsin) as usize - ptr as usize },
5904 72usize,
5905 concat!(
5906 "Offset of field: ",
5907 stringify!(cst_rateconv_struct),
5908 "::",
5909 stringify!(fsin)
5910 )
5911 );
5912 assert_eq!(
5913 unsafe { ::std::ptr::addr_of!((*ptr).fgk) as usize - ptr as usize },
5914 80usize,
5915 concat!(
5916 "Offset of field: ",
5917 stringify!(cst_rateconv_struct),
5918 "::",
5919 stringify!(fgk)
5920 )
5921 );
5922 assert_eq!(
5923 unsafe { ::std::ptr::addr_of!((*ptr).fgg) as usize - ptr as usize },
5924 88usize,
5925 concat!(
5926 "Offset of field: ",
5927 stringify!(cst_rateconv_struct),
5928 "::",
5929 stringify!(fgg)
5930 )
5931 );
5932 assert_eq!(
5933 unsafe { ::std::ptr::addr_of!((*ptr).inbaseidx) as usize - ptr as usize },
5934 96usize,
5935 concat!(
5936 "Offset of field: ",
5937 stringify!(cst_rateconv_struct),
5938 "::",
5939 stringify!(inbaseidx)
5940 )
5941 );
5942 assert_eq!(
5943 unsafe { ::std::ptr::addr_of!((*ptr).inoffset) as usize - ptr as usize },
5944 100usize,
5945 concat!(
5946 "Offset of field: ",
5947 stringify!(cst_rateconv_struct),
5948 "::",
5949 stringify!(inoffset)
5950 )
5951 );
5952 assert_eq!(
5953 unsafe { ::std::ptr::addr_of!((*ptr).cycctr) as usize - ptr as usize },
5954 104usize,
5955 concat!(
5956 "Offset of field: ",
5957 stringify!(cst_rateconv_struct),
5958 "::",
5959 stringify!(cycctr)
5960 )
5961 );
5962 assert_eq!(
5963 unsafe { ::std::ptr::addr_of!((*ptr).outidx) as usize - ptr as usize },
5964 108usize,
5965 concat!(
5966 "Offset of field: ",
5967 stringify!(cst_rateconv_struct),
5968 "::",
5969 stringify!(outidx)
5970 )
5971 );
5972}
5973pub type cst_rateconv = cst_rateconv_struct;
5974extern "C" {
5975 pub fn new_rateconv(
5976 up: ::std::os::raw::c_int,
5977 down: ::std::os::raw::c_int,
5978 channels: ::std::os::raw::c_int,
5979 ) -> *mut cst_rateconv;
5980}
5981extern "C" {
5982 pub fn delete_rateconv(filt: *mut cst_rateconv);
5983}
5984extern "C" {
5985 pub fn cst_rateconv_in(
5986 filt: *mut cst_rateconv,
5987 inptr: *const ::std::os::raw::c_short,
5988 max: ::std::os::raw::c_int,
5989 ) -> ::std::os::raw::c_int;
5990}
5991extern "C" {
5992 pub fn cst_rateconv_leadout(filt: *mut cst_rateconv) -> ::std::os::raw::c_int;
5993}
5994extern "C" {
5995 pub fn cst_rateconv_out(
5996 filt: *mut cst_rateconv,
5997 outptr: *mut ::std::os::raw::c_short,
5998 max: ::std::os::raw::c_int,
5999 ) -> ::std::os::raw::c_int;
6000}
6001#[repr(C)]
6002#[derive(Debug, Copy, Clone)]
6003pub struct snd_header {
6004 pub magic: ::std::os::raw::c_uint,
6005 pub hdr_size: ::std::os::raw::c_uint,
6006 pub data_size: ::std::os::raw::c_int,
6007 pub encoding: ::std::os::raw::c_uint,
6008 pub sample_rate: ::std::os::raw::c_uint,
6009 pub channels: ::std::os::raw::c_uint,
6010}
6011#[test]
6012fn bindgen_test_layout_snd_header() {
6013 const UNINIT: ::std::mem::MaybeUninit<snd_header> = ::std::mem::MaybeUninit::uninit();
6014 let ptr = UNINIT.as_ptr();
6015 assert_eq!(
6016 ::std::mem::size_of::<snd_header>(),
6017 24usize,
6018 concat!("Size of: ", stringify!(snd_header))
6019 );
6020 assert_eq!(
6021 ::std::mem::align_of::<snd_header>(),
6022 4usize,
6023 concat!("Alignment of ", stringify!(snd_header))
6024 );
6025 assert_eq!(
6026 unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize },
6027 0usize,
6028 concat!(
6029 "Offset of field: ",
6030 stringify!(snd_header),
6031 "::",
6032 stringify!(magic)
6033 )
6034 );
6035 assert_eq!(
6036 unsafe { ::std::ptr::addr_of!((*ptr).hdr_size) as usize - ptr as usize },
6037 4usize,
6038 concat!(
6039 "Offset of field: ",
6040 stringify!(snd_header),
6041 "::",
6042 stringify!(hdr_size)
6043 )
6044 );
6045 assert_eq!(
6046 unsafe { ::std::ptr::addr_of!((*ptr).data_size) as usize - ptr as usize },
6047 8usize,
6048 concat!(
6049 "Offset of field: ",
6050 stringify!(snd_header),
6051 "::",
6052 stringify!(data_size)
6053 )
6054 );
6055 assert_eq!(
6056 unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
6057 12usize,
6058 concat!(
6059 "Offset of field: ",
6060 stringify!(snd_header),
6061 "::",
6062 stringify!(encoding)
6063 )
6064 );
6065 assert_eq!(
6066 unsafe { ::std::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
6067 16usize,
6068 concat!(
6069 "Offset of field: ",
6070 stringify!(snd_header),
6071 "::",
6072 stringify!(sample_rate)
6073 )
6074 );
6075 assert_eq!(
6076 unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
6077 20usize,
6078 concat!(
6079 "Offset of field: ",
6080 stringify!(snd_header),
6081 "::",
6082 stringify!(channels)
6083 )
6084 );
6085}
6086extern "C" {
6087 pub fn cst_short_to_ulaw(sample: ::std::os::raw::c_short) -> ::std::os::raw::c_uchar;
6088}
6089extern "C" {
6090 pub fn cst_ulaw_to_short(ulawbyte: ::std::os::raw::c_uchar) -> ::std::os::raw::c_short;
6091}
6092extern "C" {
6093 pub fn cst_g721_decode(
6094 actual_size: *mut ::std::os::raw::c_int,
6095 size: ::std::os::raw::c_int,
6096 packed_residual: *const ::std::os::raw::c_uchar,
6097 ) -> *mut ::std::os::raw::c_uchar;
6098}
6099extern "C" {
6100 pub fn cst_g721_encode(
6101 packed_size: *mut ::std::os::raw::c_int,
6102 actual_size: ::std::os::raw::c_int,
6103 unpacked_residual: *const ::std::os::raw::c_uchar,
6104 ) -> *mut ::std::os::raw::c_uchar;
6105}
6106extern "C" {
6107 pub static cst_val_type_wave: ::std::os::raw::c_int;
6108}
6109extern "C" {
6110 pub fn val_wave(v: *const cst_val) -> *mut cst_wave;
6111}
6112extern "C" {
6113 pub fn wave_val(v: *const cst_wave) -> *mut cst_val;
6114}
6115#[repr(C)]
6116#[derive(Debug, Copy, Clone)]
6117pub struct cst_track_struct {
6118 pub type_: *const ::std::os::raw::c_char,
6119 pub num_frames: ::std::os::raw::c_int,
6120 pub num_channels: ::std::os::raw::c_int,
6121 pub times: *mut f32,
6122 pub frames: *mut *mut f32,
6123}
6124#[test]
6125fn bindgen_test_layout_cst_track_struct() {
6126 const UNINIT: ::std::mem::MaybeUninit<cst_track_struct> = ::std::mem::MaybeUninit::uninit();
6127 let ptr = UNINIT.as_ptr();
6128 assert_eq!(
6129 ::std::mem::size_of::<cst_track_struct>(),
6130 32usize,
6131 concat!("Size of: ", stringify!(cst_track_struct))
6132 );
6133 assert_eq!(
6134 ::std::mem::align_of::<cst_track_struct>(),
6135 8usize,
6136 concat!("Alignment of ", stringify!(cst_track_struct))
6137 );
6138 assert_eq!(
6139 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
6140 0usize,
6141 concat!(
6142 "Offset of field: ",
6143 stringify!(cst_track_struct),
6144 "::",
6145 stringify!(type_)
6146 )
6147 );
6148 assert_eq!(
6149 unsafe { ::std::ptr::addr_of!((*ptr).num_frames) as usize - ptr as usize },
6150 8usize,
6151 concat!(
6152 "Offset of field: ",
6153 stringify!(cst_track_struct),
6154 "::",
6155 stringify!(num_frames)
6156 )
6157 );
6158 assert_eq!(
6159 unsafe { ::std::ptr::addr_of!((*ptr).num_channels) as usize - ptr as usize },
6160 12usize,
6161 concat!(
6162 "Offset of field: ",
6163 stringify!(cst_track_struct),
6164 "::",
6165 stringify!(num_channels)
6166 )
6167 );
6168 assert_eq!(
6169 unsafe { ::std::ptr::addr_of!((*ptr).times) as usize - ptr as usize },
6170 16usize,
6171 concat!(
6172 "Offset of field: ",
6173 stringify!(cst_track_struct),
6174 "::",
6175 stringify!(times)
6176 )
6177 );
6178 assert_eq!(
6179 unsafe { ::std::ptr::addr_of!((*ptr).frames) as usize - ptr as usize },
6180 24usize,
6181 concat!(
6182 "Offset of field: ",
6183 stringify!(cst_track_struct),
6184 "::",
6185 stringify!(frames)
6186 )
6187 );
6188}
6189pub type cst_track = cst_track_struct;
6190extern "C" {
6191 pub fn new_track() -> *mut cst_track;
6192}
6193extern "C" {
6194 pub fn delete_track(val: *mut cst_track);
6195}
6196extern "C" {
6197 pub fn track_frame_shift(t: *mut cst_track, frame: ::std::os::raw::c_int) -> f32;
6198}
6199extern "C" {
6200 pub fn cst_track_resize(
6201 t: *mut cst_track,
6202 num_frames: ::std::os::raw::c_int,
6203 num_channels: ::std::os::raw::c_int,
6204 );
6205}
6206extern "C" {
6207 pub fn cst_track_copy(t: *const cst_track) -> *mut cst_track;
6208}
6209extern "C" {
6210 pub fn cst_track_save_est(
6211 t: *mut cst_track,
6212 filename: *const ::std::os::raw::c_char,
6213 ) -> ::std::os::raw::c_int;
6214}
6215extern "C" {
6216 pub fn cst_track_save_est_binary(
6217 t: *mut cst_track,
6218 filename: *const ::std::os::raw::c_char,
6219 ) -> ::std::os::raw::c_int;
6220}
6221extern "C" {
6222 pub fn cst_track_load_est(
6223 t: *mut cst_track,
6224 filename: *const ::std::os::raw::c_char,
6225 ) -> ::std::os::raw::c_int;
6226}
6227extern "C" {
6228 pub static cst_val_type_track: ::std::os::raw::c_int;
6229}
6230extern "C" {
6231 pub fn val_track(v: *const cst_val) -> *mut cst_track;
6232}
6233extern "C" {
6234 pub fn track_val(v: *const cst_track) -> *mut cst_val;
6235}
6236#[repr(C)]
6237#[derive(Debug, Copy, Clone)]
6238pub struct cst_cart_node_struct {
6239 pub feat: ::std::os::raw::c_uchar,
6240 pub op: ::std::os::raw::c_uchar,
6241 pub no_node: ::std::os::raw::c_ushort,
6242 pub val: *const cst_val,
6243}
6244#[test]
6245fn bindgen_test_layout_cst_cart_node_struct() {
6246 const UNINIT: ::std::mem::MaybeUninit<cst_cart_node_struct> = ::std::mem::MaybeUninit::uninit();
6247 let ptr = UNINIT.as_ptr();
6248 assert_eq!(
6249 ::std::mem::size_of::<cst_cart_node_struct>(),
6250 16usize,
6251 concat!("Size of: ", stringify!(cst_cart_node_struct))
6252 );
6253 assert_eq!(
6254 ::std::mem::align_of::<cst_cart_node_struct>(),
6255 8usize,
6256 concat!("Alignment of ", stringify!(cst_cart_node_struct))
6257 );
6258 assert_eq!(
6259 unsafe { ::std::ptr::addr_of!((*ptr).feat) as usize - ptr as usize },
6260 0usize,
6261 concat!(
6262 "Offset of field: ",
6263 stringify!(cst_cart_node_struct),
6264 "::",
6265 stringify!(feat)
6266 )
6267 );
6268 assert_eq!(
6269 unsafe { ::std::ptr::addr_of!((*ptr).op) as usize - ptr as usize },
6270 1usize,
6271 concat!(
6272 "Offset of field: ",
6273 stringify!(cst_cart_node_struct),
6274 "::",
6275 stringify!(op)
6276 )
6277 );
6278 assert_eq!(
6279 unsafe { ::std::ptr::addr_of!((*ptr).no_node) as usize - ptr as usize },
6280 2usize,
6281 concat!(
6282 "Offset of field: ",
6283 stringify!(cst_cart_node_struct),
6284 "::",
6285 stringify!(no_node)
6286 )
6287 );
6288 assert_eq!(
6289 unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
6290 8usize,
6291 concat!(
6292 "Offset of field: ",
6293 stringify!(cst_cart_node_struct),
6294 "::",
6295 stringify!(val)
6296 )
6297 );
6298}
6299pub type cst_cart_node = cst_cart_node_struct;
6300#[repr(C)]
6301#[derive(Debug, Copy, Clone)]
6302pub struct cst_cart_struct {
6303 pub rule_table: *const cst_cart_node,
6304 pub feat_table: *const *const ::std::os::raw::c_char,
6305}
6306#[test]
6307fn bindgen_test_layout_cst_cart_struct() {
6308 const UNINIT: ::std::mem::MaybeUninit<cst_cart_struct> = ::std::mem::MaybeUninit::uninit();
6309 let ptr = UNINIT.as_ptr();
6310 assert_eq!(
6311 ::std::mem::size_of::<cst_cart_struct>(),
6312 16usize,
6313 concat!("Size of: ", stringify!(cst_cart_struct))
6314 );
6315 assert_eq!(
6316 ::std::mem::align_of::<cst_cart_struct>(),
6317 8usize,
6318 concat!("Alignment of ", stringify!(cst_cart_struct))
6319 );
6320 assert_eq!(
6321 unsafe { ::std::ptr::addr_of!((*ptr).rule_table) as usize - ptr as usize },
6322 0usize,
6323 concat!(
6324 "Offset of field: ",
6325 stringify!(cst_cart_struct),
6326 "::",
6327 stringify!(rule_table)
6328 )
6329 );
6330 assert_eq!(
6331 unsafe { ::std::ptr::addr_of!((*ptr).feat_table) as usize - ptr as usize },
6332 8usize,
6333 concat!(
6334 "Offset of field: ",
6335 stringify!(cst_cart_struct),
6336 "::",
6337 stringify!(feat_table)
6338 )
6339 );
6340}
6341pub type cst_cart = cst_cart_struct;
6342extern "C" {
6343 pub fn delete_cart(c: *mut cst_cart);
6344}
6345extern "C" {
6346 pub static cst_val_type_cart: ::std::os::raw::c_int;
6347}
6348extern "C" {
6349 pub fn val_cart(v: *const cst_val) -> *mut cst_cart;
6350}
6351extern "C" {
6352 pub fn cart_val(v: *const cst_cart) -> *mut cst_val;
6353}
6354extern "C" {
6355 pub fn cart_interpret(item: *mut cst_item, tree: *const cst_cart) -> *const cst_val;
6356}
6357#[repr(C)]
6358#[derive(Debug, Copy, Clone)]
6359pub struct cst_phoneset_struct {
6360 pub name: *const ::std::os::raw::c_char,
6361 pub featnames: *const *const ::std::os::raw::c_char,
6362 pub featvals: *const *const cst_val,
6363 pub phonenames: *const *const ::std::os::raw::c_char,
6364 pub silence: *const ::std::os::raw::c_char,
6365 pub num_phones: ::std::os::raw::c_int,
6366 pub fvtable: *const *const ::std::os::raw::c_int,
6367 pub freeable: ::std::os::raw::c_int,
6368}
6369#[test]
6370fn bindgen_test_layout_cst_phoneset_struct() {
6371 const UNINIT: ::std::mem::MaybeUninit<cst_phoneset_struct> = ::std::mem::MaybeUninit::uninit();
6372 let ptr = UNINIT.as_ptr();
6373 assert_eq!(
6374 ::std::mem::size_of::<cst_phoneset_struct>(),
6375 64usize,
6376 concat!("Size of: ", stringify!(cst_phoneset_struct))
6377 );
6378 assert_eq!(
6379 ::std::mem::align_of::<cst_phoneset_struct>(),
6380 8usize,
6381 concat!("Alignment of ", stringify!(cst_phoneset_struct))
6382 );
6383 assert_eq!(
6384 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
6385 0usize,
6386 concat!(
6387 "Offset of field: ",
6388 stringify!(cst_phoneset_struct),
6389 "::",
6390 stringify!(name)
6391 )
6392 );
6393 assert_eq!(
6394 unsafe { ::std::ptr::addr_of!((*ptr).featnames) as usize - ptr as usize },
6395 8usize,
6396 concat!(
6397 "Offset of field: ",
6398 stringify!(cst_phoneset_struct),
6399 "::",
6400 stringify!(featnames)
6401 )
6402 );
6403 assert_eq!(
6404 unsafe { ::std::ptr::addr_of!((*ptr).featvals) as usize - ptr as usize },
6405 16usize,
6406 concat!(
6407 "Offset of field: ",
6408 stringify!(cst_phoneset_struct),
6409 "::",
6410 stringify!(featvals)
6411 )
6412 );
6413 assert_eq!(
6414 unsafe { ::std::ptr::addr_of!((*ptr).phonenames) as usize - ptr as usize },
6415 24usize,
6416 concat!(
6417 "Offset of field: ",
6418 stringify!(cst_phoneset_struct),
6419 "::",
6420 stringify!(phonenames)
6421 )
6422 );
6423 assert_eq!(
6424 unsafe { ::std::ptr::addr_of!((*ptr).silence) as usize - ptr as usize },
6425 32usize,
6426 concat!(
6427 "Offset of field: ",
6428 stringify!(cst_phoneset_struct),
6429 "::",
6430 stringify!(silence)
6431 )
6432 );
6433 assert_eq!(
6434 unsafe { ::std::ptr::addr_of!((*ptr).num_phones) as usize - ptr as usize },
6435 40usize,
6436 concat!(
6437 "Offset of field: ",
6438 stringify!(cst_phoneset_struct),
6439 "::",
6440 stringify!(num_phones)
6441 )
6442 );
6443 assert_eq!(
6444 unsafe { ::std::ptr::addr_of!((*ptr).fvtable) as usize - ptr as usize },
6445 48usize,
6446 concat!(
6447 "Offset of field: ",
6448 stringify!(cst_phoneset_struct),
6449 "::",
6450 stringify!(fvtable)
6451 )
6452 );
6453 assert_eq!(
6454 unsafe { ::std::ptr::addr_of!((*ptr).freeable) as usize - ptr as usize },
6455 56usize,
6456 concat!(
6457 "Offset of field: ",
6458 stringify!(cst_phoneset_struct),
6459 "::",
6460 stringify!(freeable)
6461 )
6462 );
6463}
6464pub type cst_phoneset = cst_phoneset_struct;
6465extern "C" {
6466 pub fn new_phoneset() -> *mut cst_phoneset;
6467}
6468extern "C" {
6469 pub fn delete_phoneset(u: *const cst_phoneset);
6470}
6471extern "C" {
6472 pub fn phone_feature(
6473 ps: *const cst_phoneset,
6474 phonename: *const ::std::os::raw::c_char,
6475 featname: *const ::std::os::raw::c_char,
6476 ) -> *const cst_val;
6477}
6478extern "C" {
6479 pub fn phone_feature_string(
6480 ps: *const cst_phoneset,
6481 phonename: *const ::std::os::raw::c_char,
6482 featname: *const ::std::os::raw::c_char,
6483 ) -> *const ::std::os::raw::c_char;
6484}
6485extern "C" {
6486 pub fn phone_id(
6487 ps: *const cst_phoneset,
6488 phonename: *const ::std::os::raw::c_char,
6489 ) -> ::std::os::raw::c_int;
6490}
6491extern "C" {
6492 pub fn phone_feat_id(
6493 ps: *const cst_phoneset,
6494 featname: *const ::std::os::raw::c_char,
6495 ) -> ::std::os::raw::c_int;
6496}
6497extern "C" {
6498 pub fn item_phoneset(i: *const cst_item) -> *const cst_phoneset;
6499}
6500extern "C" {
6501 pub static cst_val_type_phoneset: ::std::os::raw::c_int;
6502}
6503extern "C" {
6504 pub fn val_phoneset(v: *const cst_val) -> *mut cst_phoneset;
6505}
6506extern "C" {
6507 pub fn phoneset_val(v: *const cst_phoneset) -> *mut cst_val;
6508}
6509pub type cst_lts_addr = ::std::os::raw::c_ushort;
6510pub type cst_lts_phone = ::std::os::raw::c_int;
6511pub type cst_lts_feat = ::std::os::raw::c_uchar;
6512pub type cst_lts_letter = ::std::os::raw::c_uchar;
6513pub type cst_lts_model = ::std::os::raw::c_uchar;
6514#[repr(C)]
6515#[derive(Debug, Copy, Clone)]
6516pub struct cst_lts_rules_struct {
6517 pub name: *mut ::std::os::raw::c_char,
6518 pub letter_index: *const cst_lts_addr,
6519 pub models: *const cst_lts_model,
6520 pub phone_table: *const *const ::std::os::raw::c_char,
6521 pub context_window_size: ::std::os::raw::c_int,
6522 pub context_extra_feats: ::std::os::raw::c_int,
6523 pub letter_table: *const *const ::std::os::raw::c_char,
6524}
6525#[test]
6526fn bindgen_test_layout_cst_lts_rules_struct() {
6527 const UNINIT: ::std::mem::MaybeUninit<cst_lts_rules_struct> = ::std::mem::MaybeUninit::uninit();
6528 let ptr = UNINIT.as_ptr();
6529 assert_eq!(
6530 ::std::mem::size_of::<cst_lts_rules_struct>(),
6531 48usize,
6532 concat!("Size of: ", stringify!(cst_lts_rules_struct))
6533 );
6534 assert_eq!(
6535 ::std::mem::align_of::<cst_lts_rules_struct>(),
6536 8usize,
6537 concat!("Alignment of ", stringify!(cst_lts_rules_struct))
6538 );
6539 assert_eq!(
6540 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
6541 0usize,
6542 concat!(
6543 "Offset of field: ",
6544 stringify!(cst_lts_rules_struct),
6545 "::",
6546 stringify!(name)
6547 )
6548 );
6549 assert_eq!(
6550 unsafe { ::std::ptr::addr_of!((*ptr).letter_index) as usize - ptr as usize },
6551 8usize,
6552 concat!(
6553 "Offset of field: ",
6554 stringify!(cst_lts_rules_struct),
6555 "::",
6556 stringify!(letter_index)
6557 )
6558 );
6559 assert_eq!(
6560 unsafe { ::std::ptr::addr_of!((*ptr).models) as usize - ptr as usize },
6561 16usize,
6562 concat!(
6563 "Offset of field: ",
6564 stringify!(cst_lts_rules_struct),
6565 "::",
6566 stringify!(models)
6567 )
6568 );
6569 assert_eq!(
6570 unsafe { ::std::ptr::addr_of!((*ptr).phone_table) as usize - ptr as usize },
6571 24usize,
6572 concat!(
6573 "Offset of field: ",
6574 stringify!(cst_lts_rules_struct),
6575 "::",
6576 stringify!(phone_table)
6577 )
6578 );
6579 assert_eq!(
6580 unsafe { ::std::ptr::addr_of!((*ptr).context_window_size) as usize - ptr as usize },
6581 32usize,
6582 concat!(
6583 "Offset of field: ",
6584 stringify!(cst_lts_rules_struct),
6585 "::",
6586 stringify!(context_window_size)
6587 )
6588 );
6589 assert_eq!(
6590 unsafe { ::std::ptr::addr_of!((*ptr).context_extra_feats) as usize - ptr as usize },
6591 36usize,
6592 concat!(
6593 "Offset of field: ",
6594 stringify!(cst_lts_rules_struct),
6595 "::",
6596 stringify!(context_extra_feats)
6597 )
6598 );
6599 assert_eq!(
6600 unsafe { ::std::ptr::addr_of!((*ptr).letter_table) as usize - ptr as usize },
6601 40usize,
6602 concat!(
6603 "Offset of field: ",
6604 stringify!(cst_lts_rules_struct),
6605 "::",
6606 stringify!(letter_table)
6607 )
6608 );
6609}
6610pub type cst_lts_rules = cst_lts_rules_struct;
6611#[repr(C)]
6612#[derive(Debug, Copy, Clone)]
6613pub struct cst_lts_rule_struct {
6614 pub feat: cst_lts_feat,
6615 pub val: cst_lts_letter,
6616 pub qtrue: cst_lts_addr,
6617 pub qfalse: cst_lts_addr,
6618}
6619#[test]
6620fn bindgen_test_layout_cst_lts_rule_struct() {
6621 const UNINIT: ::std::mem::MaybeUninit<cst_lts_rule_struct> = ::std::mem::MaybeUninit::uninit();
6622 let ptr = UNINIT.as_ptr();
6623 assert_eq!(
6624 ::std::mem::size_of::<cst_lts_rule_struct>(),
6625 6usize,
6626 concat!("Size of: ", stringify!(cst_lts_rule_struct))
6627 );
6628 assert_eq!(
6629 ::std::mem::align_of::<cst_lts_rule_struct>(),
6630 2usize,
6631 concat!("Alignment of ", stringify!(cst_lts_rule_struct))
6632 );
6633 assert_eq!(
6634 unsafe { ::std::ptr::addr_of!((*ptr).feat) as usize - ptr as usize },
6635 0usize,
6636 concat!(
6637 "Offset of field: ",
6638 stringify!(cst_lts_rule_struct),
6639 "::",
6640 stringify!(feat)
6641 )
6642 );
6643 assert_eq!(
6644 unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
6645 1usize,
6646 concat!(
6647 "Offset of field: ",
6648 stringify!(cst_lts_rule_struct),
6649 "::",
6650 stringify!(val)
6651 )
6652 );
6653 assert_eq!(
6654 unsafe { ::std::ptr::addr_of!((*ptr).qtrue) as usize - ptr as usize },
6655 2usize,
6656 concat!(
6657 "Offset of field: ",
6658 stringify!(cst_lts_rule_struct),
6659 "::",
6660 stringify!(qtrue)
6661 )
6662 );
6663 assert_eq!(
6664 unsafe { ::std::ptr::addr_of!((*ptr).qfalse) as usize - ptr as usize },
6665 4usize,
6666 concat!(
6667 "Offset of field: ",
6668 stringify!(cst_lts_rule_struct),
6669 "::",
6670 stringify!(qfalse)
6671 )
6672 );
6673}
6674pub type cst_lts_rule = cst_lts_rule_struct;
6675extern "C" {
6676 pub fn new_lts_rules() -> *mut cst_lts_rules;
6677}
6678extern "C" {
6679 pub fn lts_apply(
6680 word: *const ::std::os::raw::c_char,
6681 feats: *const ::std::os::raw::c_char,
6682 r: *const cst_lts_rules,
6683 ) -> *mut cst_val;
6684}
6685extern "C" {
6686 pub fn lts_apply_val(
6687 wlist: *const cst_val,
6688 feats: *const ::std::os::raw::c_char,
6689 r: *const cst_lts_rules,
6690 ) -> *mut cst_val;
6691}
6692#[repr(C)]
6693#[derive(Debug, Copy, Clone)]
6694pub struct lexicon_struct {
6695 pub name: *const ::std::os::raw::c_char,
6696 pub num_entries: ::std::os::raw::c_int,
6697 pub data: *mut ::std::os::raw::c_uchar,
6698 pub num_bytes: ::std::os::raw::c_int,
6699 pub phone_table: *mut *mut ::std::os::raw::c_char,
6700 pub lts_rule_set: *mut cst_lts_rules,
6701 pub syl_boundary: ::std::option::Option<
6702 unsafe extern "C" fn(i: *const cst_item, p: *const cst_val) -> ::std::os::raw::c_int,
6703 >,
6704 pub lts_function: ::std::option::Option<
6705 unsafe extern "C" fn(
6706 l: *const lexicon_struct,
6707 word: *const ::std::os::raw::c_char,
6708 pos: *const ::std::os::raw::c_char,
6709 feats: *const cst_features,
6710 ) -> *mut cst_val,
6711 >,
6712 pub addenda: *mut *mut *mut ::std::os::raw::c_char,
6713 pub phone_hufftable: *const *const ::std::os::raw::c_char,
6714 pub entry_hufftable: *const *const ::std::os::raw::c_char,
6715 pub postlex:
6716 ::std::option::Option<unsafe extern "C" fn(u: *mut cst_utterance) -> *mut cst_utterance>,
6717 pub lex_addenda: *mut cst_val,
6718}
6719#[test]
6720fn bindgen_test_layout_lexicon_struct() {
6721 const UNINIT: ::std::mem::MaybeUninit<lexicon_struct> = ::std::mem::MaybeUninit::uninit();
6722 let ptr = UNINIT.as_ptr();
6723 assert_eq!(
6724 ::std::mem::size_of::<lexicon_struct>(),
6725 104usize,
6726 concat!("Size of: ", stringify!(lexicon_struct))
6727 );
6728 assert_eq!(
6729 ::std::mem::align_of::<lexicon_struct>(),
6730 8usize,
6731 concat!("Alignment of ", stringify!(lexicon_struct))
6732 );
6733 assert_eq!(
6734 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
6735 0usize,
6736 concat!(
6737 "Offset of field: ",
6738 stringify!(lexicon_struct),
6739 "::",
6740 stringify!(name)
6741 )
6742 );
6743 assert_eq!(
6744 unsafe { ::std::ptr::addr_of!((*ptr).num_entries) as usize - ptr as usize },
6745 8usize,
6746 concat!(
6747 "Offset of field: ",
6748 stringify!(lexicon_struct),
6749 "::",
6750 stringify!(num_entries)
6751 )
6752 );
6753 assert_eq!(
6754 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
6755 16usize,
6756 concat!(
6757 "Offset of field: ",
6758 stringify!(lexicon_struct),
6759 "::",
6760 stringify!(data)
6761 )
6762 );
6763 assert_eq!(
6764 unsafe { ::std::ptr::addr_of!((*ptr).num_bytes) as usize - ptr as usize },
6765 24usize,
6766 concat!(
6767 "Offset of field: ",
6768 stringify!(lexicon_struct),
6769 "::",
6770 stringify!(num_bytes)
6771 )
6772 );
6773 assert_eq!(
6774 unsafe { ::std::ptr::addr_of!((*ptr).phone_table) as usize - ptr as usize },
6775 32usize,
6776 concat!(
6777 "Offset of field: ",
6778 stringify!(lexicon_struct),
6779 "::",
6780 stringify!(phone_table)
6781 )
6782 );
6783 assert_eq!(
6784 unsafe { ::std::ptr::addr_of!((*ptr).lts_rule_set) as usize - ptr as usize },
6785 40usize,
6786 concat!(
6787 "Offset of field: ",
6788 stringify!(lexicon_struct),
6789 "::",
6790 stringify!(lts_rule_set)
6791 )
6792 );
6793 assert_eq!(
6794 unsafe { ::std::ptr::addr_of!((*ptr).syl_boundary) as usize - ptr as usize },
6795 48usize,
6796 concat!(
6797 "Offset of field: ",
6798 stringify!(lexicon_struct),
6799 "::",
6800 stringify!(syl_boundary)
6801 )
6802 );
6803 assert_eq!(
6804 unsafe { ::std::ptr::addr_of!((*ptr).lts_function) as usize - ptr as usize },
6805 56usize,
6806 concat!(
6807 "Offset of field: ",
6808 stringify!(lexicon_struct),
6809 "::",
6810 stringify!(lts_function)
6811 )
6812 );
6813 assert_eq!(
6814 unsafe { ::std::ptr::addr_of!((*ptr).addenda) as usize - ptr as usize },
6815 64usize,
6816 concat!(
6817 "Offset of field: ",
6818 stringify!(lexicon_struct),
6819 "::",
6820 stringify!(addenda)
6821 )
6822 );
6823 assert_eq!(
6824 unsafe { ::std::ptr::addr_of!((*ptr).phone_hufftable) as usize - ptr as usize },
6825 72usize,
6826 concat!(
6827 "Offset of field: ",
6828 stringify!(lexicon_struct),
6829 "::",
6830 stringify!(phone_hufftable)
6831 )
6832 );
6833 assert_eq!(
6834 unsafe { ::std::ptr::addr_of!((*ptr).entry_hufftable) as usize - ptr as usize },
6835 80usize,
6836 concat!(
6837 "Offset of field: ",
6838 stringify!(lexicon_struct),
6839 "::",
6840 stringify!(entry_hufftable)
6841 )
6842 );
6843 assert_eq!(
6844 unsafe { ::std::ptr::addr_of!((*ptr).postlex) as usize - ptr as usize },
6845 88usize,
6846 concat!(
6847 "Offset of field: ",
6848 stringify!(lexicon_struct),
6849 "::",
6850 stringify!(postlex)
6851 )
6852 );
6853 assert_eq!(
6854 unsafe { ::std::ptr::addr_of!((*ptr).lex_addenda) as usize - ptr as usize },
6855 96usize,
6856 concat!(
6857 "Offset of field: ",
6858 stringify!(lexicon_struct),
6859 "::",
6860 stringify!(lex_addenda)
6861 )
6862 );
6863}
6864pub type cst_lexicon = lexicon_struct;
6865extern "C" {
6866 pub fn new_lexicon() -> *mut cst_lexicon;
6867}
6868extern "C" {
6869 pub fn delete_lexicon(lex: *mut cst_lexicon);
6870}
6871extern "C" {
6872 pub fn cst_lex_make_entry(lex: *const cst_lexicon, entry: *const cst_string) -> *mut cst_val;
6873}
6874extern "C" {
6875 pub fn cst_lex_load_addenda(
6876 lex: *const cst_lexicon,
6877 lexfile: *const ::std::os::raw::c_char,
6878 ) -> *mut cst_val;
6879}
6880extern "C" {
6881 pub fn lex_lookup(
6882 l: *const cst_lexicon,
6883 word: *const ::std::os::raw::c_char,
6884 pos: *const ::std::os::raw::c_char,
6885 feats: *const cst_features,
6886 ) -> *mut cst_val;
6887}
6888extern "C" {
6889 pub fn in_lex(
6890 l: *const cst_lexicon,
6891 word: *const ::std::os::raw::c_char,
6892 pos: *const ::std::os::raw::c_char,
6893 feats: *const cst_features,
6894 ) -> ::std::os::raw::c_int;
6895}
6896extern "C" {
6897 pub static cst_val_type_lexicon: ::std::os::raw::c_int;
6898}
6899extern "C" {
6900 pub fn val_lexicon(v: *const cst_val) -> *mut cst_lexicon;
6901}
6902extern "C" {
6903 pub fn lexicon_val(v: *const cst_lexicon) -> *mut cst_val;
6904}
6905#[repr(C)]
6906#[derive(Debug, Copy, Clone)]
6907pub struct cst_voice_struct {
6908 pub name: *const ::std::os::raw::c_char,
6909 pub features: *mut cst_features,
6910 pub ffunctions: *mut cst_features,
6911 pub utt_init: ::std::option::Option<
6912 unsafe extern "C" fn(u: *mut cst_utterance, v: *mut cst_voice_struct) -> *mut cst_utterance,
6913 >,
6914}
6915#[test]
6916fn bindgen_test_layout_cst_voice_struct() {
6917 const UNINIT: ::std::mem::MaybeUninit<cst_voice_struct> = ::std::mem::MaybeUninit::uninit();
6918 let ptr = UNINIT.as_ptr();
6919 assert_eq!(
6920 ::std::mem::size_of::<cst_voice_struct>(),
6921 32usize,
6922 concat!("Size of: ", stringify!(cst_voice_struct))
6923 );
6924 assert_eq!(
6925 ::std::mem::align_of::<cst_voice_struct>(),
6926 8usize,
6927 concat!("Alignment of ", stringify!(cst_voice_struct))
6928 );
6929 assert_eq!(
6930 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
6931 0usize,
6932 concat!(
6933 "Offset of field: ",
6934 stringify!(cst_voice_struct),
6935 "::",
6936 stringify!(name)
6937 )
6938 );
6939 assert_eq!(
6940 unsafe { ::std::ptr::addr_of!((*ptr).features) as usize - ptr as usize },
6941 8usize,
6942 concat!(
6943 "Offset of field: ",
6944 stringify!(cst_voice_struct),
6945 "::",
6946 stringify!(features)
6947 )
6948 );
6949 assert_eq!(
6950 unsafe { ::std::ptr::addr_of!((*ptr).ffunctions) as usize - ptr as usize },
6951 16usize,
6952 concat!(
6953 "Offset of field: ",
6954 stringify!(cst_voice_struct),
6955 "::",
6956 stringify!(ffunctions)
6957 )
6958 );
6959 assert_eq!(
6960 unsafe { ::std::ptr::addr_of!((*ptr).utt_init) as usize - ptr as usize },
6961 24usize,
6962 concat!(
6963 "Offset of field: ",
6964 stringify!(cst_voice_struct),
6965 "::",
6966 stringify!(utt_init)
6967 )
6968 );
6969}
6970pub type cst_voice = cst_voice_struct;
6971#[repr(C)]
6972#[derive(Debug, Copy, Clone)]
6973pub struct cst_lang_struct {
6974 pub lang: *const ::std::os::raw::c_char,
6975 pub lang_init: ::std::option::Option<unsafe extern "C" fn(vox: *mut cst_voice)>,
6976 pub lex_init: ::std::option::Option<unsafe extern "C" fn() -> *mut cst_lexicon>,
6977}
6978#[test]
6979fn bindgen_test_layout_cst_lang_struct() {
6980 const UNINIT: ::std::mem::MaybeUninit<cst_lang_struct> = ::std::mem::MaybeUninit::uninit();
6981 let ptr = UNINIT.as_ptr();
6982 assert_eq!(
6983 ::std::mem::size_of::<cst_lang_struct>(),
6984 24usize,
6985 concat!("Size of: ", stringify!(cst_lang_struct))
6986 );
6987 assert_eq!(
6988 ::std::mem::align_of::<cst_lang_struct>(),
6989 8usize,
6990 concat!("Alignment of ", stringify!(cst_lang_struct))
6991 );
6992 assert_eq!(
6993 unsafe { ::std::ptr::addr_of!((*ptr).lang) as usize - ptr as usize },
6994 0usize,
6995 concat!(
6996 "Offset of field: ",
6997 stringify!(cst_lang_struct),
6998 "::",
6999 stringify!(lang)
7000 )
7001 );
7002 assert_eq!(
7003 unsafe { ::std::ptr::addr_of!((*ptr).lang_init) as usize - ptr as usize },
7004 8usize,
7005 concat!(
7006 "Offset of field: ",
7007 stringify!(cst_lang_struct),
7008 "::",
7009 stringify!(lang_init)
7010 )
7011 );
7012 assert_eq!(
7013 unsafe { ::std::ptr::addr_of!((*ptr).lex_init) as usize - ptr as usize },
7014 16usize,
7015 concat!(
7016 "Offset of field: ",
7017 stringify!(cst_lang_struct),
7018 "::",
7019 stringify!(lex_init)
7020 )
7021 );
7022}
7023pub type cst_lang = cst_lang_struct;
7024extern "C" {
7025 pub fn new_voice() -> *mut cst_voice;
7026}
7027extern "C" {
7028 pub fn delete_voice(u: *mut cst_voice);
7029}
7030extern "C" {
7031 pub static cst_val_type_voice: ::std::os::raw::c_int;
7032}
7033extern "C" {
7034 pub fn val_voice(v: *const cst_val) -> *mut cst_voice;
7035}
7036extern "C" {
7037 pub fn voice_val(v: *const cst_voice) -> *mut cst_val;
7038}
7039pub const cst_audiofmt_CST_AUDIO_LINEAR16: cst_audiofmt = 0;
7040pub const cst_audiofmt_CST_AUDIO_LINEAR8: cst_audiofmt = 1;
7041pub const cst_audiofmt_CST_AUDIO_MULAW: cst_audiofmt = 2;
7042pub type cst_audiofmt = ::std::os::raw::c_uint;
7043extern "C" {
7044 pub fn audio_bps(fmt: cst_audiofmt) -> ::std::os::raw::c_int;
7045}
7046#[repr(C)]
7047#[derive(Debug, Copy, Clone)]
7048pub struct cst_audiodev_struct {
7049 pub sps: ::std::os::raw::c_int,
7050 pub real_sps: ::std::os::raw::c_int,
7051 pub channels: ::std::os::raw::c_int,
7052 pub real_channels: ::std::os::raw::c_int,
7053 pub fmt: cst_audiofmt,
7054 pub real_fmt: cst_audiofmt,
7055 pub byteswap: ::std::os::raw::c_int,
7056 pub rateconv: *mut cst_rateconv,
7057 pub platform_data: *mut ::std::os::raw::c_void,
7058}
7059#[test]
7060fn bindgen_test_layout_cst_audiodev_struct() {
7061 const UNINIT: ::std::mem::MaybeUninit<cst_audiodev_struct> = ::std::mem::MaybeUninit::uninit();
7062 let ptr = UNINIT.as_ptr();
7063 assert_eq!(
7064 ::std::mem::size_of::<cst_audiodev_struct>(),
7065 48usize,
7066 concat!("Size of: ", stringify!(cst_audiodev_struct))
7067 );
7068 assert_eq!(
7069 ::std::mem::align_of::<cst_audiodev_struct>(),
7070 8usize,
7071 concat!("Alignment of ", stringify!(cst_audiodev_struct))
7072 );
7073 assert_eq!(
7074 unsafe { ::std::ptr::addr_of!((*ptr).sps) as usize - ptr as usize },
7075 0usize,
7076 concat!(
7077 "Offset of field: ",
7078 stringify!(cst_audiodev_struct),
7079 "::",
7080 stringify!(sps)
7081 )
7082 );
7083 assert_eq!(
7084 unsafe { ::std::ptr::addr_of!((*ptr).real_sps) as usize - ptr as usize },
7085 4usize,
7086 concat!(
7087 "Offset of field: ",
7088 stringify!(cst_audiodev_struct),
7089 "::",
7090 stringify!(real_sps)
7091 )
7092 );
7093 assert_eq!(
7094 unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
7095 8usize,
7096 concat!(
7097 "Offset of field: ",
7098 stringify!(cst_audiodev_struct),
7099 "::",
7100 stringify!(channels)
7101 )
7102 );
7103 assert_eq!(
7104 unsafe { ::std::ptr::addr_of!((*ptr).real_channels) as usize - ptr as usize },
7105 12usize,
7106 concat!(
7107 "Offset of field: ",
7108 stringify!(cst_audiodev_struct),
7109 "::",
7110 stringify!(real_channels)
7111 )
7112 );
7113 assert_eq!(
7114 unsafe { ::std::ptr::addr_of!((*ptr).fmt) as usize - ptr as usize },
7115 16usize,
7116 concat!(
7117 "Offset of field: ",
7118 stringify!(cst_audiodev_struct),
7119 "::",
7120 stringify!(fmt)
7121 )
7122 );
7123 assert_eq!(
7124 unsafe { ::std::ptr::addr_of!((*ptr).real_fmt) as usize - ptr as usize },
7125 20usize,
7126 concat!(
7127 "Offset of field: ",
7128 stringify!(cst_audiodev_struct),
7129 "::",
7130 stringify!(real_fmt)
7131 )
7132 );
7133 assert_eq!(
7134 unsafe { ::std::ptr::addr_of!((*ptr).byteswap) as usize - ptr as usize },
7135 24usize,
7136 concat!(
7137 "Offset of field: ",
7138 stringify!(cst_audiodev_struct),
7139 "::",
7140 stringify!(byteswap)
7141 )
7142 );
7143 assert_eq!(
7144 unsafe { ::std::ptr::addr_of!((*ptr).rateconv) as usize - ptr as usize },
7145 32usize,
7146 concat!(
7147 "Offset of field: ",
7148 stringify!(cst_audiodev_struct),
7149 "::",
7150 stringify!(rateconv)
7151 )
7152 );
7153 assert_eq!(
7154 unsafe { ::std::ptr::addr_of!((*ptr).platform_data) as usize - ptr as usize },
7155 40usize,
7156 concat!(
7157 "Offset of field: ",
7158 stringify!(cst_audiodev_struct),
7159 "::",
7160 stringify!(platform_data)
7161 )
7162 );
7163}
7164pub type cst_audiodev = cst_audiodev_struct;
7165extern "C" {
7166 pub fn audio_open(
7167 sps: ::std::os::raw::c_int,
7168 channels: ::std::os::raw::c_int,
7169 fmt: cst_audiofmt,
7170 ) -> *mut cst_audiodev;
7171}
7172extern "C" {
7173 pub fn audio_close(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
7174}
7175extern "C" {
7176 pub fn audio_write(
7177 ad: *mut cst_audiodev,
7178 buff: *mut ::std::os::raw::c_void,
7179 num_bytes: ::std::os::raw::c_int,
7180 ) -> ::std::os::raw::c_int;
7181}
7182extern "C" {
7183 pub fn audio_flush(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
7184}
7185extern "C" {
7186 pub fn audio_drain(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
7187}
7188extern "C" {
7189 pub fn play_wave(w: *mut cst_wave) -> ::std::os::raw::c_int;
7190}
7191extern "C" {
7192 pub fn play_wave_sync(
7193 w: *mut cst_wave,
7194 rel: *mut cst_relation,
7195 call_back: ::std::option::Option<
7196 unsafe extern "C" fn(arg1: *mut cst_item) -> ::std::os::raw::c_int,
7197 >,
7198 ) -> ::std::os::raw::c_int;
7199}
7200extern "C" {
7201 pub fn play_wave_client(
7202 w: *mut cst_wave,
7203 servername: *const ::std::os::raw::c_char,
7204 port: ::std::os::raw::c_int,
7205 encoding: *const ::std::os::raw::c_char,
7206 ) -> ::std::os::raw::c_int;
7207}
7208extern "C" {
7209 pub fn auserver(port: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
7210}
7211extern "C" {
7212 pub fn play_wave_device(w: *mut cst_wave, ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
7213}
7214extern "C" {
7215 pub fn audio_open_file(
7216 sps: ::std::os::raw::c_int,
7217 channels: ::std::os::raw::c_int,
7218 fmt: cst_audiofmt,
7219 filename: *const ::std::os::raw::c_char,
7220 ) -> *mut cst_audiodev;
7221}
7222extern "C" {
7223 pub fn audio_close_file(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
7224}
7225extern "C" {
7226 pub fn audio_write_file(
7227 ad: *mut cst_audiodev,
7228 buff: *mut ::std::os::raw::c_void,
7229 num_bytes: ::std::os::raw::c_int,
7230 ) -> ::std::os::raw::c_int;
7231}
7232extern "C" {
7233 pub fn audio_drain_file(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
7234}
7235extern "C" {
7236 pub fn audio_flush_file(ad: *mut cst_audiodev) -> ::std::os::raw::c_int;
7237}
7238#[repr(C)]
7239#[derive(Debug, Copy, Clone)]
7240pub struct cst_audio_streaming_info_struct {
7241 pub min_buffsize: ::std::os::raw::c_int,
7242 pub asc: ::std::option::Option<
7243 unsafe extern "C" fn(
7244 w: *const cst_wave,
7245 start: ::std::os::raw::c_int,
7246 size: ::std::os::raw::c_int,
7247 last: ::std::os::raw::c_int,
7248 asi: *mut cst_audio_streaming_info_struct,
7249 ) -> ::std::os::raw::c_int,
7250 >,
7251 pub utt: *const cst_utterance,
7252 pub item: *const cst_item,
7253 pub userdata: *mut ::std::os::raw::c_void,
7254}
7255#[test]
7256fn bindgen_test_layout_cst_audio_streaming_info_struct() {
7257 const UNINIT: ::std::mem::MaybeUninit<cst_audio_streaming_info_struct> =
7258 ::std::mem::MaybeUninit::uninit();
7259 let ptr = UNINIT.as_ptr();
7260 assert_eq!(
7261 ::std::mem::size_of::<cst_audio_streaming_info_struct>(),
7262 40usize,
7263 concat!("Size of: ", stringify!(cst_audio_streaming_info_struct))
7264 );
7265 assert_eq!(
7266 ::std::mem::align_of::<cst_audio_streaming_info_struct>(),
7267 8usize,
7268 concat!("Alignment of ", stringify!(cst_audio_streaming_info_struct))
7269 );
7270 assert_eq!(
7271 unsafe { ::std::ptr::addr_of!((*ptr).min_buffsize) as usize - ptr as usize },
7272 0usize,
7273 concat!(
7274 "Offset of field: ",
7275 stringify!(cst_audio_streaming_info_struct),
7276 "::",
7277 stringify!(min_buffsize)
7278 )
7279 );
7280 assert_eq!(
7281 unsafe { ::std::ptr::addr_of!((*ptr).asc) as usize - ptr as usize },
7282 8usize,
7283 concat!(
7284 "Offset of field: ",
7285 stringify!(cst_audio_streaming_info_struct),
7286 "::",
7287 stringify!(asc)
7288 )
7289 );
7290 assert_eq!(
7291 unsafe { ::std::ptr::addr_of!((*ptr).utt) as usize - ptr as usize },
7292 16usize,
7293 concat!(
7294 "Offset of field: ",
7295 stringify!(cst_audio_streaming_info_struct),
7296 "::",
7297 stringify!(utt)
7298 )
7299 );
7300 assert_eq!(
7301 unsafe { ::std::ptr::addr_of!((*ptr).item) as usize - ptr as usize },
7302 24usize,
7303 concat!(
7304 "Offset of field: ",
7305 stringify!(cst_audio_streaming_info_struct),
7306 "::",
7307 stringify!(item)
7308 )
7309 );
7310 assert_eq!(
7311 unsafe { ::std::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize },
7312 32usize,
7313 concat!(
7314 "Offset of field: ",
7315 stringify!(cst_audio_streaming_info_struct),
7316 "::",
7317 stringify!(userdata)
7318 )
7319 );
7320}
7321pub type cst_audio_streaming_info = cst_audio_streaming_info_struct;
7322extern "C" {
7323 pub fn new_audio_streaming_info() -> *mut cst_audio_streaming_info;
7324}
7325extern "C" {
7326 pub fn delete_audio_streaming_info(asi: *mut cst_audio_streaming_info);
7327}
7328extern "C" {
7329 pub static cst_val_type_audio_streaming_info: ::std::os::raw::c_int;
7330}
7331extern "C" {
7332 pub fn val_audio_streaming_info(v: *const cst_val) -> *mut cst_audio_streaming_info;
7333}
7334extern "C" {
7335 pub fn audio_streaming_info_val(v: *const cst_audio_streaming_info) -> *mut cst_val;
7336}
7337pub type cst_audio_stream_callback = ::std::option::Option<
7338 unsafe extern "C" fn(
7339 w: *const cst_wave,
7340 start: ::std::os::raw::c_int,
7341 size: ::std::os::raw::c_int,
7342 last: ::std::os::raw::c_int,
7343 asi: *mut cst_audio_streaming_info,
7344 ) -> ::std::os::raw::c_int,
7345>;
7346extern "C" {
7347 pub fn audio_stream_chunk(
7348 w: *const cst_wave,
7349 start: ::std::os::raw::c_int,
7350 size: ::std::os::raw::c_int,
7351 last: ::std::os::raw::c_int,
7352 asi: *mut cst_audio_streaming_info,
7353 ) -> ::std::os::raw::c_int;
7354}
7355extern "C" {
7356 pub fn utt_set_wave(u: *mut cst_utterance, w: *mut cst_wave) -> ::std::os::raw::c_int;
7357}
7358extern "C" {
7359 pub fn utt_wave(u: *mut cst_utterance) -> *mut cst_wave;
7360}
7361extern "C" {
7362 pub fn utt_input_text(u: *mut cst_utterance) -> *const ::std::os::raw::c_char;
7363}
7364extern "C" {
7365 pub fn utt_set_input_text(
7366 u: *mut cst_utterance,
7367 text: *const ::std::os::raw::c_char,
7368 ) -> ::std::os::raw::c_int;
7369}
7370#[repr(C)]
7371#[derive(Debug, Copy, Clone)]
7372pub struct cst_tokenstream_struct {
7373 pub fd: cst_file,
7374 pub file_pos: ::std::os::raw::c_int,
7375 pub line_number: ::std::os::raw::c_int,
7376 pub eof_flag: ::std::os::raw::c_int,
7377 pub string_buffer: *mut cst_string,
7378 pub current_char: ::std::os::raw::c_int,
7379 pub token_pos: ::std::os::raw::c_int,
7380 pub ws_max: ::std::os::raw::c_int,
7381 pub whitespace: *mut cst_string,
7382 pub prep_max: ::std::os::raw::c_int,
7383 pub prepunctuation: *mut cst_string,
7384 pub token_max: ::std::os::raw::c_int,
7385 pub token: *mut cst_string,
7386 pub postp_max: ::std::os::raw::c_int,
7387 pub postpunctuation: *mut cst_string,
7388 pub tags: *mut cst_features,
7389 pub utf8_explode_mode: ::std::os::raw::c_int,
7390 pub streamtype_data: *mut ::std::os::raw::c_void,
7391 pub p_whitespacesymbols: *const cst_string,
7392 pub p_singlecharsymbols: *const cst_string,
7393 pub p_prepunctuationsymbols: *const cst_string,
7394 pub p_postpunctuationsymbols: *const cst_string,
7395 pub charclass: [cst_string; 256usize],
7396 pub open: ::std::option::Option<
7397 unsafe extern "C" fn(
7398 ts: *mut cst_tokenstream_struct,
7399 filename: *const ::std::os::raw::c_char,
7400 ) -> ::std::os::raw::c_int,
7401 >,
7402 pub close: ::std::option::Option<unsafe extern "C" fn(ts: *mut cst_tokenstream_struct)>,
7403 pub eof: ::std::option::Option<
7404 unsafe extern "C" fn(ts: *mut cst_tokenstream_struct) -> ::std::os::raw::c_int,
7405 >,
7406 pub seek: ::std::option::Option<
7407 unsafe extern "C" fn(
7408 ts: *mut cst_tokenstream_struct,
7409 pos: ::std::os::raw::c_int,
7410 ) -> ::std::os::raw::c_int,
7411 >,
7412 pub tell: ::std::option::Option<
7413 unsafe extern "C" fn(ts: *mut cst_tokenstream_struct) -> ::std::os::raw::c_int,
7414 >,
7415 pub size: ::std::option::Option<
7416 unsafe extern "C" fn(ts: *mut cst_tokenstream_struct) -> ::std::os::raw::c_int,
7417 >,
7418 pub getc: ::std::option::Option<
7419 unsafe extern "C" fn(ts: *mut cst_tokenstream_struct) -> ::std::os::raw::c_int,
7420 >,
7421}
7422#[test]
7423fn bindgen_test_layout_cst_tokenstream_struct() {
7424 const UNINIT: ::std::mem::MaybeUninit<cst_tokenstream_struct> =
7425 ::std::mem::MaybeUninit::uninit();
7426 let ptr = UNINIT.as_ptr();
7427 assert_eq!(
7428 ::std::mem::size_of::<cst_tokenstream_struct>(),
7429 472usize,
7430 concat!("Size of: ", stringify!(cst_tokenstream_struct))
7431 );
7432 assert_eq!(
7433 ::std::mem::align_of::<cst_tokenstream_struct>(),
7434 8usize,
7435 concat!("Alignment of ", stringify!(cst_tokenstream_struct))
7436 );
7437 assert_eq!(
7438 unsafe { ::std::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
7439 0usize,
7440 concat!(
7441 "Offset of field: ",
7442 stringify!(cst_tokenstream_struct),
7443 "::",
7444 stringify!(fd)
7445 )
7446 );
7447 assert_eq!(
7448 unsafe { ::std::ptr::addr_of!((*ptr).file_pos) as usize - ptr as usize },
7449 8usize,
7450 concat!(
7451 "Offset of field: ",
7452 stringify!(cst_tokenstream_struct),
7453 "::",
7454 stringify!(file_pos)
7455 )
7456 );
7457 assert_eq!(
7458 unsafe { ::std::ptr::addr_of!((*ptr).line_number) as usize - ptr as usize },
7459 12usize,
7460 concat!(
7461 "Offset of field: ",
7462 stringify!(cst_tokenstream_struct),
7463 "::",
7464 stringify!(line_number)
7465 )
7466 );
7467 assert_eq!(
7468 unsafe { ::std::ptr::addr_of!((*ptr).eof_flag) as usize - ptr as usize },
7469 16usize,
7470 concat!(
7471 "Offset of field: ",
7472 stringify!(cst_tokenstream_struct),
7473 "::",
7474 stringify!(eof_flag)
7475 )
7476 );
7477 assert_eq!(
7478 unsafe { ::std::ptr::addr_of!((*ptr).string_buffer) as usize - ptr as usize },
7479 24usize,
7480 concat!(
7481 "Offset of field: ",
7482 stringify!(cst_tokenstream_struct),
7483 "::",
7484 stringify!(string_buffer)
7485 )
7486 );
7487 assert_eq!(
7488 unsafe { ::std::ptr::addr_of!((*ptr).current_char) as usize - ptr as usize },
7489 32usize,
7490 concat!(
7491 "Offset of field: ",
7492 stringify!(cst_tokenstream_struct),
7493 "::",
7494 stringify!(current_char)
7495 )
7496 );
7497 assert_eq!(
7498 unsafe { ::std::ptr::addr_of!((*ptr).token_pos) as usize - ptr as usize },
7499 36usize,
7500 concat!(
7501 "Offset of field: ",
7502 stringify!(cst_tokenstream_struct),
7503 "::",
7504 stringify!(token_pos)
7505 )
7506 );
7507 assert_eq!(
7508 unsafe { ::std::ptr::addr_of!((*ptr).ws_max) as usize - ptr as usize },
7509 40usize,
7510 concat!(
7511 "Offset of field: ",
7512 stringify!(cst_tokenstream_struct),
7513 "::",
7514 stringify!(ws_max)
7515 )
7516 );
7517 assert_eq!(
7518 unsafe { ::std::ptr::addr_of!((*ptr).whitespace) as usize - ptr as usize },
7519 48usize,
7520 concat!(
7521 "Offset of field: ",
7522 stringify!(cst_tokenstream_struct),
7523 "::",
7524 stringify!(whitespace)
7525 )
7526 );
7527 assert_eq!(
7528 unsafe { ::std::ptr::addr_of!((*ptr).prep_max) as usize - ptr as usize },
7529 56usize,
7530 concat!(
7531 "Offset of field: ",
7532 stringify!(cst_tokenstream_struct),
7533 "::",
7534 stringify!(prep_max)
7535 )
7536 );
7537 assert_eq!(
7538 unsafe { ::std::ptr::addr_of!((*ptr).prepunctuation) as usize - ptr as usize },
7539 64usize,
7540 concat!(
7541 "Offset of field: ",
7542 stringify!(cst_tokenstream_struct),
7543 "::",
7544 stringify!(prepunctuation)
7545 )
7546 );
7547 assert_eq!(
7548 unsafe { ::std::ptr::addr_of!((*ptr).token_max) as usize - ptr as usize },
7549 72usize,
7550 concat!(
7551 "Offset of field: ",
7552 stringify!(cst_tokenstream_struct),
7553 "::",
7554 stringify!(token_max)
7555 )
7556 );
7557 assert_eq!(
7558 unsafe { ::std::ptr::addr_of!((*ptr).token) as usize - ptr as usize },
7559 80usize,
7560 concat!(
7561 "Offset of field: ",
7562 stringify!(cst_tokenstream_struct),
7563 "::",
7564 stringify!(token)
7565 )
7566 );
7567 assert_eq!(
7568 unsafe { ::std::ptr::addr_of!((*ptr).postp_max) as usize - ptr as usize },
7569 88usize,
7570 concat!(
7571 "Offset of field: ",
7572 stringify!(cst_tokenstream_struct),
7573 "::",
7574 stringify!(postp_max)
7575 )
7576 );
7577 assert_eq!(
7578 unsafe { ::std::ptr::addr_of!((*ptr).postpunctuation) as usize - ptr as usize },
7579 96usize,
7580 concat!(
7581 "Offset of field: ",
7582 stringify!(cst_tokenstream_struct),
7583 "::",
7584 stringify!(postpunctuation)
7585 )
7586 );
7587 assert_eq!(
7588 unsafe { ::std::ptr::addr_of!((*ptr).tags) as usize - ptr as usize },
7589 104usize,
7590 concat!(
7591 "Offset of field: ",
7592 stringify!(cst_tokenstream_struct),
7593 "::",
7594 stringify!(tags)
7595 )
7596 );
7597 assert_eq!(
7598 unsafe { ::std::ptr::addr_of!((*ptr).utf8_explode_mode) as usize - ptr as usize },
7599 112usize,
7600 concat!(
7601 "Offset of field: ",
7602 stringify!(cst_tokenstream_struct),
7603 "::",
7604 stringify!(utf8_explode_mode)
7605 )
7606 );
7607 assert_eq!(
7608 unsafe { ::std::ptr::addr_of!((*ptr).streamtype_data) as usize - ptr as usize },
7609 120usize,
7610 concat!(
7611 "Offset of field: ",
7612 stringify!(cst_tokenstream_struct),
7613 "::",
7614 stringify!(streamtype_data)
7615 )
7616 );
7617 assert_eq!(
7618 unsafe { ::std::ptr::addr_of!((*ptr).p_whitespacesymbols) as usize - ptr as usize },
7619 128usize,
7620 concat!(
7621 "Offset of field: ",
7622 stringify!(cst_tokenstream_struct),
7623 "::",
7624 stringify!(p_whitespacesymbols)
7625 )
7626 );
7627 assert_eq!(
7628 unsafe { ::std::ptr::addr_of!((*ptr).p_singlecharsymbols) as usize - ptr as usize },
7629 136usize,
7630 concat!(
7631 "Offset of field: ",
7632 stringify!(cst_tokenstream_struct),
7633 "::",
7634 stringify!(p_singlecharsymbols)
7635 )
7636 );
7637 assert_eq!(
7638 unsafe { ::std::ptr::addr_of!((*ptr).p_prepunctuationsymbols) as usize - ptr as usize },
7639 144usize,
7640 concat!(
7641 "Offset of field: ",
7642 stringify!(cst_tokenstream_struct),
7643 "::",
7644 stringify!(p_prepunctuationsymbols)
7645 )
7646 );
7647 assert_eq!(
7648 unsafe { ::std::ptr::addr_of!((*ptr).p_postpunctuationsymbols) as usize - ptr as usize },
7649 152usize,
7650 concat!(
7651 "Offset of field: ",
7652 stringify!(cst_tokenstream_struct),
7653 "::",
7654 stringify!(p_postpunctuationsymbols)
7655 )
7656 );
7657 assert_eq!(
7658 unsafe { ::std::ptr::addr_of!((*ptr).charclass) as usize - ptr as usize },
7659 160usize,
7660 concat!(
7661 "Offset of field: ",
7662 stringify!(cst_tokenstream_struct),
7663 "::",
7664 stringify!(charclass)
7665 )
7666 );
7667 assert_eq!(
7668 unsafe { ::std::ptr::addr_of!((*ptr).open) as usize - ptr as usize },
7669 416usize,
7670 concat!(
7671 "Offset of field: ",
7672 stringify!(cst_tokenstream_struct),
7673 "::",
7674 stringify!(open)
7675 )
7676 );
7677 assert_eq!(
7678 unsafe { ::std::ptr::addr_of!((*ptr).close) as usize - ptr as usize },
7679 424usize,
7680 concat!(
7681 "Offset of field: ",
7682 stringify!(cst_tokenstream_struct),
7683 "::",
7684 stringify!(close)
7685 )
7686 );
7687 assert_eq!(
7688 unsafe { ::std::ptr::addr_of!((*ptr).eof) as usize - ptr as usize },
7689 432usize,
7690 concat!(
7691 "Offset of field: ",
7692 stringify!(cst_tokenstream_struct),
7693 "::",
7694 stringify!(eof)
7695 )
7696 );
7697 assert_eq!(
7698 unsafe { ::std::ptr::addr_of!((*ptr).seek) as usize - ptr as usize },
7699 440usize,
7700 concat!(
7701 "Offset of field: ",
7702 stringify!(cst_tokenstream_struct),
7703 "::",
7704 stringify!(seek)
7705 )
7706 );
7707 assert_eq!(
7708 unsafe { ::std::ptr::addr_of!((*ptr).tell) as usize - ptr as usize },
7709 448usize,
7710 concat!(
7711 "Offset of field: ",
7712 stringify!(cst_tokenstream_struct),
7713 "::",
7714 stringify!(tell)
7715 )
7716 );
7717 assert_eq!(
7718 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
7719 456usize,
7720 concat!(
7721 "Offset of field: ",
7722 stringify!(cst_tokenstream_struct),
7723 "::",
7724 stringify!(size)
7725 )
7726 );
7727 assert_eq!(
7728 unsafe { ::std::ptr::addr_of!((*ptr).getc) as usize - ptr as usize },
7729 464usize,
7730 concat!(
7731 "Offset of field: ",
7732 stringify!(cst_tokenstream_struct),
7733 "::",
7734 stringify!(getc)
7735 )
7736 );
7737}
7738pub type cst_tokenstream = cst_tokenstream_struct;
7739extern "C" {
7740 pub static cst_ts_default_whitespacesymbols: *const cst_string;
7741}
7742extern "C" {
7743 pub static cst_ts_default_prepunctuationsymbols: *const cst_string;
7744}
7745extern "C" {
7746 pub static cst_ts_default_postpunctuationsymbols: *const cst_string;
7747}
7748extern "C" {
7749 pub static cst_ts_default_singlecharsymbols: *const cst_string;
7750}
7751extern "C" {
7752 pub fn ts_open(
7753 filename: *const ::std::os::raw::c_char,
7754 whitespacesymbols: *const cst_string,
7755 singlecharsymbols: *const cst_string,
7756 prepunctsymbols: *const cst_string,
7757 postpunctsymbols: *const cst_string,
7758 ) -> *mut cst_tokenstream;
7759}
7760extern "C" {
7761 pub fn ts_open_string(
7762 string: *const cst_string,
7763 whitespacesymbols: *const cst_string,
7764 singlecharsymbols: *const cst_string,
7765 prepunctsymbols: *const cst_string,
7766 postpunctsymbols: *const cst_string,
7767 ) -> *mut cst_tokenstream;
7768}
7769extern "C" {
7770 pub fn ts_open_generic(
7771 filename: *const ::std::os::raw::c_char,
7772 whitespacesymbols: *const cst_string,
7773 singlecharsymbols: *const cst_string,
7774 prepunctsymbols: *const cst_string,
7775 postpunctsymbols: *const cst_string,
7776 streamtype_data: *mut ::std::os::raw::c_void,
7777 open: ::std::option::Option<
7778 unsafe extern "C" fn(
7779 ts: *mut cst_tokenstream,
7780 filename: *const ::std::os::raw::c_char,
7781 ) -> ::std::os::raw::c_int,
7782 >,
7783 close: ::std::option::Option<unsafe extern "C" fn(ts: *mut cst_tokenstream)>,
7784 eof: ::std::option::Option<
7785 unsafe extern "C" fn(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int,
7786 >,
7787 seek: ::std::option::Option<
7788 unsafe extern "C" fn(
7789 ts: *mut cst_tokenstream,
7790 pos: ::std::os::raw::c_int,
7791 ) -> ::std::os::raw::c_int,
7792 >,
7793 tell: ::std::option::Option<
7794 unsafe extern "C" fn(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int,
7795 >,
7796 size: ::std::option::Option<
7797 unsafe extern "C" fn(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int,
7798 >,
7799 getc: ::std::option::Option<
7800 unsafe extern "C" fn(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int,
7801 >,
7802 ) -> *mut cst_tokenstream;
7803}
7804extern "C" {
7805 pub fn ts_close(ts: *mut cst_tokenstream);
7806}
7807extern "C" {
7808 pub fn ts_utf8_sequence_length(c0: ::std::os::raw::c_char) -> ::std::os::raw::c_int;
7809}
7810extern "C" {
7811 pub fn ts_eof(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int;
7812}
7813extern "C" {
7814 pub fn ts_get(ts: *mut cst_tokenstream) -> *const cst_string;
7815}
7816extern "C" {
7817 pub fn ts_get_quoted_token(
7818 ts: *mut cst_tokenstream,
7819 quote: ::std::os::raw::c_char,
7820 escape: ::std::os::raw::c_char,
7821 ) -> *const cst_string;
7822}
7823extern "C" {
7824 pub fn private_ts_getc(ts: *mut cst_tokenstream) -> cst_string;
7825}
7826extern "C" {
7827 pub fn set_charclasses(
7828 ts: *mut cst_tokenstream,
7829 whitespace: *const cst_string,
7830 singlecharsymbols: *const cst_string,
7831 prepunctuation: *const cst_string,
7832 postpunctuation: *const cst_string,
7833 );
7834}
7835extern "C" {
7836 pub fn ts_read(
7837 buff: *mut ::std::os::raw::c_void,
7838 size: ::std::os::raw::c_int,
7839 num: ::std::os::raw::c_int,
7840 ts: *mut cst_tokenstream,
7841 ) -> ::std::os::raw::c_int;
7842}
7843extern "C" {
7844 pub fn ts_set_stream_pos(
7845 ts: *mut cst_tokenstream,
7846 pos: ::std::os::raw::c_int,
7847 ) -> ::std::os::raw::c_int;
7848}
7849extern "C" {
7850 pub fn ts_get_stream_pos(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int;
7851}
7852extern "C" {
7853 pub fn ts_get_stream_size(ts: *mut cst_tokenstream) -> ::std::os::raw::c_int;
7854}
7855pub type cst_breakfunc = ::std::option::Option<
7856 unsafe extern "C" fn(
7857 ts: *mut cst_tokenstream,
7858 token: *const ::std::os::raw::c_char,
7859 tokens: *mut cst_relation,
7860 ) -> ::std::os::raw::c_int,
7861>;
7862extern "C" {
7863 pub static cst_val_type_breakfunc: ::std::os::raw::c_int;
7864}
7865extern "C" {
7866 pub fn val_breakfunc(v: *const cst_val) -> cst_breakfunc;
7867}
7868extern "C" {
7869 pub fn breakfunc_val(v: cst_breakfunc) -> *mut cst_val;
7870}
7871extern "C" {
7872 pub fn default_utt_break(
7873 ts: *mut cst_tokenstream,
7874 token: *const ::std::os::raw::c_char,
7875 tokens: *mut cst_relation,
7876 ) -> ::std::os::raw::c_int;
7877}
7878extern "C" {
7879 pub fn utt_init(u: *mut cst_utterance, vox: *mut cst_voice) -> *mut cst_utterance;
7880}
7881extern "C" {
7882 pub fn utt_synth(u: *mut cst_utterance) -> *mut cst_utterance;
7883}
7884extern "C" {
7885 pub fn utt_synth_phones(u: *mut cst_utterance) -> *mut cst_utterance;
7886}
7887extern "C" {
7888 pub fn utt_synth_tokens(u: *mut cst_utterance) -> *mut cst_utterance;
7889}
7890extern "C" {
7891 pub fn utt_synth_wave(w: *mut cst_wave, v: *mut cst_voice) -> *mut cst_utterance;
7892}
7893#[repr(C)]
7894#[derive(Debug, Copy, Clone)]
7895pub struct cst_dur_stats_struct {
7896 pub phone: *const ::std::os::raw::c_char,
7897 pub mean: f32,
7898 pub stddev: f32,
7899}
7900#[test]
7901fn bindgen_test_layout_cst_dur_stats_struct() {
7902 const UNINIT: ::std::mem::MaybeUninit<cst_dur_stats_struct> = ::std::mem::MaybeUninit::uninit();
7903 let ptr = UNINIT.as_ptr();
7904 assert_eq!(
7905 ::std::mem::size_of::<cst_dur_stats_struct>(),
7906 16usize,
7907 concat!("Size of: ", stringify!(cst_dur_stats_struct))
7908 );
7909 assert_eq!(
7910 ::std::mem::align_of::<cst_dur_stats_struct>(),
7911 8usize,
7912 concat!("Alignment of ", stringify!(cst_dur_stats_struct))
7913 );
7914 assert_eq!(
7915 unsafe { ::std::ptr::addr_of!((*ptr).phone) as usize - ptr as usize },
7916 0usize,
7917 concat!(
7918 "Offset of field: ",
7919 stringify!(cst_dur_stats_struct),
7920 "::",
7921 stringify!(phone)
7922 )
7923 );
7924 assert_eq!(
7925 unsafe { ::std::ptr::addr_of!((*ptr).mean) as usize - ptr as usize },
7926 8usize,
7927 concat!(
7928 "Offset of field: ",
7929 stringify!(cst_dur_stats_struct),
7930 "::",
7931 stringify!(mean)
7932 )
7933 );
7934 assert_eq!(
7935 unsafe { ::std::ptr::addr_of!((*ptr).stddev) as usize - ptr as usize },
7936 12usize,
7937 concat!(
7938 "Offset of field: ",
7939 stringify!(cst_dur_stats_struct),
7940 "::",
7941 stringify!(stddev)
7942 )
7943 );
7944}
7945pub type dur_stat = cst_dur_stats_struct;
7946pub type dur_stats = *mut dur_stat;
7947extern "C" {
7948 pub static cst_val_type_dur_stats: ::std::os::raw::c_int;
7949}
7950extern "C" {
7951 pub fn val_dur_stats(v: *const cst_val) -> *mut dur_stats;
7952}
7953extern "C" {
7954 pub fn dur_stats_val(v: *const dur_stats) -> *mut cst_val;
7955}
7956extern "C" {
7957 pub fn default_segmentanalysis(u: *mut cst_utterance) -> *mut cst_utterance;
7958}
7959extern "C" {
7960 pub fn default_tokenization(u: *mut cst_utterance) -> *mut cst_utterance;
7961}
7962extern "C" {
7963 pub fn default_textanalysis(u: *mut cst_utterance) -> *mut cst_utterance;
7964}
7965extern "C" {
7966 pub fn default_tokentowords(i: *mut cst_item) -> *mut cst_val;
7967}
7968extern "C" {
7969 pub fn default_phrasing(u: *mut cst_utterance) -> *mut cst_utterance;
7970}
7971extern "C" {
7972 pub fn default_pos_tagger(u: *mut cst_utterance) -> *mut cst_utterance;
7973}
7974extern "C" {
7975 pub fn default_lexical_insertion(u: *mut cst_utterance) -> *mut cst_utterance;
7976}
7977extern "C" {
7978 pub fn default_pause_insertion(u: *mut cst_utterance) -> *mut cst_utterance;
7979}
7980extern "C" {
7981 pub fn cart_intonation(u: *mut cst_utterance) -> *mut cst_utterance;
7982}
7983extern "C" {
7984 pub fn cart_duration(u: *mut cst_utterance) -> *mut cst_utterance;
7985}
7986extern "C" {
7987 pub fn flat_prosody(u: *mut cst_utterance) -> *mut cst_utterance;
7988}
7989#[repr(C)]
7990#[derive(Debug, Copy, Clone)]
7991pub struct cst_synth_module_struct {
7992 pub hookname: *const ::std::os::raw::c_char,
7993 pub defhook: cst_uttfunc,
7994}
7995#[test]
7996fn bindgen_test_layout_cst_synth_module_struct() {
7997 const UNINIT: ::std::mem::MaybeUninit<cst_synth_module_struct> =
7998 ::std::mem::MaybeUninit::uninit();
7999 let ptr = UNINIT.as_ptr();
8000 assert_eq!(
8001 ::std::mem::size_of::<cst_synth_module_struct>(),
8002 16usize,
8003 concat!("Size of: ", stringify!(cst_synth_module_struct))
8004 );
8005 assert_eq!(
8006 ::std::mem::align_of::<cst_synth_module_struct>(),
8007 8usize,
8008 concat!("Alignment of ", stringify!(cst_synth_module_struct))
8009 );
8010 assert_eq!(
8011 unsafe { ::std::ptr::addr_of!((*ptr).hookname) as usize - ptr as usize },
8012 0usize,
8013 concat!(
8014 "Offset of field: ",
8015 stringify!(cst_synth_module_struct),
8016 "::",
8017 stringify!(hookname)
8018 )
8019 );
8020 assert_eq!(
8021 unsafe { ::std::ptr::addr_of!((*ptr).defhook) as usize - ptr as usize },
8022 8usize,
8023 concat!(
8024 "Offset of field: ",
8025 stringify!(cst_synth_module_struct),
8026 "::",
8027 stringify!(defhook)
8028 )
8029 );
8030}
8031pub type cst_synth_module = cst_synth_module_struct;
8032extern "C" {
8033 pub fn apply_synth_module(
8034 u: *mut cst_utterance,
8035 mod_: *const cst_synth_module,
8036 ) -> *mut cst_utterance;
8037}
8038extern "C" {
8039 pub fn apply_synth_method(
8040 u: *mut cst_utterance,
8041 meth: *const cst_synth_module,
8042 ) -> *mut cst_utterance;
8043}
8044#[repr(C)]
8045#[derive(Debug, Copy, Clone)]
8046pub struct cst_sts_struct {
8047 pub frame: *const ::std::os::raw::c_ushort,
8048 pub size: ::std::os::raw::c_int,
8049 pub residual: *const ::std::os::raw::c_uchar,
8050}
8051#[test]
8052fn bindgen_test_layout_cst_sts_struct() {
8053 const UNINIT: ::std::mem::MaybeUninit<cst_sts_struct> = ::std::mem::MaybeUninit::uninit();
8054 let ptr = UNINIT.as_ptr();
8055 assert_eq!(
8056 ::std::mem::size_of::<cst_sts_struct>(),
8057 24usize,
8058 concat!("Size of: ", stringify!(cst_sts_struct))
8059 );
8060 assert_eq!(
8061 ::std::mem::align_of::<cst_sts_struct>(),
8062 8usize,
8063 concat!("Alignment of ", stringify!(cst_sts_struct))
8064 );
8065 assert_eq!(
8066 unsafe { ::std::ptr::addr_of!((*ptr).frame) as usize - ptr as usize },
8067 0usize,
8068 concat!(
8069 "Offset of field: ",
8070 stringify!(cst_sts_struct),
8071 "::",
8072 stringify!(frame)
8073 )
8074 );
8075 assert_eq!(
8076 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8077 8usize,
8078 concat!(
8079 "Offset of field: ",
8080 stringify!(cst_sts_struct),
8081 "::",
8082 stringify!(size)
8083 )
8084 );
8085 assert_eq!(
8086 unsafe { ::std::ptr::addr_of!((*ptr).residual) as usize - ptr as usize },
8087 16usize,
8088 concat!(
8089 "Offset of field: ",
8090 stringify!(cst_sts_struct),
8091 "::",
8092 stringify!(residual)
8093 )
8094 );
8095}
8096pub type cst_sts = cst_sts_struct;
8097#[repr(C)]
8098#[derive(Debug, Copy, Clone)]
8099pub struct cst_sts_paged_struct {
8100 pub frame_offset: ::std::os::raw::c_uint,
8101 pub res_size: ::std::os::raw::c_ushort,
8102 pub res_offset: ::std::os::raw::c_uint,
8103 pub frame_page: *const ::std::os::raw::c_ushort,
8104 pub res_page: *const ::std::os::raw::c_uchar,
8105}
8106#[test]
8107fn bindgen_test_layout_cst_sts_paged_struct() {
8108 const UNINIT: ::std::mem::MaybeUninit<cst_sts_paged_struct> = ::std::mem::MaybeUninit::uninit();
8109 let ptr = UNINIT.as_ptr();
8110 assert_eq!(
8111 ::std::mem::size_of::<cst_sts_paged_struct>(),
8112 32usize,
8113 concat!("Size of: ", stringify!(cst_sts_paged_struct))
8114 );
8115 assert_eq!(
8116 ::std::mem::align_of::<cst_sts_paged_struct>(),
8117 8usize,
8118 concat!("Alignment of ", stringify!(cst_sts_paged_struct))
8119 );
8120 assert_eq!(
8121 unsafe { ::std::ptr::addr_of!((*ptr).frame_offset) as usize - ptr as usize },
8122 0usize,
8123 concat!(
8124 "Offset of field: ",
8125 stringify!(cst_sts_paged_struct),
8126 "::",
8127 stringify!(frame_offset)
8128 )
8129 );
8130 assert_eq!(
8131 unsafe { ::std::ptr::addr_of!((*ptr).res_size) as usize - ptr as usize },
8132 4usize,
8133 concat!(
8134 "Offset of field: ",
8135 stringify!(cst_sts_paged_struct),
8136 "::",
8137 stringify!(res_size)
8138 )
8139 );
8140 assert_eq!(
8141 unsafe { ::std::ptr::addr_of!((*ptr).res_offset) as usize - ptr as usize },
8142 8usize,
8143 concat!(
8144 "Offset of field: ",
8145 stringify!(cst_sts_paged_struct),
8146 "::",
8147 stringify!(res_offset)
8148 )
8149 );
8150 assert_eq!(
8151 unsafe { ::std::ptr::addr_of!((*ptr).frame_page) as usize - ptr as usize },
8152 16usize,
8153 concat!(
8154 "Offset of field: ",
8155 stringify!(cst_sts_paged_struct),
8156 "::",
8157 stringify!(frame_page)
8158 )
8159 );
8160 assert_eq!(
8161 unsafe { ::std::ptr::addr_of!((*ptr).res_page) as usize - ptr as usize },
8162 24usize,
8163 concat!(
8164 "Offset of field: ",
8165 stringify!(cst_sts_paged_struct),
8166 "::",
8167 stringify!(res_page)
8168 )
8169 );
8170}
8171pub type cst_sts_paged = cst_sts_paged_struct;
8172#[repr(C)]
8173#[derive(Debug, Copy, Clone)]
8174pub struct cst_sts_list_struct {
8175 pub sts: *const cst_sts,
8176 pub sts_paged: *const cst_sts_paged,
8177 pub frames: *const ::std::os::raw::c_ushort,
8178 pub residuals: *const ::std::os::raw::c_uchar,
8179 pub resoffs: *const ::std::os::raw::c_uint,
8180 pub ressizes: *const ::std::os::raw::c_uchar,
8181 pub num_sts: ::std::os::raw::c_int,
8182 pub num_channels: ::std::os::raw::c_int,
8183 pub sample_rate: ::std::os::raw::c_int,
8184 pub coeff_min: f32,
8185 pub coeff_range: f32,
8186 pub codec: *const ::std::os::raw::c_char,
8187}
8188#[test]
8189fn bindgen_test_layout_cst_sts_list_struct() {
8190 const UNINIT: ::std::mem::MaybeUninit<cst_sts_list_struct> = ::std::mem::MaybeUninit::uninit();
8191 let ptr = UNINIT.as_ptr();
8192 assert_eq!(
8193 ::std::mem::size_of::<cst_sts_list_struct>(),
8194 80usize,
8195 concat!("Size of: ", stringify!(cst_sts_list_struct))
8196 );
8197 assert_eq!(
8198 ::std::mem::align_of::<cst_sts_list_struct>(),
8199 8usize,
8200 concat!("Alignment of ", stringify!(cst_sts_list_struct))
8201 );
8202 assert_eq!(
8203 unsafe { ::std::ptr::addr_of!((*ptr).sts) as usize - ptr as usize },
8204 0usize,
8205 concat!(
8206 "Offset of field: ",
8207 stringify!(cst_sts_list_struct),
8208 "::",
8209 stringify!(sts)
8210 )
8211 );
8212 assert_eq!(
8213 unsafe { ::std::ptr::addr_of!((*ptr).sts_paged) as usize - ptr as usize },
8214 8usize,
8215 concat!(
8216 "Offset of field: ",
8217 stringify!(cst_sts_list_struct),
8218 "::",
8219 stringify!(sts_paged)
8220 )
8221 );
8222 assert_eq!(
8223 unsafe { ::std::ptr::addr_of!((*ptr).frames) as usize - ptr as usize },
8224 16usize,
8225 concat!(
8226 "Offset of field: ",
8227 stringify!(cst_sts_list_struct),
8228 "::",
8229 stringify!(frames)
8230 )
8231 );
8232 assert_eq!(
8233 unsafe { ::std::ptr::addr_of!((*ptr).residuals) as usize - ptr as usize },
8234 24usize,
8235 concat!(
8236 "Offset of field: ",
8237 stringify!(cst_sts_list_struct),
8238 "::",
8239 stringify!(residuals)
8240 )
8241 );
8242 assert_eq!(
8243 unsafe { ::std::ptr::addr_of!((*ptr).resoffs) as usize - ptr as usize },
8244 32usize,
8245 concat!(
8246 "Offset of field: ",
8247 stringify!(cst_sts_list_struct),
8248 "::",
8249 stringify!(resoffs)
8250 )
8251 );
8252 assert_eq!(
8253 unsafe { ::std::ptr::addr_of!((*ptr).ressizes) as usize - ptr as usize },
8254 40usize,
8255 concat!(
8256 "Offset of field: ",
8257 stringify!(cst_sts_list_struct),
8258 "::",
8259 stringify!(ressizes)
8260 )
8261 );
8262 assert_eq!(
8263 unsafe { ::std::ptr::addr_of!((*ptr).num_sts) as usize - ptr as usize },
8264 48usize,
8265 concat!(
8266 "Offset of field: ",
8267 stringify!(cst_sts_list_struct),
8268 "::",
8269 stringify!(num_sts)
8270 )
8271 );
8272 assert_eq!(
8273 unsafe { ::std::ptr::addr_of!((*ptr).num_channels) as usize - ptr as usize },
8274 52usize,
8275 concat!(
8276 "Offset of field: ",
8277 stringify!(cst_sts_list_struct),
8278 "::",
8279 stringify!(num_channels)
8280 )
8281 );
8282 assert_eq!(
8283 unsafe { ::std::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
8284 56usize,
8285 concat!(
8286 "Offset of field: ",
8287 stringify!(cst_sts_list_struct),
8288 "::",
8289 stringify!(sample_rate)
8290 )
8291 );
8292 assert_eq!(
8293 unsafe { ::std::ptr::addr_of!((*ptr).coeff_min) as usize - ptr as usize },
8294 60usize,
8295 concat!(
8296 "Offset of field: ",
8297 stringify!(cst_sts_list_struct),
8298 "::",
8299 stringify!(coeff_min)
8300 )
8301 );
8302 assert_eq!(
8303 unsafe { ::std::ptr::addr_of!((*ptr).coeff_range) as usize - ptr as usize },
8304 64usize,
8305 concat!(
8306 "Offset of field: ",
8307 stringify!(cst_sts_list_struct),
8308 "::",
8309 stringify!(coeff_range)
8310 )
8311 );
8312 assert_eq!(
8313 unsafe { ::std::ptr::addr_of!((*ptr).codec) as usize - ptr as usize },
8314 72usize,
8315 concat!(
8316 "Offset of field: ",
8317 stringify!(cst_sts_list_struct),
8318 "::",
8319 stringify!(codec)
8320 )
8321 );
8322}
8323pub type cst_sts_list = cst_sts_list_struct;
8324#[repr(C)]
8325#[derive(Debug, Copy, Clone)]
8326pub struct cst_lpcres_struct {
8327 pub frames: *mut *const ::std::os::raw::c_ushort,
8328 pub times: *mut ::std::os::raw::c_int,
8329 pub num_frames: ::std::os::raw::c_int,
8330 pub num_channels: ::std::os::raw::c_int,
8331 pub lpc_min: f32,
8332 pub lpc_range: f32,
8333 pub num_samples: ::std::os::raw::c_int,
8334 pub sample_rate: ::std::os::raw::c_int,
8335 pub sizes: *mut ::std::os::raw::c_int,
8336 pub residual: *mut ::std::os::raw::c_uchar,
8337 pub asi: *mut cst_audio_streaming_info,
8338 pub packed_residuals: *mut *const ::std::os::raw::c_uchar,
8339 pub delayed_decoding: ::std::os::raw::c_int,
8340}
8341#[test]
8342fn bindgen_test_layout_cst_lpcres_struct() {
8343 const UNINIT: ::std::mem::MaybeUninit<cst_lpcres_struct> = ::std::mem::MaybeUninit::uninit();
8344 let ptr = UNINIT.as_ptr();
8345 assert_eq!(
8346 ::std::mem::size_of::<cst_lpcres_struct>(),
8347 80usize,
8348 concat!("Size of: ", stringify!(cst_lpcres_struct))
8349 );
8350 assert_eq!(
8351 ::std::mem::align_of::<cst_lpcres_struct>(),
8352 8usize,
8353 concat!("Alignment of ", stringify!(cst_lpcres_struct))
8354 );
8355 assert_eq!(
8356 unsafe { ::std::ptr::addr_of!((*ptr).frames) as usize - ptr as usize },
8357 0usize,
8358 concat!(
8359 "Offset of field: ",
8360 stringify!(cst_lpcres_struct),
8361 "::",
8362 stringify!(frames)
8363 )
8364 );
8365 assert_eq!(
8366 unsafe { ::std::ptr::addr_of!((*ptr).times) as usize - ptr as usize },
8367 8usize,
8368 concat!(
8369 "Offset of field: ",
8370 stringify!(cst_lpcres_struct),
8371 "::",
8372 stringify!(times)
8373 )
8374 );
8375 assert_eq!(
8376 unsafe { ::std::ptr::addr_of!((*ptr).num_frames) as usize - ptr as usize },
8377 16usize,
8378 concat!(
8379 "Offset of field: ",
8380 stringify!(cst_lpcres_struct),
8381 "::",
8382 stringify!(num_frames)
8383 )
8384 );
8385 assert_eq!(
8386 unsafe { ::std::ptr::addr_of!((*ptr).num_channels) as usize - ptr as usize },
8387 20usize,
8388 concat!(
8389 "Offset of field: ",
8390 stringify!(cst_lpcres_struct),
8391 "::",
8392 stringify!(num_channels)
8393 )
8394 );
8395 assert_eq!(
8396 unsafe { ::std::ptr::addr_of!((*ptr).lpc_min) as usize - ptr as usize },
8397 24usize,
8398 concat!(
8399 "Offset of field: ",
8400 stringify!(cst_lpcres_struct),
8401 "::",
8402 stringify!(lpc_min)
8403 )
8404 );
8405 assert_eq!(
8406 unsafe { ::std::ptr::addr_of!((*ptr).lpc_range) as usize - ptr as usize },
8407 28usize,
8408 concat!(
8409 "Offset of field: ",
8410 stringify!(cst_lpcres_struct),
8411 "::",
8412 stringify!(lpc_range)
8413 )
8414 );
8415 assert_eq!(
8416 unsafe { ::std::ptr::addr_of!((*ptr).num_samples) as usize - ptr as usize },
8417 32usize,
8418 concat!(
8419 "Offset of field: ",
8420 stringify!(cst_lpcres_struct),
8421 "::",
8422 stringify!(num_samples)
8423 )
8424 );
8425 assert_eq!(
8426 unsafe { ::std::ptr::addr_of!((*ptr).sample_rate) as usize - ptr as usize },
8427 36usize,
8428 concat!(
8429 "Offset of field: ",
8430 stringify!(cst_lpcres_struct),
8431 "::",
8432 stringify!(sample_rate)
8433 )
8434 );
8435 assert_eq!(
8436 unsafe { ::std::ptr::addr_of!((*ptr).sizes) as usize - ptr as usize },
8437 40usize,
8438 concat!(
8439 "Offset of field: ",
8440 stringify!(cst_lpcres_struct),
8441 "::",
8442 stringify!(sizes)
8443 )
8444 );
8445 assert_eq!(
8446 unsafe { ::std::ptr::addr_of!((*ptr).residual) as usize - ptr as usize },
8447 48usize,
8448 concat!(
8449 "Offset of field: ",
8450 stringify!(cst_lpcres_struct),
8451 "::",
8452 stringify!(residual)
8453 )
8454 );
8455 assert_eq!(
8456 unsafe { ::std::ptr::addr_of!((*ptr).asi) as usize - ptr as usize },
8457 56usize,
8458 concat!(
8459 "Offset of field: ",
8460 stringify!(cst_lpcres_struct),
8461 "::",
8462 stringify!(asi)
8463 )
8464 );
8465 assert_eq!(
8466 unsafe { ::std::ptr::addr_of!((*ptr).packed_residuals) as usize - ptr as usize },
8467 64usize,
8468 concat!(
8469 "Offset of field: ",
8470 stringify!(cst_lpcres_struct),
8471 "::",
8472 stringify!(packed_residuals)
8473 )
8474 );
8475 assert_eq!(
8476 unsafe { ::std::ptr::addr_of!((*ptr).delayed_decoding) as usize - ptr as usize },
8477 72usize,
8478 concat!(
8479 "Offset of field: ",
8480 stringify!(cst_lpcres_struct),
8481 "::",
8482 stringify!(delayed_decoding)
8483 )
8484 );
8485}
8486pub type cst_lpcres = cst_lpcres_struct;
8487extern "C" {
8488 pub fn new_lpcres() -> *mut cst_lpcres;
8489}
8490extern "C" {
8491 pub fn delete_lpcres(l: *mut cst_lpcres);
8492}
8493extern "C" {
8494 pub fn lpcres_frame_shift(t: *mut cst_lpcres, frame: ::std::os::raw::c_int) -> f32;
8495}
8496extern "C" {
8497 pub fn lpcres_resize_frames(l: *mut cst_lpcres, num_frames: ::std::os::raw::c_int);
8498}
8499extern "C" {
8500 pub fn lpcres_resize_samples(l: *mut cst_lpcres, num_samples: ::std::os::raw::c_int);
8501}
8502extern "C" {
8503 pub fn new_sts_list() -> *mut cst_sts_list;
8504}
8505extern "C" {
8506 pub fn delete_sts_list(l: *mut cst_sts_list);
8507}
8508extern "C" {
8509 pub fn get_sts_frame(
8510 sts_list: *const cst_sts_list,
8511 frame: ::std::os::raw::c_int,
8512 ) -> *const ::std::os::raw::c_ushort;
8513}
8514extern "C" {
8515 pub fn get_sts_residual(
8516 sts_list: *const cst_sts_list,
8517 frame: ::std::os::raw::c_int,
8518 ) -> *const ::std::os::raw::c_uchar;
8519}
8520extern "C" {
8521 pub fn get_sts_residual_fixed(
8522 sts_list: *const cst_sts_list,
8523 frame: ::std::os::raw::c_int,
8524 ) -> *const ::std::os::raw::c_uchar;
8525}
8526extern "C" {
8527 pub fn get_frame_size(
8528 sts_list: *const cst_sts_list,
8529 frame: ::std::os::raw::c_int,
8530 ) -> ::std::os::raw::c_int;
8531}
8532extern "C" {
8533 pub fn get_unit_size(
8534 s: *const cst_sts_list,
8535 start: ::std::os::raw::c_int,
8536 end: ::std::os::raw::c_int,
8537 ) -> ::std::os::raw::c_int;
8538}
8539extern "C" {
8540 pub static cst_val_type_lpcres: ::std::os::raw::c_int;
8541}
8542extern "C" {
8543 pub fn val_lpcres(v: *const cst_val) -> *mut cst_lpcres;
8544}
8545extern "C" {
8546 pub fn lpcres_val(v: *const cst_lpcres) -> *mut cst_val;
8547}
8548extern "C" {
8549 pub static cst_val_type_sts_list: ::std::os::raw::c_int;
8550}
8551extern "C" {
8552 pub fn val_sts_list(v: *const cst_val) -> *mut cst_sts_list;
8553}
8554extern "C" {
8555 pub fn sts_list_val(v: *const cst_sts_list) -> *mut cst_val;
8556}
8557extern "C" {
8558 pub fn join_units(utt: *mut cst_utterance) -> *mut cst_utterance;
8559}
8560extern "C" {
8561 pub fn join_units_windowed(utt: *mut cst_utterance) -> *mut cst_utterance;
8562}
8563extern "C" {
8564 pub fn join_units_simple(utt: *mut cst_utterance) -> *mut cst_utterance;
8565}
8566extern "C" {
8567 pub fn join_units_modified_lpc(utt: *mut cst_utterance) -> *mut cst_utterance;
8568}
8569extern "C" {
8570 pub fn asis_to_pm(utt: *mut cst_utterance) -> *mut cst_utterance;
8571}
8572extern "C" {
8573 pub fn f0_targets_to_pm(utt: *mut cst_utterance) -> *mut cst_utterance;
8574}
8575extern "C" {
8576 pub fn concat_units(utt: *mut cst_utterance) -> *mut cst_utterance;
8577}
8578extern "C" {
8579 pub fn add_residual(
8580 targ_size: ::std::os::raw::c_int,
8581 targ_residual: *mut ::std::os::raw::c_uchar,
8582 unit_size: ::std::os::raw::c_int,
8583 unit_residual: *const ::std::os::raw::c_uchar,
8584 );
8585}
8586extern "C" {
8587 pub fn add_residual_pulse(
8588 targ_size: ::std::os::raw::c_int,
8589 targ_residual: *mut ::std::os::raw::c_uchar,
8590 unit_size: ::std::os::raw::c_int,
8591 unit_residual: *const ::std::os::raw::c_uchar,
8592 );
8593}
8594extern "C" {
8595 pub static mut flite_voice_list: *mut cst_val;
8596}
8597extern "C" {
8598 pub static mut flite_lang_list: [cst_lang; 20usize];
8599}
8600extern "C" {
8601 pub static mut flite_lang_list_length: ::std::os::raw::c_int;
8602}
8603extern "C" {
8604 pub fn flite_init() -> ::std::os::raw::c_int;
8605}
8606extern "C" {
8607 pub fn flite_voice_select(name: *const ::std::os::raw::c_char) -> *mut cst_voice;
8608}
8609extern "C" {
8610 pub fn flite_voice_load(voice_filename: *const ::std::os::raw::c_char) -> *mut cst_voice;
8611}
8612extern "C" {
8613 pub fn flite_voice_dump(
8614 voice: *mut cst_voice,
8615 voice_filename: *const ::std::os::raw::c_char,
8616 ) -> ::std::os::raw::c_int;
8617}
8618extern "C" {
8619 pub fn flite_file_to_speech(
8620 filename: *const ::std::os::raw::c_char,
8621 voice: *mut cst_voice,
8622 outtype: *const ::std::os::raw::c_char,
8623 ) -> f32;
8624}
8625extern "C" {
8626 pub fn flite_text_to_speech(
8627 text: *const ::std::os::raw::c_char,
8628 voice: *mut cst_voice,
8629 outtype: *const ::std::os::raw::c_char,
8630 ) -> f32;
8631}
8632extern "C" {
8633 pub fn flite_phones_to_speech(
8634 text: *const ::std::os::raw::c_char,
8635 voice: *mut cst_voice,
8636 outtype: *const ::std::os::raw::c_char,
8637 ) -> f32;
8638}
8639extern "C" {
8640 pub fn flite_ssml_file_to_speech(
8641 filename: *const ::std::os::raw::c_char,
8642 voice: *mut cst_voice,
8643 outtype: *const ::std::os::raw::c_char,
8644 ) -> f32;
8645}
8646extern "C" {
8647 pub fn flite_ssml_text_to_speech(
8648 text: *const ::std::os::raw::c_char,
8649 voice: *mut cst_voice,
8650 outtype: *const ::std::os::raw::c_char,
8651 ) -> f32;
8652}
8653extern "C" {
8654 pub fn flite_voice_add_lex_addenda(
8655 v: *mut cst_voice,
8656 lexfile: *const cst_string,
8657 ) -> ::std::os::raw::c_int;
8658}
8659extern "C" {
8660 pub fn flite_text_to_wave(
8661 text: *const ::std::os::raw::c_char,
8662 voice: *mut cst_voice,
8663 ) -> *mut cst_wave;
8664}
8665extern "C" {
8666 pub fn flite_synth_text(
8667 text: *const ::std::os::raw::c_char,
8668 voice: *mut cst_voice,
8669 ) -> *mut cst_utterance;
8670}
8671extern "C" {
8672 pub fn flite_synth_phones(
8673 phones: *const ::std::os::raw::c_char,
8674 voice: *mut cst_voice,
8675 ) -> *mut cst_utterance;
8676}
8677extern "C" {
8678 pub fn flite_ts_to_speech(
8679 ts: *mut cst_tokenstream,
8680 voice: *mut cst_voice,
8681 outtype: *const ::std::os::raw::c_char,
8682 ) -> f32;
8683}
8684extern "C" {
8685 pub fn flite_do_synth(
8686 u: *mut cst_utterance,
8687 voice: *mut cst_voice,
8688 synth: cst_uttfunc,
8689 ) -> *mut cst_utterance;
8690}
8691extern "C" {
8692 pub fn flite_process_output(
8693 u: *mut cst_utterance,
8694 outtype: *const ::std::os::raw::c_char,
8695 append: ::std::os::raw::c_int,
8696 ) -> f32;
8697}
8698extern "C" {
8699 pub fn flite_mmap_clunit_voxdata(
8700 voxdir: *const ::std::os::raw::c_char,
8701 voice: *mut cst_voice,
8702 ) -> ::std::os::raw::c_int;
8703}
8704extern "C" {
8705 pub fn flite_munmap_clunit_voxdata(voice: *mut cst_voice) -> ::std::os::raw::c_int;
8706}
8707extern "C" {
8708 pub fn flite_get_param_int(
8709 f: *const cst_features,
8710 name: *const ::std::os::raw::c_char,
8711 def: ::std::os::raw::c_int,
8712 ) -> ::std::os::raw::c_int;
8713}
8714extern "C" {
8715 pub fn flite_get_param_float(
8716 f: *const cst_features,
8717 name: *const ::std::os::raw::c_char,
8718 def: f32,
8719 ) -> f32;
8720}
8721extern "C" {
8722 pub fn flite_get_param_string(
8723 f: *const cst_features,
8724 name: *const ::std::os::raw::c_char,
8725 def: *const ::std::os::raw::c_char,
8726 ) -> *const ::std::os::raw::c_char;
8727}
8728extern "C" {
8729 pub fn flite_get_param_val(
8730 f: *const cst_features,
8731 name: *const ::std::os::raw::c_char,
8732 def: *mut cst_val,
8733 ) -> *const cst_val;
8734}
8735extern "C" {
8736 pub fn flite_feat_set_int(
8737 f: *mut cst_features,
8738 name: *const ::std::os::raw::c_char,
8739 v: ::std::os::raw::c_int,
8740 );
8741}
8742extern "C" {
8743 pub fn flite_feat_set_float(f: *mut cst_features, name: *const ::std::os::raw::c_char, v: f32);
8744}
8745extern "C" {
8746 pub fn flite_feat_set_string(
8747 f: *mut cst_features,
8748 name: *const ::std::os::raw::c_char,
8749 v: *const ::std::os::raw::c_char,
8750 );
8751}
8752extern "C" {
8753 pub fn flite_feat_set(
8754 f: *mut cst_features,
8755 name: *const ::std::os::raw::c_char,
8756 v: *const cst_val,
8757 );
8758}
8759extern "C" {
8760 pub fn flite_feat_remove(
8761 f: *mut cst_features,
8762 name: *const ::std::os::raw::c_char,
8763 ) -> ::std::os::raw::c_int;
8764}
8765extern "C" {
8766 pub fn flite_ffeature_string(
8767 item: *const cst_item,
8768 featpath: *const ::std::os::raw::c_char,
8769 ) -> *const ::std::os::raw::c_char;
8770}
8771extern "C" {
8772 pub fn flite_ffeature_int(
8773 item: *const cst_item,
8774 featpath: *const ::std::os::raw::c_char,
8775 ) -> ::std::os::raw::c_int;
8776}
8777extern "C" {
8778 pub fn flite_ffeature_float(
8779 item: *const cst_item,
8780 featpath: *const ::std::os::raw::c_char,
8781 ) -> f32;
8782}
8783extern "C" {
8784 pub fn flite_ffeature(
8785 item: *const cst_item,
8786 featpath: *const ::std::os::raw::c_char,
8787 ) -> *const cst_val;
8788}
8789extern "C" {
8790 pub fn flite_path_to_item(
8791 item: *const cst_item,
8792 featpath: *const ::std::os::raw::c_char,
8793 ) -> *mut cst_item;
8794}
8795extern "C" {
8796 pub fn flite_add_voice(voice: *mut cst_voice) -> ::std::os::raw::c_int;
8797}
8798extern "C" {
8799 pub fn flite_add_lang(
8800 langname: *const ::std::os::raw::c_char,
8801 lang_init: ::std::option::Option<unsafe extern "C" fn(vox: *mut cst_voice)>,
8802 lex_init: ::std::option::Option<unsafe extern "C" fn() -> *mut cst_lexicon>,
8803 ) -> ::std::os::raw::c_int;
8804}
8805extern "C" {
8806 pub fn utf8_grapheme_lang_init(v: *mut cst_voice);
8807}
8808extern "C" {
8809 pub fn utf8_grapheme_lex_init() -> *mut cst_lexicon;
8810}
8811#[repr(C)]
8812#[derive(Debug, Copy, Clone)]
8813pub struct __locale_data {
8814 pub _address: u8,
8815}
8816pub type __builtin_va_list = [__va_list_tag; 1usize];
8817#[repr(C)]
8818#[derive(Debug, Copy, Clone)]
8819pub struct __va_list_tag {
8820 pub gp_offset: ::std::os::raw::c_uint,
8821 pub fp_offset: ::std::os::raw::c_uint,
8822 pub overflow_arg_area: *mut ::std::os::raw::c_void,
8823 pub reg_save_area: *mut ::std::os::raw::c_void,
8824}
8825#[test]
8826fn bindgen_test_layout___va_list_tag() {
8827 const UNINIT: ::std::mem::MaybeUninit<__va_list_tag> = ::std::mem::MaybeUninit::uninit();
8828 let ptr = UNINIT.as_ptr();
8829 assert_eq!(
8830 ::std::mem::size_of::<__va_list_tag>(),
8831 24usize,
8832 concat!("Size of: ", stringify!(__va_list_tag))
8833 );
8834 assert_eq!(
8835 ::std::mem::align_of::<__va_list_tag>(),
8836 8usize,
8837 concat!("Alignment of ", stringify!(__va_list_tag))
8838 );
8839 assert_eq!(
8840 unsafe { ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
8841 0usize,
8842 concat!(
8843 "Offset of field: ",
8844 stringify!(__va_list_tag),
8845 "::",
8846 stringify!(gp_offset)
8847 )
8848 );
8849 assert_eq!(
8850 unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
8851 4usize,
8852 concat!(
8853 "Offset of field: ",
8854 stringify!(__va_list_tag),
8855 "::",
8856 stringify!(fp_offset)
8857 )
8858 );
8859 assert_eq!(
8860 unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
8861 8usize,
8862 concat!(
8863 "Offset of field: ",
8864 stringify!(__va_list_tag),
8865 "::",
8866 stringify!(overflow_arg_area)
8867 )
8868 );
8869 assert_eq!(
8870 unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
8871 16usize,
8872 concat!(
8873 "Offset of field: ",
8874 stringify!(__va_list_tag),
8875 "::",
8876 stringify!(reg_save_area)
8877 )
8878 );
8879}