1#![allow(non_camel_case_types)]
2#![allow(non_snake_case)]
3extern crate libc;
6use libc::{
7 c_long,
8 c_longlong,
9 c_double,
10 c_ulong,
11 c_void,
12 c_int,
13 c_char,
14 c_ushort,
15 c_uint,
16 c_float,
17 c_ulonglong,
18 c_short,
19 c_uchar
20};
21
22pub type ptrdiff_t = c_long;
23pub type size_t = c_ulong;
24pub type wchar_t = c_int;
25#[repr(C)]
26#[derive(Copy)]
27pub struct Struct_Unnamed1 {
28 pub __clang_max_align_nonce1: c_longlong,
29 pub __clang_max_align_nonce2: c_double,
30}
31impl ::std::clone::Clone for Struct_Unnamed1 {
32 fn clone(&self) -> Self { *self }
33}
34impl ::std::default::Default for Struct_Unnamed1 {
35 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
36}
37pub type max_align_t = Struct_Unnamed1;
38pub type mp_limb_t = c_ulong;
39pub type mp_limb_signed_t = c_long;
40pub type mp_bitcnt_t = c_ulong;
41#[repr(C)]
42#[derive(Copy)]
43pub struct Struct_Unnamed2 {
44 pub _mp_alloc: c_int,
45 pub _mp_size: c_int,
46 pub _mp_d: *mut mp_limb_t,
47}
48impl ::std::clone::Clone for Struct_Unnamed2 {
49 fn clone(&self) -> Self { *self }
50}
51impl ::std::default::Default for Struct_Unnamed2 {
52 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
53}
54pub type __mpz_struct = Struct_Unnamed2;
55pub type MP_INT = __mpz_struct;
56pub type mpz_t = [__mpz_struct; 1usize];
57pub type mp_ptr = *mut mp_limb_t;
58pub type mp_srcptr = *const mp_limb_t;
59pub type mp_size_t = c_long;
60pub type mp_exp_t = c_long;
61#[repr(C)]
62#[derive(Copy)]
63pub struct Struct_Unnamed3 {
64 pub _mp_num: __mpz_struct,
65 pub _mp_den: __mpz_struct,
66}
67impl ::std::clone::Clone for Struct_Unnamed3 {
68 fn clone(&self) -> Self { *self }
69}
70impl ::std::default::Default for Struct_Unnamed3 {
71 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
72}
73pub type __mpq_struct = Struct_Unnamed3;
74pub type MP_RAT = __mpq_struct;
75pub type mpq_t = [__mpq_struct; 1usize];
76#[repr(C)]
77#[derive(Copy)]
78pub struct Struct_Unnamed4 {
79 pub _mp_prec: c_int,
80 pub _mp_size: c_int,
81 pub _mp_exp: mp_exp_t,
82 pub _mp_d: *mut mp_limb_t,
83}
84impl ::std::clone::Clone for Struct_Unnamed4 {
85 fn clone(&self) -> Self { *self }
86}
87impl ::std::default::Default for Struct_Unnamed4 {
88 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
89}
90pub type __mpf_struct = Struct_Unnamed4;
91pub type mpf_t = [__mpf_struct; 1usize];
92pub const GMP_RAND_ALG_LC: Enum_Unnamed5 =
93 Enum_Unnamed5::GMP_RAND_ALG_DEFAULT;
94#[derive(Clone, Copy)]
95#[repr(u32)]
96pub enum Enum_Unnamed5 { GMP_RAND_ALG_DEFAULT = 0, }
97pub type gmp_randalg_t = Enum_Unnamed5;
98#[repr(C)]
99#[derive(Copy)]
100pub struct Struct_Unnamed6 {
101 pub _mp_seed: mpz_t,
102 pub _mp_alg: gmp_randalg_t,
103 pub _mp_algdata: Union_Unnamed7,
104}
105impl ::std::clone::Clone for Struct_Unnamed6 {
106 fn clone(&self) -> Self { *self }
107}
108impl ::std::default::Default for Struct_Unnamed6 {
109 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
110}
111#[repr(C)]
112#[derive(Copy)]
113pub struct Union_Unnamed7 {
114 pub _bindgen_data_: [u64; 1usize],
115}
116impl Union_Unnamed7 {
117 pub unsafe fn _mp_lc(&mut self) -> *mut *mut c_void {
118 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
119 ::std::mem::transmute(raw.offset(0))
120 }
121}
122impl ::std::clone::Clone for Union_Unnamed7 {
123 fn clone(&self) -> Self { *self }
124}
125impl ::std::default::Default for Union_Unnamed7 {
126 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
127}
128pub type __gmp_randstate_struct = Struct_Unnamed6;
129pub type gmp_randstate_t = [__gmp_randstate_struct; 1usize];
130pub type mpz_srcptr = *const __mpz_struct;
131pub type mpz_ptr = *mut __mpz_struct;
132pub type mpf_srcptr = *const __mpf_struct;
133pub type mpf_ptr = *mut __mpf_struct;
134pub type mpq_srcptr = *const __mpq_struct;
135pub type mpq_ptr = *mut __mpq_struct;
136#[derive(Clone, Copy)]
137#[repr(u32)]
138pub enum Enum_Unnamed8 {
139 GMP_ERROR_NONE = 0,
140 GMP_ERROR_UNSUPPORTED_ARGUMENT = 1,
141 GMP_ERROR_DIVISION_BY_ZERO = 2,
142 GMP_ERROR_SQRT_OF_NEGATIVE = 4,
143 GMP_ERROR_INVALID_ARGUMENT = 8,
144}
145pub type int8_t = c_char;
146pub type int16_t = c_short;
147pub type int32_t = c_int;
148pub type int64_t = c_long;
149pub type uint8_t = c_uchar;
150pub type uint16_t = c_ushort;
151pub type uint32_t = c_uint;
152pub type uint64_t = c_ulong;
153pub type int_least8_t = c_char;
154pub type int_least16_t = c_short;
155pub type int_least32_t = c_int;
156pub type int_least64_t = c_long;
157pub type uint_least8_t = c_uchar;
158pub type uint_least16_t = c_ushort;
159pub type uint_least32_t = c_uint;
160pub type uint_least64_t = c_ulong;
161pub type int_fast8_t = c_char;
162pub type int_fast16_t = c_long;
163pub type int_fast32_t = c_long;
164pub type int_fast64_t = c_long;
165pub type uint_fast8_t = c_uchar;
166pub type uint_fast16_t = c_ulong;
167pub type uint_fast32_t = c_ulong;
168pub type uint_fast64_t = c_ulong;
169pub type intptr_t = c_long;
170pub type uintptr_t = c_ulong;
171pub type intmax_t = c_long;
172pub type uintmax_t = c_ulong;
173pub type __u_char = c_uchar;
174pub type __u_short = c_ushort;
175pub type __u_int = c_uint;
176pub type __u_long = c_ulong;
177pub type __int8_t = c_char;
178pub type __uint8_t = c_uchar;
179pub type __int16_t = c_short;
180pub type __uint16_t = c_ushort;
181pub type __int32_t = c_int;
182pub type __uint32_t = c_uint;
183pub type __int64_t = c_long;
184pub type __uint64_t = c_ulong;
185pub type __quad_t = c_long;
186pub type __u_quad_t = c_ulong;
187pub type __dev_t = c_ulong;
188pub type __uid_t = c_uint;
189pub type __gid_t = c_uint;
190pub type __ino_t = c_ulong;
191pub type __ino64_t = c_ulong;
192pub type __mode_t = c_uint;
193pub type __nlink_t = c_ulong;
194pub type __off_t = c_long;
195pub type __off64_t = c_long;
196pub type __pid_t = c_int;
197#[repr(C)]
198#[derive(Copy)]
199pub struct Struct_Unnamed9 {
200 pub __val: [c_int; 2usize],
201}
202impl ::std::clone::Clone for Struct_Unnamed9 {
203 fn clone(&self) -> Self { *self }
204}
205impl ::std::default::Default for Struct_Unnamed9 {
206 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
207}
208pub type __fsid_t = Struct_Unnamed9;
209pub type __clock_t = c_long;
210pub type __rlim_t = c_ulong;
211pub type __rlim64_t = c_ulong;
212pub type __id_t = c_uint;
213pub type __time_t = c_long;
214pub type __useconds_t = c_uint;
215pub type __suseconds_t = c_long;
216pub type __daddr_t = c_int;
217pub type __key_t = c_int;
218pub type __clockid_t = c_int;
219pub type __timer_t = *mut c_void;
220pub type __blksize_t = c_long;
221pub type __blkcnt_t = c_long;
222pub type __blkcnt64_t = c_long;
223pub type __fsblkcnt_t = c_ulong;
224pub type __fsblkcnt64_t = c_ulong;
225pub type __fsfilcnt_t = c_ulong;
226pub type __fsfilcnt64_t = c_ulong;
227pub type __fsword_t = c_long;
228pub type __ssize_t = c_long;
229pub type __syscall_slong_t = c_long;
230pub type __syscall_ulong_t = c_ulong;
231pub type __loff_t = __off64_t;
232pub type __qaddr_t = *mut __quad_t;
233pub type __caddr_t = *mut c_char;
234pub type __intptr_t = c_long;
235pub type __socklen_t = c_uint;
236pub type time_t = __time_t;
237#[repr(C)]
238#[derive(Copy)]
239pub struct Struct_timeval {
240 pub tv_sec: __time_t,
241 pub tv_usec: __suseconds_t,
242}
243impl ::std::clone::Clone for Struct_timeval {
244 fn clone(&self) -> Self { *self }
245}
246impl ::std::default::Default for Struct_timeval {
247 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
248}
249pub type __sig_atomic_t = c_int;
250#[repr(C)]
251#[derive(Copy)]
252pub struct Struct_Unnamed10 {
253 pub __val: [c_ulong; 16usize],
254}
255impl ::std::clone::Clone for Struct_Unnamed10 {
256 fn clone(&self) -> Self { *self }
257}
258impl ::std::default::Default for Struct_Unnamed10 {
259 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
260}
261pub type __sigset_t = Struct_Unnamed10;
262pub type sigset_t = __sigset_t;
263#[repr(C)]
264#[derive(Copy)]
265pub struct Struct_timespec {
266 pub tv_sec: __time_t,
267 pub tv_nsec: __syscall_slong_t,
268}
269impl ::std::clone::Clone for Struct_timespec {
270 fn clone(&self) -> Self { *self }
271}
272impl ::std::default::Default for Struct_timespec {
273 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
274}
275pub type suseconds_t = __suseconds_t;
276pub type __fd_mask = c_long;
277#[repr(C)]
278#[derive(Copy)]
279pub struct Struct_Unnamed11 {
280 pub __fds_bits: [__fd_mask; 16usize],
281}
282impl ::std::clone::Clone for Struct_Unnamed11 {
283 fn clone(&self) -> Self { *self }
284}
285impl ::std::default::Default for Struct_Unnamed11 {
286 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
287}
288pub type fd_set = Struct_Unnamed11;
289pub type fd_mask = __fd_mask;
290#[repr(C)]
291#[derive(Copy)]
292pub struct Struct_timezone {
293 pub tz_minuteswest: c_int,
294 pub tz_dsttime: c_int,
295}
296impl ::std::clone::Clone for Struct_timezone {
297 fn clone(&self) -> Self { *self }
298}
299impl ::std::default::Default for Struct_timezone {
300 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
301}
302pub type __timezone_ptr_t = *mut Struct_timezone;
303#[derive(Clone, Copy)]
304#[repr(u32)]
305pub enum Enum___itimer_which {
306 ITIMER_REAL = 0,
307 ITIMER_VIRTUAL = 1,
308 ITIMER_PROF = 2,
309}
310#[repr(C)]
311#[derive(Copy)]
312pub struct Struct_itimerval {
313 pub it_interval: Struct_timeval,
314 pub it_value: Struct_timeval,
315}
316impl ::std::clone::Clone for Struct_itimerval {
317 fn clone(&self) -> Self { *self }
318}
319impl ::std::default::Default for Struct_itimerval {
320 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
321}
322pub type __itimer_which_t = c_int;
323pub type clock_t = __clock_t;
324pub type clockid_t = __clockid_t;
325pub type timer_t = __timer_t;
326#[repr(C)]
327#[derive(Copy)]
328pub struct Struct_tm {
329 pub tm_sec: c_int,
330 pub tm_min: c_int,
331 pub tm_hour: c_int,
332 pub tm_mday: c_int,
333 pub tm_mon: c_int,
334 pub tm_year: c_int,
335 pub tm_wday: c_int,
336 pub tm_yday: c_int,
337 pub tm_isdst: c_int,
338 pub tm_gmtoff: c_long,
339 pub tm_zone: *const c_char,
340}
341impl ::std::clone::Clone for Struct_tm {
342 fn clone(&self) -> Self { *self }
343}
344impl ::std::default::Default for Struct_tm {
345 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
346}
347#[repr(C)]
348#[derive(Copy)]
349pub struct Struct_itimerspec {
350 pub it_interval: Struct_timespec,
351 pub it_value: Struct_timespec,
352}
353impl ::std::clone::Clone for Struct_itimerspec {
354 fn clone(&self) -> Self { *self }
355}
356impl ::std::default::Default for Struct_itimerspec {
357 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
358}
359pub type pid_t = __pid_t;
360pub enum Struct___locale_data { }
361#[repr(C)]
362#[derive(Copy)]
363pub struct Struct___locale_struct {
364 pub __locales: [*mut Struct___locale_data; 13usize],
365 pub __ctype_b: *const c_ushort,
366 pub __ctype_tolower: *const c_int,
367 pub __ctype_toupper: *const c_int,
368 pub __names: [*const c_char; 13usize],
369}
370impl ::std::clone::Clone for Struct___locale_struct {
371 fn clone(&self) -> Self { *self }
372}
373impl ::std::default::Default for Struct___locale_struct {
374 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
375}
376pub type __locale_t = *mut Struct___locale_struct;
377pub type locale_t = __locale_t;
378#[repr(C)]
379#[derive(Copy)]
380pub struct Union_wait {
381 pub _bindgen_data_: [u32; 1usize],
382}
383impl Union_wait {
384 pub unsafe fn w_status(&mut self) -> *mut c_int {
385 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
386 ::std::mem::transmute(raw.offset(0))
387 }
388 pub unsafe fn __wait_terminated(&mut self) -> *mut Struct_Unnamed12 {
389 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
390 ::std::mem::transmute(raw.offset(0))
391 }
392 pub unsafe fn __wait_stopped(&mut self) -> *mut Struct_Unnamed13 {
393 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
394 ::std::mem::transmute(raw.offset(0))
395 }
396}
397impl ::std::clone::Clone for Union_wait {
398 fn clone(&self) -> Self { *self }
399}
400impl ::std::default::Default for Union_wait {
401 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
402}
403#[repr(C)]
404#[derive(Copy)]
405pub struct Struct_Unnamed12 {
406 pub _bindgen_bitfield_1_: c_uint,
407}
408impl ::std::clone::Clone for Struct_Unnamed12 {
409 fn clone(&self) -> Self { *self }
410}
411impl ::std::default::Default for Struct_Unnamed12 {
412 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
413}
414#[repr(C)]
415#[derive(Copy)]
416pub struct Struct_Unnamed13 {
417 pub _bindgen_bitfield_1_: c_uint,
418}
419impl ::std::clone::Clone for Struct_Unnamed13 {
420 fn clone(&self) -> Self { *self }
421}
422impl ::std::default::Default for Struct_Unnamed13 {
423 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
424}
425#[repr(C)]
426#[derive(Copy)]
427pub struct Union_Unnamed14 {
428 pub _bindgen_data_: [u64; 1usize],
429}
430impl Union_Unnamed14 {
431 pub unsafe fn __uptr(&mut self) -> *mut *mut Union_wait {
432 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
433 ::std::mem::transmute(raw.offset(0))
434 }
435 pub unsafe fn __iptr(&mut self) -> *mut *mut c_int {
436 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
437 ::std::mem::transmute(raw.offset(0))
438 }
439}
440impl ::std::clone::Clone for Union_Unnamed14 {
441 fn clone(&self) -> Self { *self }
442}
443impl ::std::default::Default for Union_Unnamed14 {
444 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
445}
446pub type __WAIT_STATUS = Union_Unnamed14;
447#[repr(C)]
448#[derive(Copy)]
449pub struct Struct_Unnamed15 {
450 pub quot: c_int,
451 pub rem: c_int,
452}
453impl ::std::clone::Clone for Struct_Unnamed15 {
454 fn clone(&self) -> Self { *self }
455}
456impl ::std::default::Default for Struct_Unnamed15 {
457 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
458}
459pub type div_t = Struct_Unnamed15;
460#[repr(C)]
461#[derive(Copy)]
462pub struct Struct_Unnamed16 {
463 pub quot: c_long,
464 pub rem: c_long,
465}
466impl ::std::clone::Clone for Struct_Unnamed16 {
467 fn clone(&self) -> Self { *self }
468}
469impl ::std::default::Default for Struct_Unnamed16 {
470 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
471}
472pub type ldiv_t = Struct_Unnamed16;
473#[repr(C)]
474#[derive(Copy)]
475pub struct Struct_Unnamed17 {
476 pub quot: c_longlong,
477 pub rem: c_longlong,
478}
479impl ::std::clone::Clone for Struct_Unnamed17 {
480 fn clone(&self) -> Self { *self }
481}
482impl ::std::default::Default for Struct_Unnamed17 {
483 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
484}
485pub type lldiv_t = Struct_Unnamed17;
486pub type u_char = __u_char;
487pub type u_short = __u_short;
488pub type u_int = __u_int;
489pub type u_long = __u_long;
490pub type quad_t = __quad_t;
491pub type u_quad_t = __u_quad_t;
492pub type fsid_t = __fsid_t;
493pub type loff_t = __loff_t;
494pub type ino_t = __ino_t;
495pub type dev_t = __dev_t;
496pub type gid_t = __gid_t;
497pub type mode_t = __mode_t;
498pub type nlink_t = __nlink_t;
499pub type uid_t = __uid_t;
500pub type off_t = __off_t;
501pub type id_t = __id_t;
502pub type ssize_t = __ssize_t;
503pub type daddr_t = __daddr_t;
504pub type caddr_t = __caddr_t;
505pub type key_t = __key_t;
506pub type ulong = c_ulong;
507pub type ushort = c_ushort;
508pub type _uint = c_uint;
509pub type u_int8_t = c_uchar;
510pub type u_int16_t = c_ushort;
511pub type u_int32_t = c_uint;
512pub type u_int64_t = c_ulong;
513pub type register_t = c_long;
514pub type blksize_t = __blksize_t;
515pub type blkcnt_t = __blkcnt_t;
516pub type fsblkcnt_t = __fsblkcnt_t;
517pub type fsfilcnt_t = __fsfilcnt_t;
518pub type pthread_t = c_ulong;
519#[repr(C)]
520#[derive(Copy)]
521pub struct Union_pthread_attr_t {
522 pub _bindgen_data_: [u64; 7usize],
523}
524impl Union_pthread_attr_t {
525 pub unsafe fn __size(&mut self)
526 -> *mut [c_char; 56usize] {
527 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
528 ::std::mem::transmute(raw.offset(0))
529 }
530 pub unsafe fn __align(&mut self) -> *mut c_long {
531 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
532 ::std::mem::transmute(raw.offset(0))
533 }
534}
535impl ::std::clone::Clone for Union_pthread_attr_t {
536 fn clone(&self) -> Self { *self }
537}
538impl ::std::default::Default for Union_pthread_attr_t {
539 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
540}
541pub type pthread_attr_t = Union_pthread_attr_t;
542#[repr(C)]
543#[derive(Copy)]
544pub struct Struct___pthread_internal_list {
545 pub __prev: *mut Struct___pthread_internal_list,
546 pub __next: *mut Struct___pthread_internal_list,
547}
548impl ::std::clone::Clone for Struct___pthread_internal_list {
549 fn clone(&self) -> Self { *self }
550}
551impl ::std::default::Default for Struct___pthread_internal_list {
552 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
553}
554pub type __pthread_list_t = Struct___pthread_internal_list;
555#[repr(C)]
556#[derive(Copy)]
557pub struct Union_Unnamed18 {
558 pub _bindgen_data_: [u64; 5usize],
559}
560impl Union_Unnamed18 {
561 pub unsafe fn __data(&mut self) -> *mut Struct___pthread_mutex_s {
562 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
563 ::std::mem::transmute(raw.offset(0))
564 }
565 pub unsafe fn __size(&mut self)
566 -> *mut [c_char; 40usize] {
567 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
568 ::std::mem::transmute(raw.offset(0))
569 }
570 pub unsafe fn __align(&mut self) -> *mut c_long {
571 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
572 ::std::mem::transmute(raw.offset(0))
573 }
574}
575impl ::std::clone::Clone for Union_Unnamed18 {
576 fn clone(&self) -> Self { *self }
577}
578impl ::std::default::Default for Union_Unnamed18 {
579 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
580}
581#[repr(C)]
582#[derive(Copy)]
583pub struct Struct___pthread_mutex_s {
584 pub __lock: c_int,
585 pub __count: c_uint,
586 pub __owner: c_int,
587 pub __nusers: c_uint,
588 pub __kind: c_int,
589 pub __spins: c_short,
590 pub __elision: c_short,
591 pub __list: __pthread_list_t,
592}
593impl ::std::clone::Clone for Struct___pthread_mutex_s {
594 fn clone(&self) -> Self { *self }
595}
596impl ::std::default::Default for Struct___pthread_mutex_s {
597 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
598}
599pub type pthread_mutex_t = Union_Unnamed18;
600#[repr(C)]
601#[derive(Copy)]
602pub struct Union_Unnamed19 {
603 pub _bindgen_data_: [u32; 1usize],
604}
605impl Union_Unnamed19 {
606 pub unsafe fn __size(&mut self) -> *mut [c_char; 4usize] {
607 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
608 ::std::mem::transmute(raw.offset(0))
609 }
610 pub unsafe fn __align(&mut self) -> *mut c_int {
611 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
612 ::std::mem::transmute(raw.offset(0))
613 }
614}
615impl ::std::clone::Clone for Union_Unnamed19 {
616 fn clone(&self) -> Self { *self }
617}
618impl ::std::default::Default for Union_Unnamed19 {
619 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
620}
621pub type pthread_mutexattr_t = Union_Unnamed19;
622#[repr(C)]
623#[derive(Copy)]
624pub struct Union_Unnamed20 {
625 pub _bindgen_data_: [u64; 6usize],
626}
627impl Union_Unnamed20 {
628 pub unsafe fn __data(&mut self) -> *mut Struct_Unnamed21 {
629 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
630 ::std::mem::transmute(raw.offset(0))
631 }
632 pub unsafe fn __size(&mut self)
633 -> *mut [c_char; 48usize] {
634 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
635 ::std::mem::transmute(raw.offset(0))
636 }
637 pub unsafe fn __align(&mut self) -> *mut c_longlong {
638 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
639 ::std::mem::transmute(raw.offset(0))
640 }
641}
642impl ::std::clone::Clone for Union_Unnamed20 {
643 fn clone(&self) -> Self { *self }
644}
645impl ::std::default::Default for Union_Unnamed20 {
646 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
647}
648#[repr(C)]
649#[derive(Copy)]
650pub struct Struct_Unnamed21 {
651 pub __lock: c_int,
652 pub __futex: c_uint,
653 pub __total_seq: c_ulonglong,
654 pub __wakeup_seq: c_ulonglong,
655 pub __woken_seq: c_ulonglong,
656 pub __mutex: *mut c_void,
657 pub __nwaiters: c_uint,
658 pub __broadcast_seq: c_uint,
659}
660impl ::std::clone::Clone for Struct_Unnamed21 {
661 fn clone(&self) -> Self { *self }
662}
663impl ::std::default::Default for Struct_Unnamed21 {
664 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
665}
666pub type pthread_cond_t = Union_Unnamed20;
667#[repr(C)]
668#[derive(Copy)]
669pub struct Union_Unnamed22 {
670 pub _bindgen_data_: [u32; 1usize],
671}
672impl Union_Unnamed22 {
673 pub unsafe fn __size(&mut self) -> *mut [c_char; 4usize] {
674 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
675 ::std::mem::transmute(raw.offset(0))
676 }
677 pub unsafe fn __align(&mut self) -> *mut c_int {
678 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
679 ::std::mem::transmute(raw.offset(0))
680 }
681}
682impl ::std::clone::Clone for Union_Unnamed22 {
683 fn clone(&self) -> Self { *self }
684}
685impl ::std::default::Default for Union_Unnamed22 {
686 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
687}
688pub type pthread_condattr_t = Union_Unnamed22;
689pub type pthread_key_t = c_uint;
690pub type pthread_once_t = c_int;
691#[repr(C)]
692#[derive(Copy)]
693pub struct Union_Unnamed23 {
694 pub _bindgen_data_: [u64; 7usize],
695}
696impl Union_Unnamed23 {
697 pub unsafe fn __data(&mut self) -> *mut Struct_Unnamed24 {
698 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
699 ::std::mem::transmute(raw.offset(0))
700 }
701 pub unsafe fn __size(&mut self)
702 -> *mut [c_char; 56usize] {
703 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
704 ::std::mem::transmute(raw.offset(0))
705 }
706 pub unsafe fn __align(&mut self) -> *mut c_long {
707 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
708 ::std::mem::transmute(raw.offset(0))
709 }
710}
711impl ::std::clone::Clone for Union_Unnamed23 {
712 fn clone(&self) -> Self { *self }
713}
714impl ::std::default::Default for Union_Unnamed23 {
715 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
716}
717#[repr(C)]
718#[derive(Copy)]
719pub struct Struct_Unnamed24 {
720 pub __lock: c_int,
721 pub __nr_readers: c_uint,
722 pub __readers_wakeup: c_uint,
723 pub __writer_wakeup: c_uint,
724 pub __nr_readers_queued: c_uint,
725 pub __nr_writers_queued: c_uint,
726 pub __writer: c_int,
727 pub __shared: c_int,
728 pub __rwelision: c_char,
729 pub __pad1: [c_uchar; 7usize],
730 pub __pad2: c_ulong,
731 pub __flags: c_uint,
732}
733impl ::std::clone::Clone for Struct_Unnamed24 {
734 fn clone(&self) -> Self { *self }
735}
736impl ::std::default::Default for Struct_Unnamed24 {
737 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
738}
739pub type pthread_rwlock_t = Union_Unnamed23;
740#[repr(C)]
741#[derive(Copy)]
742pub struct Union_Unnamed25 {
743 pub _bindgen_data_: [u64; 1usize],
744}
745impl Union_Unnamed25 {
746 pub unsafe fn __size(&mut self) -> *mut [c_char; 8usize] {
747 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
748 ::std::mem::transmute(raw.offset(0))
749 }
750 pub unsafe fn __align(&mut self) -> *mut c_long {
751 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
752 ::std::mem::transmute(raw.offset(0))
753 }
754}
755impl ::std::clone::Clone for Union_Unnamed25 {
756 fn clone(&self) -> Self { *self }
757}
758impl ::std::default::Default for Union_Unnamed25 {
759 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
760}
761pub type pthread_rwlockattr_t = Union_Unnamed25;
762pub type pthread_spinlock_t = c_int;
763#[repr(C)]
764#[derive(Copy)]
765pub struct Union_Unnamed26 {
766 pub _bindgen_data_: [u64; 4usize],
767}
768impl Union_Unnamed26 {
769 pub unsafe fn __size(&mut self)
770 -> *mut [c_char; 32usize] {
771 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
772 ::std::mem::transmute(raw.offset(0))
773 }
774 pub unsafe fn __align(&mut self) -> *mut c_long {
775 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
776 ::std::mem::transmute(raw.offset(0))
777 }
778}
779impl ::std::clone::Clone for Union_Unnamed26 {
780 fn clone(&self) -> Self { *self }
781}
782impl ::std::default::Default for Union_Unnamed26 {
783 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
784}
785pub type pthread_barrier_t = Union_Unnamed26;
786#[repr(C)]
787#[derive(Copy)]
788pub struct Union_Unnamed27 {
789 pub _bindgen_data_: [u32; 1usize],
790}
791impl Union_Unnamed27 {
792 pub unsafe fn __size(&mut self) -> *mut [c_char; 4usize] {
793 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
794 ::std::mem::transmute(raw.offset(0))
795 }
796 pub unsafe fn __align(&mut self) -> *mut c_int {
797 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
798 ::std::mem::transmute(raw.offset(0))
799 }
800}
801impl ::std::clone::Clone for Union_Unnamed27 {
802 fn clone(&self) -> Self { *self }
803}
804impl ::std::default::Default for Union_Unnamed27 {
805 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
806}
807pub type pthread_barrierattr_t = Union_Unnamed27;
808#[repr(C)]
809#[derive(Copy)]
810pub struct Struct_random_data {
811 pub fptr: *mut int32_t,
812 pub rptr: *mut int32_t,
813 pub state: *mut int32_t,
814 pub rand_type: c_int,
815 pub rand_deg: c_int,
816 pub rand_sep: c_int,
817 pub end_ptr: *mut int32_t,
818}
819impl ::std::clone::Clone for Struct_random_data {
820 fn clone(&self) -> Self { *self }
821}
822impl ::std::default::Default for Struct_random_data {
823 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
824}
825#[repr(C)]
826#[derive(Copy)]
827pub struct Struct_drand48_data {
828 pub __x: [c_ushort; 3usize],
829 pub __old_x: [c_ushort; 3usize],
830 pub __c: c_ushort,
831 pub __init: c_ushort,
832 pub __a: c_ulonglong,
833}
834impl ::std::clone::Clone for Struct_drand48_data {
835 fn clone(&self) -> Self { *self }
836}
837impl ::std::default::Default for Struct_drand48_data {
838 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
839}
840pub type __compar_fn_t =
841 ::std::option::Option<unsafe extern "C" fn(arg1:
842 *const c_void,
843 arg2:
844 *const c_void)
845 -> c_int>;
846pub type scm_t_int8 = int8_t;
847pub type scm_t_uint8 = uint8_t;
848pub type scm_t_int16 = int16_t;
849pub type scm_t_uint16 = uint16_t;
850pub type scm_t_int32 = int32_t;
851pub type scm_t_uint32 = uint32_t;
852pub type scm_t_intmax = intmax_t;
853pub type scm_t_uintmax = uintmax_t;
854pub type scm_t_intptr = intptr_t;
855pub type scm_t_uintptr = uintptr_t;
856pub type scm_t_int64 = int64_t;
857pub type scm_t_uint64 = uint64_t;
858pub type scm_t_ptrdiff = ptrdiff_t;
859pub type scm_t_timespec = Struct_timespec;
860pub type scm_t_off = scm_t_int64;
861pub type scm_t_signed_bits = scm_t_intptr;
862pub type scm_t_bits = scm_t_uintptr;
863#[repr(C)]
864#[derive(Copy)]
865pub struct Struct_scm_unused_struct {
866 pub scm_unused_field: c_char,
867}
868impl ::std::clone::Clone for Struct_scm_unused_struct {
869 fn clone(&self) -> Self { *self }
870}
871impl ::std::default::Default for Struct_scm_unused_struct {
872 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
873}
874pub type SCM = *mut Struct_scm_unused_struct;
875#[derive(Clone, Copy)]
876#[repr(u32)]
877pub enum Enum_scm_tc8_tags {
878 scm_tc8_flag = 4,
879 scm_tc8_char = 12,
880 scm_tc8_unused_0 = 20,
881 scm_tc8_unused_1 = 28,
882}
883pub type scm_t_subr = *mut c_void;
884pub type __jmp_buf = [c_long; 8usize];
885#[repr(C)]
886#[derive(Copy)]
887pub struct Struct___jmp_buf_tag {
888 pub __jmpbuf: __jmp_buf,
889 pub __mask_was_saved: c_int,
890 pub __saved_mask: __sigset_t,
891}
892impl ::std::clone::Clone for Struct___jmp_buf_tag {
893 fn clone(&self) -> Self { *self }
894}
895impl ::std::default::Default for Struct___jmp_buf_tag {
896 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
897}
898pub type jmp_buf = [Struct___jmp_buf_tag; 1usize];
899pub type sigjmp_buf = [Struct___jmp_buf_tag; 1usize];
900pub type SCM_STACKITEM = c_long;
901pub type scm_t_wchar = scm_t_int32;
902#[repr(C)]
903#[derive(Copy)]
904pub struct Struct_scm_t_option {
905 pub _type: c_uint,
906 pub name: *const c_char,
907 pub val: scm_t_bits,
908 pub doc: *mut c_char,
909}
910impl ::std::clone::Clone for Struct_scm_t_option {
911 fn clone(&self) -> Self { *self }
912}
913impl ::std::default::Default for Struct_scm_t_option {
914 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
915}
916pub type scm_t_option = Struct_scm_t_option;
917#[repr(C)]
918#[derive(Copy)]
919pub struct Struct_scm_print_state {
920 pub handle: SCM,
921 pub revealed: c_int,
922 pub writingp: c_ulong,
923 pub fancyp: c_ulong,
924 pub level: c_ulong,
925 pub length: c_ulong,
926 pub hot_ref: SCM,
927 pub list_offset: c_ulong,
928 pub top: c_ulong,
929 pub ceiling: c_ulong,
930 pub ref_vect: SCM,
931 pub highlight_objects: SCM,
932}
933impl ::std::clone::Clone for Struct_scm_print_state {
934 fn clone(&self) -> Self { *self }
935}
936impl ::std::default::Default for Struct_scm_print_state {
937 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
938}
939pub type scm_print_state = Struct_scm_print_state;
940#[repr(C)]
941#[derive(Copy)]
942pub struct Struct_scm_t_double {
943 pub _type: SCM,
944 pub pad: SCM,
945 pub real: c_double,
946}
947impl ::std::clone::Clone for Struct_scm_t_double {
948 fn clone(&self) -> Self { *self }
949}
950impl ::std::default::Default for Struct_scm_t_double {
951 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
952}
953pub type scm_t_double = Struct_scm_t_double;
954#[repr(C)]
955#[derive(Copy)]
956pub struct Struct_scm_t_complex {
957 pub _type: SCM,
958 pub pad: SCM,
959 pub real: c_double,
960 pub imag: c_double,
961}
962impl ::std::clone::Clone for Struct_scm_t_complex {
963 fn clone(&self) -> Self { *self }
964}
965impl ::std::default::Default for Struct_scm_t_complex {
966 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
967}
968pub type scm_t_complex = Struct_scm_t_complex;
969pub type scm_i_t_array_ref =
970 ::std::option::Option<unsafe extern "C" fn(arg1:
971 *mut Struct_scm_t_array_handle,
972 arg2: size_t) -> SCM>;
973pub type scm_i_t_array_set =
974 ::std::option::Option<unsafe extern "C" fn(arg1:
975 *mut Struct_scm_t_array_handle,
976 arg2: size_t, arg3: SCM)>;
977#[repr(C)]
978#[derive(Copy)]
979pub struct Struct_Unnamed28 {
980 pub tag: scm_t_bits,
981 pub mask: scm_t_bits,
982 pub vref: scm_i_t_array_ref,
983 pub vset: scm_i_t_array_set,
984 pub get_handle: ::std::option::Option<unsafe extern "C" fn(arg1: SCM,
985 arg2:
986 *mut Struct_scm_t_array_handle)>,
987}
988impl ::std::clone::Clone for Struct_Unnamed28 {
989 fn clone(&self) -> Self { *self }
990}
991impl ::std::default::Default for Struct_Unnamed28 {
992 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
993}
994pub type scm_t_array_implementation = Struct_Unnamed28;
995#[repr(C)]
996#[derive(Copy)]
997pub struct Struct_scm_t_array_dim {
998 pub lbnd: ssize_t,
999 pub ubnd: ssize_t,
1000 pub inc: ssize_t,
1001}
1002impl ::std::clone::Clone for Struct_scm_t_array_dim {
1003 fn clone(&self) -> Self { *self }
1004}
1005impl ::std::default::Default for Struct_scm_t_array_dim {
1006 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1007}
1008pub type scm_t_array_dim = Struct_scm_t_array_dim;
1009pub const SCM_ARRAY_ELEMENT_TYPE_LAST: Enum_Unnamed29 =
1010 Enum_Unnamed29::SCM_ARRAY_ELEMENT_TYPE_C64;
1011#[derive(Clone, Copy)]
1012#[repr(u32)]
1013pub enum Enum_Unnamed29 {
1014 SCM_ARRAY_ELEMENT_TYPE_SCM = 0,
1015 SCM_ARRAY_ELEMENT_TYPE_CHAR = 1,
1016 SCM_ARRAY_ELEMENT_TYPE_BIT = 2,
1017 SCM_ARRAY_ELEMENT_TYPE_VU8 = 3,
1018 SCM_ARRAY_ELEMENT_TYPE_U8 = 4,
1019 SCM_ARRAY_ELEMENT_TYPE_S8 = 5,
1020 SCM_ARRAY_ELEMENT_TYPE_U16 = 6,
1021 SCM_ARRAY_ELEMENT_TYPE_S16 = 7,
1022 SCM_ARRAY_ELEMENT_TYPE_U32 = 8,
1023 SCM_ARRAY_ELEMENT_TYPE_S32 = 9,
1024 SCM_ARRAY_ELEMENT_TYPE_U64 = 10,
1025 SCM_ARRAY_ELEMENT_TYPE_S64 = 11,
1026 SCM_ARRAY_ELEMENT_TYPE_F32 = 12,
1027 SCM_ARRAY_ELEMENT_TYPE_F64 = 13,
1028 SCM_ARRAY_ELEMENT_TYPE_C32 = 14,
1029 SCM_ARRAY_ELEMENT_TYPE_C64 = 15,
1030}
1031pub type scm_t_array_element_type = Enum_Unnamed29;
1032#[repr(C)]
1033#[derive(Copy)]
1034pub struct Struct_scm_t_array_handle {
1035 pub array: SCM,
1036 pub _impl: *mut scm_t_array_implementation,
1037 pub base: size_t,
1038 pub ndims: size_t,
1039 pub dims: *mut scm_t_array_dim,
1040 pub dim0: scm_t_array_dim,
1041 pub element_type: scm_t_array_element_type,
1042 pub elements: *const c_void,
1043 pub writable_elements: *mut c_void,
1044}
1045impl ::std::clone::Clone for Struct_scm_t_array_handle {
1046 fn clone(&self) -> Self { *self }
1047}
1048impl ::std::default::Default for Struct_scm_t_array_handle {
1049 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1050}
1051pub type scm_t_array_handle = Struct_scm_t_array_handle;
1052#[repr(C)]
1053#[derive(Copy)]
1054pub struct Struct_scm_i_t_array {
1055 pub v: SCM,
1056 pub base: c_ulong,
1057}
1058impl ::std::clone::Clone for Struct_scm_i_t_array {
1059 fn clone(&self) -> Self { *self }
1060}
1061impl ::std::default::Default for Struct_scm_i_t_array {
1062 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1063}
1064pub type scm_i_t_array = Struct_scm_i_t_array;
1065#[repr(C)]
1066#[derive(Copy)]
1067pub struct Union_scm_t_debug_info {
1068 pub _bindgen_data_: [u64; 2usize],
1069}
1070impl Union_scm_t_debug_info {
1071 pub unsafe fn e(&mut self) -> *mut Struct_Unnamed30 {
1072 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1073 ::std::mem::transmute(raw.offset(0))
1074 }
1075 pub unsafe fn a(&mut self) -> *mut Struct_Unnamed31 {
1076 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1077 ::std::mem::transmute(raw.offset(0))
1078 }
1079 pub unsafe fn id(&mut self) -> *mut SCM {
1080 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1081 ::std::mem::transmute(raw.offset(0))
1082 }
1083}
1084impl ::std::clone::Clone for Union_scm_t_debug_info {
1085 fn clone(&self) -> Self { *self }
1086}
1087impl ::std::default::Default for Union_scm_t_debug_info {
1088 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1089}
1090#[repr(C)]
1091#[derive(Copy)]
1092pub struct Struct_Unnamed30 {
1093 pub exp: SCM,
1094 pub env: SCM,
1095}
1096impl ::std::clone::Clone for Struct_Unnamed30 {
1097 fn clone(&self) -> Self { *self }
1098}
1099impl ::std::default::Default for Struct_Unnamed30 {
1100 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1101}
1102#[repr(C)]
1103#[derive(Copy)]
1104pub struct Struct_Unnamed31 {
1105 pub _proc: SCM,
1106 pub args: SCM,
1107}
1108impl ::std::clone::Clone for Struct_Unnamed31 {
1109 fn clone(&self) -> Self { *self }
1110}
1111impl ::std::default::Default for Struct_Unnamed31 {
1112 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1113}
1114pub type scm_t_debug_info = Union_scm_t_debug_info;
1115pub type scm_t_catch_body =
1116 ::std::option::Option<unsafe extern "C" fn(data:
1117 *mut c_void)
1118 -> SCM>;
1119pub type scm_t_catch_handler =
1120 ::std::option::Option<unsafe extern "C" fn(data:
1121 *mut c_void,
1122 tag: SCM, throw_args: SCM)
1123 -> SCM>;
1124#[repr(C)]
1125#[derive(Copy)]
1126pub struct Struct_scm_body_thunk_data {
1127 pub tag: SCM,
1128 pub body_proc: SCM,
1129}
1130impl ::std::clone::Clone for Struct_scm_body_thunk_data {
1131 fn clone(&self) -> Self { *self }
1132}
1133impl ::std::default::Default for Struct_scm_body_thunk_data {
1134 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1135}
1136pub type scm_t_guard =
1137 ::std::option::Option<unsafe extern "C" fn(arg1:
1138 *mut c_void)>;
1139#[derive(Clone, Copy)]
1140#[repr(u32)]
1141pub enum Enum_Unnamed32 { SCM_F_DYNWIND_REWINDABLE = 1, }
1142pub type scm_t_dynwind_flags = Enum_Unnamed32;
1143#[derive(Clone, Copy)]
1144#[repr(u32)]
1145pub enum Enum_Unnamed33 { SCM_F_WIND_EXPLICITLY = 1, }
1146pub type scm_t_wind_flags = Enum_Unnamed33;
1147#[repr(C)]
1148#[derive(Copy)]
1149pub struct Struct_Unnamed34 {
1150 pub jmpbuf: jmp_buf,
1151 pub dynenv: SCM,
1152 pub num_stack_items: size_t,
1153 pub root: SCM,
1154 pub vm: SCM,
1155 pub vm_cont: SCM,
1156 pub offset: scm_t_ptrdiff,
1157 pub stack: [SCM_STACKITEM; 1usize],
1158}
1159impl ::std::clone::Clone for Struct_Unnamed34 {
1160 fn clone(&self) -> Self { *self }
1161}
1162impl ::std::default::Default for Struct_Unnamed34 {
1163 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1164}
1165pub type scm_t_contregs = Struct_Unnamed34;
1166#[repr(C)]
1167#[derive(Copy)]
1168pub struct Struct_sched_param {
1169 pub __sched_priority: c_int,
1170}
1171impl ::std::clone::Clone for Struct_sched_param {
1172 fn clone(&self) -> Self { *self }
1173}
1174impl ::std::default::Default for Struct_sched_param {
1175 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1176}
1177#[repr(C)]
1178#[derive(Copy)]
1179pub struct Struct___sched_param {
1180 pub __sched_priority: c_int,
1181}
1182impl ::std::clone::Clone for Struct___sched_param {
1183 fn clone(&self) -> Self { *self }
1184}
1185impl ::std::default::Default for Struct___sched_param {
1186 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1187}
1188pub type __cpu_mask = c_ulong;
1189#[repr(C)]
1190#[derive(Copy)]
1191pub struct Struct_Unnamed35 {
1192 pub __bits: [__cpu_mask; 16usize],
1193}
1194impl ::std::clone::Clone for Struct_Unnamed35 {
1195 fn clone(&self) -> Self { *self }
1196}
1197impl ::std::default::Default for Struct_Unnamed35 {
1198 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1199}
1200pub type cpu_set_t = Struct_Unnamed35;
1201#[derive(Clone, Copy)]
1202#[repr(u32)]
1203pub enum Enum_Unnamed36 {
1204 PTHREAD_CREATE_JOINABLE = 0,
1205 PTHREAD_CREATE_DETACHED = 1,
1206}
1207pub const PTHREAD_MUTEX_NORMAL: Enum_Unnamed37 =
1208 Enum_Unnamed37::PTHREAD_MUTEX_TIMED_NP;
1209pub const PTHREAD_MUTEX_RECURSIVE: Enum_Unnamed37 =
1210 Enum_Unnamed37::PTHREAD_MUTEX_RECURSIVE_NP;
1211pub const PTHREAD_MUTEX_ERRORCHECK: Enum_Unnamed37 =
1212 Enum_Unnamed37::PTHREAD_MUTEX_ERRORCHECK_NP;
1213pub const PTHREAD_MUTEX_DEFAULT: Enum_Unnamed37 =
1214 Enum_Unnamed37::PTHREAD_MUTEX_TIMED_NP;
1215#[derive(Clone, Copy)]
1216#[repr(u32)]
1217pub enum Enum_Unnamed37 {
1218 PTHREAD_MUTEX_TIMED_NP = 0,
1219 PTHREAD_MUTEX_RECURSIVE_NP = 1,
1220 PTHREAD_MUTEX_ERRORCHECK_NP = 2,
1221 PTHREAD_MUTEX_ADAPTIVE_NP = 3,
1222}
1223pub const PTHREAD_MUTEX_STALLED_NP: Enum_Unnamed38 =
1224 Enum_Unnamed38::PTHREAD_MUTEX_STALLED;
1225pub const PTHREAD_MUTEX_ROBUST_NP: Enum_Unnamed38 =
1226 Enum_Unnamed38::PTHREAD_MUTEX_ROBUST;
1227#[derive(Clone, Copy)]
1228#[repr(u32)]
1229pub enum Enum_Unnamed38 {
1230 PTHREAD_MUTEX_STALLED = 0,
1231 PTHREAD_MUTEX_ROBUST = 1,
1232}
1233#[derive(Clone, Copy)]
1234#[repr(u32)]
1235pub enum Enum_Unnamed39 {
1236 PTHREAD_PRIO_NONE = 0,
1237 PTHREAD_PRIO_INHERIT = 1,
1238 PTHREAD_PRIO_PROTECT = 2,
1239}
1240pub const PTHREAD_RWLOCK_DEFAULT_NP: Enum_Unnamed40 =
1241 Enum_Unnamed40::PTHREAD_RWLOCK_PREFER_READER_NP;
1242#[derive(Clone, Copy)]
1243#[repr(u32)]
1244pub enum Enum_Unnamed40 {
1245 PTHREAD_RWLOCK_PREFER_READER_NP = 0,
1246 PTHREAD_RWLOCK_PREFER_WRITER_NP = 1,
1247 PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP = 2,
1248}
1249#[derive(Clone, Copy)]
1250#[repr(u32)]
1251pub enum Enum_Unnamed41 {
1252 PTHREAD_INHERIT_SCHED = 0,
1253 PTHREAD_EXPLICIT_SCHED = 1,
1254}
1255#[derive(Clone, Copy)]
1256#[repr(u32)]
1257pub enum Enum_Unnamed42 {
1258 PTHREAD_SCOPE_SYSTEM = 0,
1259 PTHREAD_SCOPE_PROCESS = 1,
1260}
1261#[derive(Clone, Copy)]
1262#[repr(u32)]
1263pub enum Enum_Unnamed43 {
1264 PTHREAD_PROCESS_PRIVATE = 0,
1265 PTHREAD_PROCESS_SHARED = 1,
1266}
1267#[repr(C)]
1268#[derive(Copy)]
1269pub struct Struct__pthread_cleanup_buffer {
1270 pub __routine: ::std::option::Option<unsafe extern "C" fn(arg1:
1271 *mut c_void)>,
1272 pub __arg: *mut c_void,
1273 pub __canceltype: c_int,
1274 pub __prev: *mut Struct__pthread_cleanup_buffer,
1275}
1276impl ::std::clone::Clone for Struct__pthread_cleanup_buffer {
1277 fn clone(&self) -> Self { *self }
1278}
1279impl ::std::default::Default for Struct__pthread_cleanup_buffer {
1280 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1281}
1282#[derive(Clone, Copy)]
1283#[repr(u32)]
1284pub enum Enum_Unnamed44 {
1285 PTHREAD_CANCEL_ENABLE = 0,
1286 PTHREAD_CANCEL_DISABLE = 1,
1287}
1288#[derive(Clone, Copy)]
1289#[repr(u32)]
1290pub enum Enum_Unnamed45 {
1291 PTHREAD_CANCEL_DEFERRED = 0,
1292 PTHREAD_CANCEL_ASYNCHRONOUS = 1,
1293}
1294#[repr(C)]
1295#[derive(Copy)]
1296pub struct Struct_Unnamed46 {
1297 pub __cancel_jmp_buf: [Struct_Unnamed47; 1usize],
1298 pub __pad: [*mut c_void; 4usize],
1299}
1300impl ::std::clone::Clone for Struct_Unnamed46 {
1301 fn clone(&self) -> Self { *self }
1302}
1303impl ::std::default::Default for Struct_Unnamed46 {
1304 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1305}
1306#[repr(C)]
1307#[derive(Copy)]
1308pub struct Struct_Unnamed47 {
1309 pub __cancel_jmp_buf: __jmp_buf,
1310 pub __mask_was_saved: c_int,
1311}
1312impl ::std::clone::Clone for Struct_Unnamed47 {
1313 fn clone(&self) -> Self { *self }
1314}
1315impl ::std::default::Default for Struct_Unnamed47 {
1316 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1317}
1318pub type __pthread_unwind_buf_t = Struct_Unnamed46;
1319#[repr(C)]
1320#[derive(Copy)]
1321pub struct Struct___pthread_cleanup_frame {
1322 pub __cancel_routine: ::std::option::Option<unsafe extern "C" fn(arg1:
1323 *mut c_void)>,
1324 pub __cancel_arg: *mut c_void,
1325 pub __do_it: c_int,
1326 pub __cancel_type: c_int,
1327}
1328impl ::std::clone::Clone for Struct___pthread_cleanup_frame {
1329 fn clone(&self) -> Self { *self }
1330}
1331impl ::std::default::Default for Struct___pthread_cleanup_frame {
1332 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1333}
1334pub type GC_PTR = *mut c_void;
1335pub type GC_word = c_ulong;
1336pub type GC_signed_word = c_long;
1337pub type GC_oom_func =
1338 ::std::option::Option<extern "C" fn(arg1: size_t)
1339 -> *mut c_void>;
1340pub type GC_on_heap_resize_proc =
1341 ::std::option::Option<extern "C" fn(arg1: GC_word)>;
1342pub type GC_finalizer_notifier_proc = ::std::option::Option<extern "C" fn()>;
1343pub type GC_stop_func =
1344 ::std::option::Option<extern "C" fn() -> c_int>;
1345#[repr(C)]
1346#[derive(Copy)]
1347pub struct Struct_GC_prof_stats_s {
1348 pub heapsize_full: GC_word,
1349 pub free_bytes_full: GC_word,
1350 pub unmapped_bytes: GC_word,
1351 pub bytes_allocd_since_gc: GC_word,
1352 pub allocd_bytes_before_gc: GC_word,
1353 pub non_gc_bytes: GC_word,
1354 pub gc_no: GC_word,
1355 pub markers_m1: GC_word,
1356 pub bytes_reclaimed_since_gc: GC_word,
1357 pub reclaimed_bytes_before_gc: GC_word,
1358}
1359impl ::std::clone::Clone for Struct_GC_prof_stats_s {
1360 fn clone(&self) -> Self { *self }
1361}
1362impl ::std::default::Default for Struct_GC_prof_stats_s {
1363 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1364}
1365pub type GC_finalization_proc =
1366 ::std::option::Option<unsafe extern "C" fn(arg1:
1367 *mut c_void,
1368 arg2:
1369 *mut c_void)>;
1370pub type GC_warn_proc =
1371 ::std::option::Option<unsafe extern "C" fn(arg1:
1372 *mut c_char,
1373 arg2: GC_word)>;
1374pub type GC_abort_func =
1375 ::std::option::Option<unsafe extern "C" fn(arg1:
1376 *const c_char)>;
1377pub type GC_hidden_pointer = GC_word;
1378pub type GC_fn_type =
1379 ::std::option::Option<unsafe extern "C" fn(arg1:
1380 *mut c_void)
1381 -> *mut c_void>;
1382#[repr(C)]
1383#[derive(Copy)]
1384pub struct Struct_GC_stack_base {
1385 pub mem_base: *mut c_void,
1386}
1387impl ::std::clone::Clone for Struct_GC_stack_base {
1388 fn clone(&self) -> Self { *self }
1389}
1390impl ::std::default::Default for Struct_GC_stack_base {
1391 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1392}
1393pub type GC_stack_base_func =
1394 ::std::option::Option<unsafe extern "C" fn(arg1:
1395 *mut Struct_GC_stack_base,
1396 arg2:
1397 *mut c_void)
1398 -> *mut c_void>;
1399pub type sig_atomic_t = __sig_atomic_t;
1400#[repr(C)]
1401#[derive(Copy)]
1402pub struct Union_sigval {
1403 pub _bindgen_data_: [u64; 1usize],
1404}
1405impl Union_sigval {
1406 pub unsafe fn sival_int(&mut self) -> *mut c_int {
1407 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1408 ::std::mem::transmute(raw.offset(0))
1409 }
1410 pub unsafe fn sival_ptr(&mut self) -> *mut *mut c_void {
1411 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1412 ::std::mem::transmute(raw.offset(0))
1413 }
1414}
1415impl ::std::clone::Clone for Union_sigval {
1416 fn clone(&self) -> Self { *self }
1417}
1418impl ::std::default::Default for Union_sigval {
1419 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1420}
1421pub type sigval_t = Union_sigval;
1422pub type __sigchld_clock_t = __clock_t;
1423#[repr(C)]
1424#[derive(Copy)]
1425pub struct Struct_Unnamed48 {
1426 pub si_signo: c_int,
1427 pub si_errno: c_int,
1428 pub si_code: c_int,
1429 pub _sifields: Union_Unnamed49,
1430}
1431impl ::std::clone::Clone for Struct_Unnamed48 {
1432 fn clone(&self) -> Self { *self }
1433}
1434impl ::std::default::Default for Struct_Unnamed48 {
1435 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1436}
1437#[repr(C)]
1438#[derive(Copy)]
1439pub struct Union_Unnamed49 {
1440 pub _bindgen_data_: [u64; 14usize],
1441}
1442impl Union_Unnamed49 {
1443 pub unsafe fn _pad(&mut self) -> *mut [c_int; 28usize] {
1444 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1445 ::std::mem::transmute(raw.offset(0))
1446 }
1447 pub unsafe fn _kill(&mut self) -> *mut Struct_Unnamed50 {
1448 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1449 ::std::mem::transmute(raw.offset(0))
1450 }
1451 pub unsafe fn _timer(&mut self) -> *mut Struct_Unnamed51 {
1452 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1453 ::std::mem::transmute(raw.offset(0))
1454 }
1455 pub unsafe fn _rt(&mut self) -> *mut Struct_Unnamed52 {
1456 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1457 ::std::mem::transmute(raw.offset(0))
1458 }
1459 pub unsafe fn _sigchld(&mut self) -> *mut Struct_Unnamed53 {
1460 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1461 ::std::mem::transmute(raw.offset(0))
1462 }
1463 pub unsafe fn _sigfault(&mut self) -> *mut Struct_Unnamed54 {
1464 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1465 ::std::mem::transmute(raw.offset(0))
1466 }
1467 pub unsafe fn _sigpoll(&mut self) -> *mut Struct_Unnamed56 {
1468 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1469 ::std::mem::transmute(raw.offset(0))
1470 }
1471 pub unsafe fn _sigsys(&mut self) -> *mut Struct_Unnamed57 {
1472 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1473 ::std::mem::transmute(raw.offset(0))
1474 }
1475}
1476impl ::std::clone::Clone for Union_Unnamed49 {
1477 fn clone(&self) -> Self { *self }
1478}
1479impl ::std::default::Default for Union_Unnamed49 {
1480 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1481}
1482#[repr(C)]
1483#[derive(Copy)]
1484pub struct Struct_Unnamed50 {
1485 pub si_pid: __pid_t,
1486 pub si_uid: __uid_t,
1487}
1488impl ::std::clone::Clone for Struct_Unnamed50 {
1489 fn clone(&self) -> Self { *self }
1490}
1491impl ::std::default::Default for Struct_Unnamed50 {
1492 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1493}
1494#[repr(C)]
1495#[derive(Copy)]
1496pub struct Struct_Unnamed51 {
1497 pub si_tid: c_int,
1498 pub si_overrun: c_int,
1499 pub si_sigval: sigval_t,
1500}
1501impl ::std::clone::Clone for Struct_Unnamed51 {
1502 fn clone(&self) -> Self { *self }
1503}
1504impl ::std::default::Default for Struct_Unnamed51 {
1505 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1506}
1507#[repr(C)]
1508#[derive(Copy)]
1509pub struct Struct_Unnamed52 {
1510 pub si_pid: __pid_t,
1511 pub si_uid: __uid_t,
1512 pub si_sigval: sigval_t,
1513}
1514impl ::std::clone::Clone for Struct_Unnamed52 {
1515 fn clone(&self) -> Self { *self }
1516}
1517impl ::std::default::Default for Struct_Unnamed52 {
1518 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1519}
1520#[repr(C)]
1521#[derive(Copy)]
1522pub struct Struct_Unnamed53 {
1523 pub si_pid: __pid_t,
1524 pub si_uid: __uid_t,
1525 pub si_status: c_int,
1526 pub si_utime: __sigchld_clock_t,
1527 pub si_stime: __sigchld_clock_t,
1528}
1529impl ::std::clone::Clone for Struct_Unnamed53 {
1530 fn clone(&self) -> Self { *self }
1531}
1532impl ::std::default::Default for Struct_Unnamed53 {
1533 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1534}
1535#[repr(C)]
1536#[derive(Copy)]
1537pub struct Struct_Unnamed54 {
1538 pub si_addr: *mut c_void,
1539 pub si_addr_lsb: c_short,
1540 pub si_addr_bnd: Struct_Unnamed55,
1541}
1542impl ::std::clone::Clone for Struct_Unnamed54 {
1543 fn clone(&self) -> Self { *self }
1544}
1545impl ::std::default::Default for Struct_Unnamed54 {
1546 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1547}
1548#[repr(C)]
1549#[derive(Copy)]
1550pub struct Struct_Unnamed55 {
1551 pub _lower: *mut c_void,
1552 pub _upper: *mut c_void,
1553}
1554impl ::std::clone::Clone for Struct_Unnamed55 {
1555 fn clone(&self) -> Self { *self }
1556}
1557impl ::std::default::Default for Struct_Unnamed55 {
1558 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1559}
1560#[repr(C)]
1561#[derive(Copy)]
1562pub struct Struct_Unnamed56 {
1563 pub si_band: c_long,
1564 pub si_fd: c_int,
1565}
1566impl ::std::clone::Clone for Struct_Unnamed56 {
1567 fn clone(&self) -> Self { *self }
1568}
1569impl ::std::default::Default for Struct_Unnamed56 {
1570 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1571}
1572#[repr(C)]
1573#[derive(Copy)]
1574pub struct Struct_Unnamed57 {
1575 pub _call_addr: *mut c_void,
1576 pub _syscall: c_int,
1577 pub _arch: c_uint,
1578}
1579impl ::std::clone::Clone for Struct_Unnamed57 {
1580 fn clone(&self) -> Self { *self }
1581}
1582impl ::std::default::Default for Struct_Unnamed57 {
1583 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1584}
1585pub type siginfo_t = Struct_Unnamed48;
1586#[derive(Clone, Copy)]
1587#[repr(i32)]
1588pub enum Enum_Unnamed58 {
1589 SI_ASYNCNL = -60,
1590 SI_TKILL = -6,
1591 SI_SIGIO = -5,
1592 SI_ASYNCIO = -4,
1593 SI_MESGQ = -3,
1594 SI_TIMER = -2,
1595 SI_QUEUE = -1,
1596 SI_USER = 0,
1597 SI_KERNEL = 128,
1598}
1599#[derive(Clone, Copy)]
1600#[repr(u32)]
1601pub enum Enum_Unnamed59 {
1602 ILL_ILLOPC = 1,
1603 ILL_ILLOPN = 2,
1604 ILL_ILLADR = 3,
1605 ILL_ILLTRP = 4,
1606 ILL_PRVOPC = 5,
1607 ILL_PRVREG = 6,
1608 ILL_COPROC = 7,
1609 ILL_BADSTK = 8,
1610}
1611#[derive(Clone, Copy)]
1612#[repr(u32)]
1613pub enum Enum_Unnamed60 {
1614 FPE_INTDIV = 1,
1615 FPE_INTOVF = 2,
1616 FPE_FLTDIV = 3,
1617 FPE_FLTOVF = 4,
1618 FPE_FLTUND = 5,
1619 FPE_FLTRES = 6,
1620 FPE_FLTINV = 7,
1621 FPE_FLTSUB = 8,
1622}
1623#[derive(Clone, Copy)]
1624#[repr(u32)]
1625pub enum Enum_Unnamed61 { SEGV_MAPERR = 1, SEGV_ACCERR = 2, }
1626#[derive(Clone, Copy)]
1627#[repr(u32)]
1628pub enum Enum_Unnamed62 {
1629 BUS_ADRALN = 1,
1630 BUS_ADRERR = 2,
1631 BUS_OBJERR = 3,
1632 BUS_MCEERR_AR = 4,
1633 BUS_MCEERR_AO = 5,
1634}
1635#[derive(Clone, Copy)]
1636#[repr(u32)]
1637pub enum Enum_Unnamed63 {
1638 CLD_EXITED = 1,
1639 CLD_KILLED = 2,
1640 CLD_DUMPED = 3,
1641 CLD_TRAPPED = 4,
1642 CLD_STOPPED = 5,
1643 CLD_CONTINUED = 6,
1644}
1645#[derive(Clone, Copy)]
1646#[repr(u32)]
1647pub enum Enum_Unnamed64 {
1648 POLL_IN = 1,
1649 POLL_OUT = 2,
1650 POLL_MSG = 3,
1651 POLL_ERR = 4,
1652 POLL_PRI = 5,
1653 POLL_HUP = 6,
1654}
1655#[repr(C)]
1656#[derive(Copy)]
1657pub struct Struct_sigevent {
1658 pub sigev_value: sigval_t,
1659 pub sigev_signo: c_int,
1660 pub sigev_notify: c_int,
1661 pub _sigev_un: Union_Unnamed65,
1662}
1663impl ::std::clone::Clone for Struct_sigevent {
1664 fn clone(&self) -> Self { *self }
1665}
1666impl ::std::default::Default for Struct_sigevent {
1667 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1668}
1669#[repr(C)]
1670#[derive(Copy)]
1671pub struct Union_Unnamed65 {
1672 pub _bindgen_data_: [u64; 6usize],
1673}
1674impl Union_Unnamed65 {
1675 pub unsafe fn _pad(&mut self) -> *mut [c_int; 12usize] {
1676 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1677 ::std::mem::transmute(raw.offset(0))
1678 }
1679 pub unsafe fn _tid(&mut self) -> *mut __pid_t {
1680 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1681 ::std::mem::transmute(raw.offset(0))
1682 }
1683 pub unsafe fn _sigev_thread(&mut self) -> *mut Struct_Unnamed66 {
1684 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1685 ::std::mem::transmute(raw.offset(0))
1686 }
1687}
1688impl ::std::clone::Clone for Union_Unnamed65 {
1689 fn clone(&self) -> Self { *self }
1690}
1691impl ::std::default::Default for Union_Unnamed65 {
1692 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1693}
1694#[repr(C)]
1695#[derive(Copy)]
1696pub struct Struct_Unnamed66 {
1697 pub _function: ::std::option::Option<extern "C" fn(arg1: sigval_t)>,
1698 pub _attribute: *mut pthread_attr_t,
1699}
1700impl ::std::clone::Clone for Struct_Unnamed66 {
1701 fn clone(&self) -> Self { *self }
1702}
1703impl ::std::default::Default for Struct_Unnamed66 {
1704 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1705}
1706pub type sigevent_t = Struct_sigevent;
1707#[derive(Clone, Copy)]
1708#[repr(u32)]
1709pub enum Enum_Unnamed67 {
1710 SIGEV_SIGNAL = 0,
1711 SIGEV_NONE = 1,
1712 SIGEV_THREAD = 2,
1713 SIGEV_THREAD_ID = 4,
1714}
1715pub type __sighandler_t =
1716 ::std::option::Option<extern "C" fn(arg1: c_int)>;
1717pub type sig_t = __sighandler_t;
1718#[repr(C)]
1719#[derive(Copy)]
1720pub struct Struct_sigaction {
1721 pub __sigaction_handler: Union_Unnamed68,
1722 pub sa_mask: __sigset_t,
1723 pub sa_flags: c_int,
1724 pub sa_restorer: ::std::option::Option<extern "C" fn()>,
1725}
1726impl ::std::clone::Clone for Struct_sigaction {
1727 fn clone(&self) -> Self { *self }
1728}
1729impl ::std::default::Default for Struct_sigaction {
1730 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1731}
1732#[repr(C)]
1733#[derive(Copy)]
1734pub struct Union_Unnamed68 {
1735 pub _bindgen_data_: [u64; 1usize],
1736}
1737impl Union_Unnamed68 {
1738 pub unsafe fn sa_handler(&mut self) -> *mut __sighandler_t {
1739 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1740 ::std::mem::transmute(raw.offset(0))
1741 }
1742 pub unsafe fn sa_sigaction(&mut self)
1743 ->
1744 *mut ::std::option::Option<unsafe extern "C" fn(arg1:
1745 c_int,
1746 arg2: *mut siginfo_t,
1747 arg3:
1748 *mut c_void)> {
1749 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
1750 ::std::mem::transmute(raw.offset(0))
1751 }
1752}
1753impl ::std::clone::Clone for Union_Unnamed68 {
1754 fn clone(&self) -> Self { *self }
1755}
1756impl ::std::default::Default for Union_Unnamed68 {
1757 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1758}
1759#[repr(C)]
1760#[derive(Copy)]
1761pub struct Struct__fpx_sw_bytes {
1762 pub magic1: __uint32_t,
1763 pub extended_size: __uint32_t,
1764 pub xstate_bv: __uint64_t,
1765 pub xstate_size: __uint32_t,
1766 pub padding: [__uint32_t; 7usize],
1767}
1768impl ::std::clone::Clone for Struct__fpx_sw_bytes {
1769 fn clone(&self) -> Self { *self }
1770}
1771impl ::std::default::Default for Struct__fpx_sw_bytes {
1772 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1773}
1774#[repr(C)]
1775#[derive(Copy)]
1776pub struct Struct__fpreg {
1777 pub significand: [c_ushort; 4usize],
1778 pub exponent: c_ushort,
1779}
1780impl ::std::clone::Clone for Struct__fpreg {
1781 fn clone(&self) -> Self { *self }
1782}
1783impl ::std::default::Default for Struct__fpreg {
1784 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1785}
1786#[repr(C)]
1787#[derive(Copy)]
1788pub struct Struct__fpxreg {
1789 pub significand: [c_ushort; 4usize],
1790 pub exponent: c_ushort,
1791 pub padding: [c_ushort; 3usize],
1792}
1793impl ::std::clone::Clone for Struct__fpxreg {
1794 fn clone(&self) -> Self { *self }
1795}
1796impl ::std::default::Default for Struct__fpxreg {
1797 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1798}
1799#[repr(C)]
1800#[derive(Copy)]
1801pub struct Struct__xmmreg {
1802 pub element: [__uint32_t; 4usize],
1803}
1804impl ::std::clone::Clone for Struct__xmmreg {
1805 fn clone(&self) -> Self { *self }
1806}
1807impl ::std::default::Default for Struct__xmmreg {
1808 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1809}
1810#[repr(C)]
1811#[derive(Copy)]
1812pub struct Struct__fpstate {
1813 pub cwd: __uint16_t,
1814 pub swd: __uint16_t,
1815 pub ftw: __uint16_t,
1816 pub fop: __uint16_t,
1817 pub rip: __uint64_t,
1818 pub rdp: __uint64_t,
1819 pub mxcsr: __uint32_t,
1820 pub mxcr_mask: __uint32_t,
1821 pub _st: [Struct__fpxreg; 8usize],
1822 pub _xmm: [Struct__xmmreg; 16usize],
1823 pub padding: [__uint32_t; 24usize],
1824}
1825impl ::std::clone::Clone for Struct__fpstate {
1826 fn clone(&self) -> Self { *self }
1827}
1828impl ::std::default::Default for Struct__fpstate {
1829 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1830}
1831#[repr(C)]
1832#[derive(Copy)]
1833pub struct Struct_sigcontext {
1834 pub r8: __uint64_t,
1835 pub r9: __uint64_t,
1836 pub r10: __uint64_t,
1837 pub r11: __uint64_t,
1838 pub r12: __uint64_t,
1839 pub r13: __uint64_t,
1840 pub r14: __uint64_t,
1841 pub r15: __uint64_t,
1842 pub rdi: __uint64_t,
1843 pub rsi: __uint64_t,
1844 pub rbp: __uint64_t,
1845 pub rbx: __uint64_t,
1846 pub rdx: __uint64_t,
1847 pub rax: __uint64_t,
1848 pub rcx: __uint64_t,
1849 pub rsp: __uint64_t,
1850 pub rip: __uint64_t,
1851 pub eflags: __uint64_t,
1852 pub cs: c_ushort,
1853 pub gs: c_ushort,
1854 pub fs: c_ushort,
1855 pub __pad0: c_ushort,
1856 pub err: __uint64_t,
1857 pub trapno: __uint64_t,
1858 pub oldmask: __uint64_t,
1859 pub cr2: __uint64_t,
1860 pub _bindgen_data_1_: [u64; 1usize],
1861 pub __reserved1: [__uint64_t; 8usize],
1862}
1863impl Struct_sigcontext {
1864 pub unsafe fn fpstate(&mut self) -> *mut *mut Struct__fpstate {
1865 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
1866 ::std::mem::transmute(raw.offset(0))
1867 }
1868 pub unsafe fn __fpstate_word(&mut self) -> *mut __uint64_t {
1869 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
1870 ::std::mem::transmute(raw.offset(0))
1871 }
1872}
1873impl ::std::clone::Clone for Struct_sigcontext {
1874 fn clone(&self) -> Self { *self }
1875}
1876impl ::std::default::Default for Struct_sigcontext {
1877 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1878}
1879#[repr(C)]
1880#[derive(Copy)]
1881pub struct Struct__xsave_hdr {
1882 pub xstate_bv: __uint64_t,
1883 pub reserved1: [__uint64_t; 2usize],
1884 pub reserved2: [__uint64_t; 5usize],
1885}
1886impl ::std::clone::Clone for Struct__xsave_hdr {
1887 fn clone(&self) -> Self { *self }
1888}
1889impl ::std::default::Default for Struct__xsave_hdr {
1890 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1891}
1892#[repr(C)]
1893#[derive(Copy)]
1894pub struct Struct__ymmh_state {
1895 pub ymmh_space: [__uint32_t; 64usize],
1896}
1897impl ::std::clone::Clone for Struct__ymmh_state {
1898 fn clone(&self) -> Self { *self }
1899}
1900impl ::std::default::Default for Struct__ymmh_state {
1901 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1902}
1903#[repr(C)]
1904#[derive(Copy)]
1905pub struct Struct__xstate {
1906 pub fpstate: Struct__fpstate,
1907 pub xstate_hdr: Struct__xsave_hdr,
1908 pub ymmh: Struct__ymmh_state,
1909}
1910impl ::std::clone::Clone for Struct__xstate {
1911 fn clone(&self) -> Self { *self }
1912}
1913impl ::std::default::Default for Struct__xstate {
1914 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1915}
1916#[repr(C)]
1917#[derive(Copy)]
1918pub struct Struct_sigstack {
1919 pub ss_sp: *mut c_void,
1920 pub ss_onstack: c_int,
1921}
1922impl ::std::clone::Clone for Struct_sigstack {
1923 fn clone(&self) -> Self { *self }
1924}
1925impl ::std::default::Default for Struct_sigstack {
1926 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1927}
1928#[derive(Clone, Copy)]
1929#[repr(u32)]
1930pub enum Enum_Unnamed69 { SS_ONSTACK = 1, SS_DISABLE = 2, }
1931#[repr(C)]
1932#[derive(Copy)]
1933pub struct Struct_sigaltstack {
1934 pub ss_sp: *mut c_void,
1935 pub ss_flags: c_int,
1936 pub ss_size: size_t,
1937}
1938impl ::std::clone::Clone for Struct_sigaltstack {
1939 fn clone(&self) -> Self { *self }
1940}
1941impl ::std::default::Default for Struct_sigaltstack {
1942 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1943}
1944pub type stack_t = Struct_sigaltstack;
1945pub type greg_t = c_longlong;
1946pub type gregset_t = [greg_t; 23usize];
1947#[repr(C)]
1948#[derive(Copy)]
1949pub struct Struct__libc_fpxreg {
1950 pub significand: [c_ushort; 4usize],
1951 pub exponent: c_ushort,
1952 pub padding: [c_ushort; 3usize],
1953}
1954impl ::std::clone::Clone for Struct__libc_fpxreg {
1955 fn clone(&self) -> Self { *self }
1956}
1957impl ::std::default::Default for Struct__libc_fpxreg {
1958 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1959}
1960#[repr(C)]
1961#[derive(Copy)]
1962pub struct Struct__libc_xmmreg {
1963 pub element: [__uint32_t; 4usize],
1964}
1965impl ::std::clone::Clone for Struct__libc_xmmreg {
1966 fn clone(&self) -> Self { *self }
1967}
1968impl ::std::default::Default for Struct__libc_xmmreg {
1969 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1970}
1971#[repr(C)]
1972#[derive(Copy)]
1973pub struct Struct__libc_fpstate {
1974 pub cwd: __uint16_t,
1975 pub swd: __uint16_t,
1976 pub ftw: __uint16_t,
1977 pub fop: __uint16_t,
1978 pub rip: __uint64_t,
1979 pub rdp: __uint64_t,
1980 pub mxcsr: __uint32_t,
1981 pub mxcr_mask: __uint32_t,
1982 pub _st: [Struct__libc_fpxreg; 8usize],
1983 pub _xmm: [Struct__libc_xmmreg; 16usize],
1984 pub padding: [__uint32_t; 24usize],
1985}
1986impl ::std::clone::Clone for Struct__libc_fpstate {
1987 fn clone(&self) -> Self { *self }
1988}
1989impl ::std::default::Default for Struct__libc_fpstate {
1990 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
1991}
1992pub type fpregset_t = *mut Struct__libc_fpstate;
1993#[repr(C)]
1994#[derive(Copy)]
1995pub struct Struct_Unnamed70 {
1996 pub gregs: gregset_t,
1997 pub fpregs: fpregset_t,
1998 pub __reserved1: [c_ulonglong; 8usize],
1999}
2000impl ::std::clone::Clone for Struct_Unnamed70 {
2001 fn clone(&self) -> Self { *self }
2002}
2003impl ::std::default::Default for Struct_Unnamed70 {
2004 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2005}
2006pub type mcontext_t = Struct_Unnamed70;
2007#[repr(C)]
2008#[derive(Copy)]
2009pub struct Struct_ucontext {
2010 pub uc_flags: c_ulong,
2011 pub uc_link: *mut Struct_ucontext,
2012 pub uc_stack: stack_t,
2013 pub uc_mcontext: mcontext_t,
2014 pub uc_sigmask: __sigset_t,
2015 pub __fpregs_mem: Struct__libc_fpstate,
2016}
2017impl ::std::clone::Clone for Struct_ucontext {
2018 fn clone(&self) -> Self { *self }
2019}
2020impl ::std::default::Default for Struct_ucontext {
2021 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2022}
2023pub type ucontext_t = Struct_ucontext;
2024pub type GC_has_static_roots_func =
2025 ::std::option::Option<unsafe extern "C" fn(arg1:
2026 *const c_char,
2027 arg2:
2028 *mut c_void,
2029 arg3: size_t)
2030 -> c_int>;
2031#[repr(C)]
2032#[derive(Copy)]
2033pub struct Struct_scm_i_thread {
2034 pub next_thread: *mut Struct_scm_i_thread,
2035 pub handle: SCM,
2036 pub pthread: pthread_t,
2037 pub cleanup_handler: SCM,
2038 pub join_queue: SCM,
2039 pub admin_mutex: pthread_mutex_t,
2040 pub mutexes: SCM,
2041 pub held_mutex: *mut pthread_mutex_t,
2042 pub result: SCM,
2043 pub canceled: c_int,
2044 pub exited: c_int,
2045 pub guile_mode: c_int,
2046 pub sleep_object: SCM,
2047 pub sleep_mutex: *mut pthread_mutex_t,
2048 pub sleep_cond: pthread_cond_t,
2049 pub sleep_fd: c_int,
2050 pub sleep_pipe: [c_int; 2usize],
2051 pub current_mark_stack_ptr: *mut c_void,
2052 pub current_mark_stack_limit: *mut c_void,
2053 pub dynamic_state: SCM,
2054 pub dynwinds: SCM,
2055 pub active_asyncs: SCM,
2056 pub block_asyncs: c_uint,
2057 pub pending_asyncs: c_uint,
2058 pub continuation_root: SCM,
2059 pub continuation_base: *mut SCM_STACKITEM,
2060 pub vm: SCM,
2061 pub base: *mut SCM_STACKITEM,
2062 pub regs: jmp_buf,
2063 pub critical_section_level: c_int,
2064}
2065impl ::std::clone::Clone for Struct_scm_i_thread {
2066 fn clone(&self) -> Self { *self }
2067}
2068impl ::std::default::Default for Struct_scm_i_thread {
2069 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2070}
2071pub type scm_i_thread = Struct_scm_i_thread;
2072pub type scm_t_struct_finalize =
2073 ::std::option::Option<extern "C" fn(obj: SCM)>;
2074#[derive(Clone, Copy)]
2075#[repr(u32)]
2076pub enum Enum_Unnamed71 {
2077 SCM_M_BEGIN = 0,
2078 SCM_M_IF = 1,
2079 SCM_M_LAMBDA = 2,
2080 SCM_M_LET = 3,
2081 SCM_M_QUOTE = 4,
2082 SCM_M_DEFINE = 5,
2083 SCM_M_DYNWIND = 6,
2084 SCM_M_WITH_FLUIDS = 7,
2085 SCM_M_APPLY = 8,
2086 SCM_M_CONT = 9,
2087 SCM_M_CALL_WITH_VALUES = 10,
2088 SCM_M_CALL = 11,
2089 SCM_M_LEXICAL_REF = 12,
2090 SCM_M_LEXICAL_SET = 13,
2091 SCM_M_TOPLEVEL_REF = 14,
2092 SCM_M_TOPLEVEL_SET = 15,
2093 SCM_M_MODULE_REF = 16,
2094 SCM_M_MODULE_SET = 17,
2095 SCM_M_PROMPT = 18,
2096}
2097pub type scm_t_trampoline_0 =
2098 ::std::option::Option<extern "C" fn(_proc: SCM) -> SCM>;
2099pub type scm_t_trampoline_1 =
2100 ::std::option::Option<extern "C" fn(_proc: SCM, arg1: SCM) -> SCM>;
2101pub type scm_t_trampoline_2 =
2102 ::std::option::Option<extern "C" fn(_proc: SCM, arg1: SCM, arg2: SCM)
2103 -> SCM>;
2104pub type scm_t_extension_init_func =
2105 ::std::option::Option<unsafe extern "C" fn(arg1:
2106 *mut c_void)>;
2107pub type scm_t_finalizer_proc =
2108 ::std::option::Option<unsafe extern "C" fn(obj:
2109 *mut c_void,
2110 data:
2111 *mut c_void)>;
2112pub const SCM_FOREIGN_TYPE_LAST: Enum_scm_t_foreign_type =
2113 Enum_scm_t_foreign_type::SCM_FOREIGN_TYPE_INT64;
2114#[derive(Clone, Copy)]
2115#[repr(u32)]
2116pub enum Enum_scm_t_foreign_type {
2117 SCM_FOREIGN_TYPE_VOID = 0,
2118 SCM_FOREIGN_TYPE_FLOAT = 1,
2119 SCM_FOREIGN_TYPE_DOUBLE = 2,
2120 SCM_FOREIGN_TYPE_UINT8 = 3,
2121 SCM_FOREIGN_TYPE_INT8 = 4,
2122 SCM_FOREIGN_TYPE_UINT16 = 5,
2123 SCM_FOREIGN_TYPE_INT16 = 6,
2124 SCM_FOREIGN_TYPE_UINT32 = 7,
2125 SCM_FOREIGN_TYPE_INT32 = 8,
2126 SCM_FOREIGN_TYPE_UINT64 = 9,
2127 SCM_FOREIGN_TYPE_INT64 = 10,
2128}
2129pub type scm_t_foreign_type = Enum_scm_t_foreign_type;
2130pub type scm_t_pointer_finalizer =
2131 ::std::option::Option<unsafe extern "C" fn(arg1:
2132 *mut c_void)>;
2133pub type useconds_t = __useconds_t;
2134pub type socklen_t = __socklen_t;
2135#[derive(Clone, Copy)]
2136#[repr(u32)]
2137pub enum Enum_Unnamed72 {
2138 _PC_LINK_MAX = 0,
2139 _PC_MAX_CANON = 1,
2140 _PC_MAX_INPUT = 2,
2141 _PC_NAME_MAX = 3,
2142 _PC_PATH_MAX = 4,
2143 _PC_PIPE_BUF = 5,
2144 _PC_CHOWN_RESTRICTED = 6,
2145 _PC_NO_TRUNC = 7,
2146 _PC_VDISABLE = 8,
2147 _PC_SYNC_IO = 9,
2148 _PC_ASYNC_IO = 10,
2149 _PC_PRIO_IO = 11,
2150 _PC_SOCK_MAXBUF = 12,
2151 _PC_FILESIZEBITS = 13,
2152 _PC_REC_INCR_XFER_SIZE = 14,
2153 _PC_REC_MAX_XFER_SIZE = 15,
2154 _PC_REC_MIN_XFER_SIZE = 16,
2155 _PC_REC_XFER_ALIGN = 17,
2156 _PC_ALLOC_SIZE_MIN = 18,
2157 _PC_SYMLINK_MAX = 19,
2158 _PC_2_SYMLINKS = 20,
2159}
2160pub const _SC_IOV_MAX: Enum_Unnamed73 = Enum_Unnamed73::_SC_UIO_MAXIOV;
2161#[derive(Clone, Copy)]
2162#[repr(u32)]
2163pub enum Enum_Unnamed73 {
2164 _SC_ARG_MAX = 0,
2165 _SC_CHILD_MAX = 1,
2166 _SC_CLK_TCK = 2,
2167 _SC_NGROUPS_MAX = 3,
2168 _SC_OPEN_MAX = 4,
2169 _SC_STREAM_MAX = 5,
2170 _SC_TZNAME_MAX = 6,
2171 _SC_JOB_CONTROL = 7,
2172 _SC_SAVED_IDS = 8,
2173 _SC_REALTIME_SIGNALS = 9,
2174 _SC_PRIORITY_SCHEDULING = 10,
2175 _SC_TIMERS = 11,
2176 _SC_ASYNCHRONOUS_IO = 12,
2177 _SC_PRIORITIZED_IO = 13,
2178 _SC_SYNCHRONIZED_IO = 14,
2179 _SC_FSYNC = 15,
2180 _SC_MAPPED_FILES = 16,
2181 _SC_MEMLOCK = 17,
2182 _SC_MEMLOCK_RANGE = 18,
2183 _SC_MEMORY_PROTECTION = 19,
2184 _SC_MESSAGE_PASSING = 20,
2185 _SC_SEMAPHORES = 21,
2186 _SC_SHARED_MEMORY_OBJECTS = 22,
2187 _SC_AIO_LISTIO_MAX = 23,
2188 _SC_AIO_MAX = 24,
2189 _SC_AIO_PRIO_DELTA_MAX = 25,
2190 _SC_DELAYTIMER_MAX = 26,
2191 _SC_MQ_OPEN_MAX = 27,
2192 _SC_MQ_PRIO_MAX = 28,
2193 _SC_VERSION = 29,
2194 _SC_PAGESIZE = 30,
2195 _SC_RTSIG_MAX = 31,
2196 _SC_SEM_NSEMS_MAX = 32,
2197 _SC_SEM_VALUE_MAX = 33,
2198 _SC_SIGQUEUE_MAX = 34,
2199 _SC_TIMER_MAX = 35,
2200 _SC_BC_BASE_MAX = 36,
2201 _SC_BC_DIM_MAX = 37,
2202 _SC_BC_SCALE_MAX = 38,
2203 _SC_BC_STRING_MAX = 39,
2204 _SC_COLL_WEIGHTS_MAX = 40,
2205 _SC_EQUIV_CLASS_MAX = 41,
2206 _SC_EXPR_NEST_MAX = 42,
2207 _SC_LINE_MAX = 43,
2208 _SC_RE_DUP_MAX = 44,
2209 _SC_CHARCLASS_NAME_MAX = 45,
2210 _SC_2_VERSION = 46,
2211 _SC_2_C_BIND = 47,
2212 _SC_2_C_DEV = 48,
2213 _SC_2_FORT_DEV = 49,
2214 _SC_2_FORT_RUN = 50,
2215 _SC_2_SW_DEV = 51,
2216 _SC_2_LOCALEDEF = 52,
2217 _SC_PII = 53,
2218 _SC_PII_XTI = 54,
2219 _SC_PII_SOCKET = 55,
2220 _SC_PII_INTERNET = 56,
2221 _SC_PII_OSI = 57,
2222 _SC_POLL = 58,
2223 _SC_SELECT = 59,
2224 _SC_UIO_MAXIOV = 60,
2225 _SC_PII_INTERNET_STREAM = 61,
2226 _SC_PII_INTERNET_DGRAM = 62,
2227 _SC_PII_OSI_COTS = 63,
2228 _SC_PII_OSI_CLTS = 64,
2229 _SC_PII_OSI_M = 65,
2230 _SC_T_IOV_MAX = 66,
2231 _SC_THREADS = 67,
2232 _SC_THREAD_SAFE_FUNCTIONS = 68,
2233 _SC_GETGR_R_SIZE_MAX = 69,
2234 _SC_GETPW_R_SIZE_MAX = 70,
2235 _SC_LOGIN_NAME_MAX = 71,
2236 _SC_TTY_NAME_MAX = 72,
2237 _SC_THREAD_DESTRUCTOR_ITERATIONS = 73,
2238 _SC_THREAD_KEYS_MAX = 74,
2239 _SC_THREAD_STACK_MIN = 75,
2240 _SC_THREAD_THREADS_MAX = 76,
2241 _SC_THREAD_ATTR_STACKADDR = 77,
2242 _SC_THREAD_ATTR_STACKSIZE = 78,
2243 _SC_THREAD_PRIORITY_SCHEDULING = 79,
2244 _SC_THREAD_PRIO_INHERIT = 80,
2245 _SC_THREAD_PRIO_PROTECT = 81,
2246 _SC_THREAD_PROCESS_SHARED = 82,
2247 _SC_NPROCESSORS_CONF = 83,
2248 _SC_NPROCESSORS_ONLN = 84,
2249 _SC_PHYS_PAGES = 85,
2250 _SC_AVPHYS_PAGES = 86,
2251 _SC_ATEXIT_MAX = 87,
2252 _SC_PASS_MAX = 88,
2253 _SC_XOPEN_VERSION = 89,
2254 _SC_XOPEN_XCU_VERSION = 90,
2255 _SC_XOPEN_UNIX = 91,
2256 _SC_XOPEN_CRYPT = 92,
2257 _SC_XOPEN_ENH_I18N = 93,
2258 _SC_XOPEN_SHM = 94,
2259 _SC_2_CHAR_TERM = 95,
2260 _SC_2_C_VERSION = 96,
2261 _SC_2_UPE = 97,
2262 _SC_XOPEN_XPG2 = 98,
2263 _SC_XOPEN_XPG3 = 99,
2264 _SC_XOPEN_XPG4 = 100,
2265 _SC_CHAR_BIT = 101,
2266 _SC_CHAR_MAX = 102,
2267 _SC_CHAR_MIN = 103,
2268 _SC_INT_MAX = 104,
2269 _SC_INT_MIN = 105,
2270 _SC_LONG_BIT = 106,
2271 _SC_WORD_BIT = 107,
2272 _SC_MB_LEN_MAX = 108,
2273 _SC_NZERO = 109,
2274 _SC_SSIZE_MAX = 110,
2275 _SC_SCHAR_MAX = 111,
2276 _SC_SCHAR_MIN = 112,
2277 _SC_SHRT_MAX = 113,
2278 _SC_SHRT_MIN = 114,
2279 _SC_UCHAR_MAX = 115,
2280 _SC_UINT_MAX = 116,
2281 _SC_ULONG_MAX = 117,
2282 _SC_USHRT_MAX = 118,
2283 _SC_NL_ARGMAX = 119,
2284 _SC_NL_LANGMAX = 120,
2285 _SC_NL_MSGMAX = 121,
2286 _SC_NL_NMAX = 122,
2287 _SC_NL_SETMAX = 123,
2288 _SC_NL_TEXTMAX = 124,
2289 _SC_XBS5_ILP32_OFF32 = 125,
2290 _SC_XBS5_ILP32_OFFBIG = 126,
2291 _SC_XBS5_LP64_OFF64 = 127,
2292 _SC_XBS5_LPBIG_OFFBIG = 128,
2293 _SC_XOPEN_LEGACY = 129,
2294 _SC_XOPEN_REALTIME = 130,
2295 _SC_XOPEN_REALTIME_THREADS = 131,
2296 _SC_ADVISORY_INFO = 132,
2297 _SC_BARRIERS = 133,
2298 _SC_BASE = 134,
2299 _SC_C_LANG_SUPPORT = 135,
2300 _SC_C_LANG_SUPPORT_R = 136,
2301 _SC_CLOCK_SELECTION = 137,
2302 _SC_CPUTIME = 138,
2303 _SC_THREAD_CPUTIME = 139,
2304 _SC_DEVICE_IO = 140,
2305 _SC_DEVICE_SPECIFIC = 141,
2306 _SC_DEVICE_SPECIFIC_R = 142,
2307 _SC_FD_MGMT = 143,
2308 _SC_FIFO = 144,
2309 _SC_PIPE = 145,
2310 _SC_FILE_ATTRIBUTES = 146,
2311 _SC_FILE_LOCKING = 147,
2312 _SC_FILE_SYSTEM = 148,
2313 _SC_MONOTONIC_CLOCK = 149,
2314 _SC_MULTI_PROCESS = 150,
2315 _SC_SINGLE_PROCESS = 151,
2316 _SC_NETWORKING = 152,
2317 _SC_READER_WRITER_LOCKS = 153,
2318 _SC_SPIN_LOCKS = 154,
2319 _SC_REGEXP = 155,
2320 _SC_REGEX_VERSION = 156,
2321 _SC_SHELL = 157,
2322 _SC_SIGNALS = 158,
2323 _SC_SPAWN = 159,
2324 _SC_SPORADIC_SERVER = 160,
2325 _SC_THREAD_SPORADIC_SERVER = 161,
2326 _SC_SYSTEM_DATABASE = 162,
2327 _SC_SYSTEM_DATABASE_R = 163,
2328 _SC_TIMEOUTS = 164,
2329 _SC_TYPED_MEMORY_OBJECTS = 165,
2330 _SC_USER_GROUPS = 166,
2331 _SC_USER_GROUPS_R = 167,
2332 _SC_2_PBS = 168,
2333 _SC_2_PBS_ACCOUNTING = 169,
2334 _SC_2_PBS_LOCATE = 170,
2335 _SC_2_PBS_MESSAGE = 171,
2336 _SC_2_PBS_TRACK = 172,
2337 _SC_SYMLOOP_MAX = 173,
2338 _SC_STREAMS = 174,
2339 _SC_2_PBS_CHECKPOINT = 175,
2340 _SC_V6_ILP32_OFF32 = 176,
2341 _SC_V6_ILP32_OFFBIG = 177,
2342 _SC_V6_LP64_OFF64 = 178,
2343 _SC_V6_LPBIG_OFFBIG = 179,
2344 _SC_HOST_NAME_MAX = 180,
2345 _SC_TRACE = 181,
2346 _SC_TRACE_EVENT_FILTER = 182,
2347 _SC_TRACE_INHERIT = 183,
2348 _SC_TRACE_LOG = 184,
2349 _SC_LEVEL1_ICACHE_SIZE = 185,
2350 _SC_LEVEL1_ICACHE_ASSOC = 186,
2351 _SC_LEVEL1_ICACHE_LINESIZE = 187,
2352 _SC_LEVEL1_DCACHE_SIZE = 188,
2353 _SC_LEVEL1_DCACHE_ASSOC = 189,
2354 _SC_LEVEL1_DCACHE_LINESIZE = 190,
2355 _SC_LEVEL2_CACHE_SIZE = 191,
2356 _SC_LEVEL2_CACHE_ASSOC = 192,
2357 _SC_LEVEL2_CACHE_LINESIZE = 193,
2358 _SC_LEVEL3_CACHE_SIZE = 194,
2359 _SC_LEVEL3_CACHE_ASSOC = 195,
2360 _SC_LEVEL3_CACHE_LINESIZE = 196,
2361 _SC_LEVEL4_CACHE_SIZE = 197,
2362 _SC_LEVEL4_CACHE_ASSOC = 198,
2363 _SC_LEVEL4_CACHE_LINESIZE = 199,
2364 _SC_IPV6 = 235,
2365 _SC_RAW_SOCKETS = 236,
2366 _SC_V7_ILP32_OFF32 = 237,
2367 _SC_V7_ILP32_OFFBIG = 238,
2368 _SC_V7_LP64_OFF64 = 239,
2369 _SC_V7_LPBIG_OFFBIG = 240,
2370 _SC_SS_REPL_MAX = 241,
2371 _SC_TRACE_EVENT_NAME_MAX = 242,
2372 _SC_TRACE_NAME_MAX = 243,
2373 _SC_TRACE_SYS_MAX = 244,
2374 _SC_TRACE_USER_EVENT_MAX = 245,
2375 _SC_XOPEN_STREAMS = 246,
2376 _SC_THREAD_ROBUST_PRIO_INHERIT = 247,
2377 _SC_THREAD_ROBUST_PRIO_PROTECT = 248,
2378}
2379#[derive(Clone, Copy)]
2380#[repr(u32)]
2381pub enum Enum_Unnamed74 {
2382 _CS_PATH = 0,
2383 _CS_V6_WIDTH_RESTRICTED_ENVS = 1,
2384 _CS_GNU_LIBC_VERSION = 2,
2385 _CS_GNU_LIBPTHREAD_VERSION = 3,
2386 _CS_V5_WIDTH_RESTRICTED_ENVS = 4,
2387 _CS_V7_WIDTH_RESTRICTED_ENVS = 5,
2388 _CS_LFS_CFLAGS = 1000,
2389 _CS_LFS_LDFLAGS = 1001,
2390 _CS_LFS_LIBS = 1002,
2391 _CS_LFS_LINTFLAGS = 1003,
2392 _CS_LFS64_CFLAGS = 1004,
2393 _CS_LFS64_LDFLAGS = 1005,
2394 _CS_LFS64_LIBS = 1006,
2395 _CS_LFS64_LINTFLAGS = 1007,
2396 _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
2397 _CS_XBS5_ILP32_OFF32_LDFLAGS = 1101,
2398 _CS_XBS5_ILP32_OFF32_LIBS = 1102,
2399 _CS_XBS5_ILP32_OFF32_LINTFLAGS = 1103,
2400 _CS_XBS5_ILP32_OFFBIG_CFLAGS = 1104,
2401 _CS_XBS5_ILP32_OFFBIG_LDFLAGS = 1105,
2402 _CS_XBS5_ILP32_OFFBIG_LIBS = 1106,
2403 _CS_XBS5_ILP32_OFFBIG_LINTFLAGS = 1107,
2404 _CS_XBS5_LP64_OFF64_CFLAGS = 1108,
2405 _CS_XBS5_LP64_OFF64_LDFLAGS = 1109,
2406 _CS_XBS5_LP64_OFF64_LIBS = 1110,
2407 _CS_XBS5_LP64_OFF64_LINTFLAGS = 1111,
2408 _CS_XBS5_LPBIG_OFFBIG_CFLAGS = 1112,
2409 _CS_XBS5_LPBIG_OFFBIG_LDFLAGS = 1113,
2410 _CS_XBS5_LPBIG_OFFBIG_LIBS = 1114,
2411 _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS = 1115,
2412 _CS_POSIX_V6_ILP32_OFF32_CFLAGS = 1116,
2413 _CS_POSIX_V6_ILP32_OFF32_LDFLAGS = 1117,
2414 _CS_POSIX_V6_ILP32_OFF32_LIBS = 1118,
2415 _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS = 1119,
2416 _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS = 1120,
2417 _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS = 1121,
2418 _CS_POSIX_V6_ILP32_OFFBIG_LIBS = 1122,
2419 _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS = 1123,
2420 _CS_POSIX_V6_LP64_OFF64_CFLAGS = 1124,
2421 _CS_POSIX_V6_LP64_OFF64_LDFLAGS = 1125,
2422 _CS_POSIX_V6_LP64_OFF64_LIBS = 1126,
2423 _CS_POSIX_V6_LP64_OFF64_LINTFLAGS = 1127,
2424 _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS = 1128,
2425 _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS = 1129,
2426 _CS_POSIX_V6_LPBIG_OFFBIG_LIBS = 1130,
2427 _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS = 1131,
2428 _CS_POSIX_V7_ILP32_OFF32_CFLAGS = 1132,
2429 _CS_POSIX_V7_ILP32_OFF32_LDFLAGS = 1133,
2430 _CS_POSIX_V7_ILP32_OFF32_LIBS = 1134,
2431 _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS = 1135,
2432 _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS = 1136,
2433 _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS = 1137,
2434 _CS_POSIX_V7_ILP32_OFFBIG_LIBS = 1138,
2435 _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS = 1139,
2436 _CS_POSIX_V7_LP64_OFF64_CFLAGS = 1140,
2437 _CS_POSIX_V7_LP64_OFF64_LDFLAGS = 1141,
2438 _CS_POSIX_V7_LP64_OFF64_LIBS = 1142,
2439 _CS_POSIX_V7_LP64_OFF64_LINTFLAGS = 1143,
2440 _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS = 1144,
2441 _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS = 1145,
2442 _CS_POSIX_V7_LPBIG_OFFBIG_LIBS = 1146,
2443 _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS = 1147,
2444 _CS_V6_ENV = 1148,
2445 _CS_V7_ENV = 1149,
2446}
2447#[derive(Clone, Copy)]
2448#[repr(u32)]
2449pub enum Enum_Unnamed75 {
2450 SCM_FAILED_CONVERSION_ERROR = 0,
2451 SCM_FAILED_CONVERSION_QUESTION_MARK = 1,
2452 SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE = 2,
2453}
2454pub type scm_t_string_failed_conversion_handler = Enum_Unnamed75;
2455#[derive(Clone, Copy)]
2456#[repr(u32)]
2457pub enum Enum_scm_t_port_rw_active {
2458 SCM_PORT_NEITHER = 0,
2459 SCM_PORT_READ = 1,
2460 SCM_PORT_WRITE = 2,
2461}
2462pub type scm_t_port_rw_active = Enum_scm_t_port_rw_active;
2463#[repr(C)]
2464#[derive(Copy)]
2465pub struct Struct_Unnamed76 {
2466 pub port: SCM,
2467 pub revealed: c_int,
2468 pub stream: scm_t_bits,
2469 pub file_name: SCM,
2470 pub line_number: c_long,
2471 pub column_number: c_int,
2472 pub encoding: *mut c_char,
2473 pub ilseq_handler: scm_t_string_failed_conversion_handler,
2474 pub read_buf: *mut c_uchar,
2475 pub read_pos: *const c_uchar,
2476 pub read_end: *mut c_uchar,
2477 pub read_buf_size: scm_t_off,
2478 pub saved_read_buf: *mut c_uchar,
2479 pub saved_read_pos: *const c_uchar,
2480 pub saved_read_end: *mut c_uchar,
2481 pub saved_read_buf_size: scm_t_off,
2482 pub write_buf: *mut c_uchar,
2483 pub write_pos: *mut c_uchar,
2484 pub write_end: *mut c_uchar,
2485 pub write_buf_size: scm_t_off,
2486 pub shortbuf: c_uchar,
2487 pub rw_random: c_int,
2488 pub rw_active: scm_t_port_rw_active,
2489 pub putback_buf: *mut c_uchar,
2490 pub putback_buf_size: size_t,
2491 pub input_cd: *mut c_void,
2492 pub output_cd: *mut c_void,
2493}
2494impl ::std::clone::Clone for Struct_Unnamed76 {
2495 fn clone(&self) -> Self { *self }
2496}
2497impl ::std::default::Default for Struct_Unnamed76 {
2498 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2499}
2500pub type scm_t_port = Struct_Unnamed76;
2501#[repr(C)]
2502#[derive(Copy)]
2503pub struct Struct_scm_t_ptob_descriptor {
2504 pub name: *mut c_char,
2505 pub mark: ::std::option::Option<extern "C" fn(arg1: SCM) -> SCM>,
2506 pub free: ::std::option::Option<extern "C" fn(arg1: SCM) -> size_t>,
2507 pub print: ::std::option::Option<unsafe extern "C" fn(exp: SCM, port: SCM,
2508 pstate:
2509 *mut scm_print_state)
2510 -> c_int>,
2511 pub equalp: ::std::option::Option<extern "C" fn(arg1: SCM, arg2: SCM)
2512 -> SCM>,
2513 pub close: ::std::option::Option<extern "C" fn(port: SCM)
2514 -> c_int>,
2515 pub write: ::std::option::Option<unsafe extern "C" fn(port: SCM,
2516 data:
2517 *const c_void,
2518 size: size_t)>,
2519 pub flush: ::std::option::Option<extern "C" fn(port: SCM)>,
2520 pub end_input: ::std::option::Option<extern "C" fn(port: SCM,
2521 offset:
2522 c_int)>,
2523 pub fill_input: ::std::option::Option<extern "C" fn(port: SCM)
2524 -> c_int>,
2525 pub input_waiting: ::std::option::Option<extern "C" fn(port: SCM)
2526 -> c_int>,
2527 pub seek: ::std::option::Option<extern "C" fn(port: SCM,
2528 OFFSET: scm_t_off,
2529 WHENCE:
2530 c_int)
2531 -> scm_t_off>,
2532 pub truncate: ::std::option::Option<extern "C" fn(port: SCM,
2533 length: scm_t_off)>,
2534}
2535impl ::std::clone::Clone for Struct_scm_t_ptob_descriptor {
2536 fn clone(&self) -> Self { *self }
2537}
2538impl ::std::default::Default for Struct_scm_t_ptob_descriptor {
2539 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2540}
2541pub type scm_t_ptob_descriptor = Struct_scm_t_ptob_descriptor;
2542#[repr(C)]
2543#[derive(Copy)]
2544pub struct Struct_scm_t_fport {
2545 pub fdes: c_int,
2546}
2547impl ::std::clone::Clone for Struct_scm_t_fport {
2548 fn clone(&self) -> Self { *self }
2549}
2550impl ::std::default::Default for Struct_scm_t_fport {
2551 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2552}
2553pub type scm_t_fport = Struct_scm_t_fport;
2554#[derive(Clone, Copy)]
2555#[repr(u32)]
2556pub enum Enum_scm_t_c_hook_type {
2557 SCM_C_HOOK_NORMAL = 0,
2558 SCM_C_HOOK_OR = 1,
2559 SCM_C_HOOK_AND = 2,
2560}
2561pub type scm_t_c_hook_type = Enum_scm_t_c_hook_type;
2562pub type scm_t_c_hook_function =
2563 ::std::option::Option<unsafe extern "C" fn(hook_data:
2564 *mut c_void,
2565 fn_data:
2566 *mut c_void,
2567 data:
2568 *mut c_void)
2569 -> *mut c_void>;
2570#[repr(C)]
2571#[derive(Copy)]
2572pub struct Struct_scm_t_c_hook_entry {
2573 pub next: *mut Struct_scm_t_c_hook_entry,
2574 pub func: scm_t_c_hook_function,
2575 pub data: *mut c_void,
2576}
2577impl ::std::clone::Clone for Struct_scm_t_c_hook_entry {
2578 fn clone(&self) -> Self { *self }
2579}
2580impl ::std::default::Default for Struct_scm_t_c_hook_entry {
2581 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2582}
2583pub type scm_t_c_hook_entry = Struct_scm_t_c_hook_entry;
2584#[repr(C)]
2585#[derive(Copy)]
2586pub struct Struct_scm_t_c_hook {
2587 pub first: *mut scm_t_c_hook_entry,
2588 pub _type: scm_t_c_hook_type,
2589 pub data: *mut c_void,
2590}
2591impl ::std::clone::Clone for Struct_scm_t_c_hook {
2592 fn clone(&self) -> Self { *self }
2593}
2594impl ::std::default::Default for Struct_scm_t_c_hook {
2595 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2596}
2597pub type scm_t_c_hook = Struct_scm_t_c_hook;
2598#[repr(C)]
2599#[derive(Copy)]
2600pub struct Struct_scm_t_cell {
2601 pub word_0: SCM,
2602 pub word_1: SCM,
2603}
2604impl ::std::clone::Clone for Struct_scm_t_cell {
2605 fn clone(&self) -> Self { *self }
2606}
2607impl ::std::default::Default for Struct_scm_t_cell {
2608 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2609}
2610pub type scm_t_cell = Struct_scm_t_cell;
2611#[repr(C)]
2612#[derive(Copy)]
2613pub struct Struct_scm_t_method {
2614 pub generic_function: SCM,
2615 pub specializers: SCM,
2616 pub procedure: SCM,
2617}
2618impl ::std::clone::Clone for Struct_scm_t_method {
2619 fn clone(&self) -> Self { *self }
2620}
2621impl ::std::default::Default for Struct_scm_t_method {
2622 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2623}
2624pub type scm_t_method = Struct_scm_t_method;
2625pub type scm_t_hash_fn =
2626 ::std::option::Option<unsafe extern "C" fn(obj: SCM,
2627 max: c_ulong,
2628 closure:
2629 *mut c_void)
2630 -> c_ulong>;
2631pub type scm_t_assoc_fn =
2632 ::std::option::Option<unsafe extern "C" fn(obj: SCM, alist: SCM,
2633 closure:
2634 *mut c_void)
2635 -> SCM>;
2636pub type scm_t_hash_predicate_fn =
2637 ::std::option::Option<unsafe extern "C" fn(obj: SCM,
2638 closure:
2639 *mut c_void)
2640 -> c_int>;
2641pub type scm_t_hash_fold_fn =
2642 ::std::option::Option<unsafe extern "C" fn(closure:
2643 *mut c_void,
2644 key: SCM, value: SCM,
2645 result: SCM) -> SCM>;
2646pub type scm_t_hash_handle_fn =
2647 ::std::option::Option<unsafe extern "C" fn(closure:
2648 *mut c_void,
2649 handle: SCM) -> SCM>;
2650#[repr(C)]
2651#[derive(Copy)]
2652pub struct Struct_scm_t_hashtable {
2653 pub flags: c_int,
2654 pub n_items: c_ulong,
2655 pub lower: c_ulong,
2656 pub upper: c_ulong,
2657 pub size_index: c_int,
2658 pub min_size_index: c_int,
2659 pub hash_fn: scm_t_hash_fn,
2660}
2661impl ::std::clone::Clone for Struct_scm_t_hashtable {
2662 fn clone(&self) -> Self { *self }
2663}
2664impl ::std::default::Default for Struct_scm_t_hashtable {
2665 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2666}
2667pub type scm_t_hashtable = Struct_scm_t_hashtable;
2668#[derive(Clone, Copy)]
2669#[repr(u32)]
2670pub enum Enum_scm_keyword_arguments_flags {
2671 SCM_ALLOW_OTHER_KEYS = 1,
2672 SCM_ALLOW_NON_KEYWORD_ARGUMENTS = 2,
2673}
2674pub type scm_t_keyword_arguments_flags = Enum_scm_keyword_arguments_flags;
2675pub type scm_t_macro_primitive =
2676 ::std::option::Option<extern "C" fn(arg1: SCM, arg2: SCM) -> SCM>;
2677#[repr(C)]
2678#[derive(Copy)]
2679pub struct Struct_scm_t_rstate {
2680 pub rng: *mut Struct_scm_t_rng,
2681 pub normal_next: c_double,
2682}
2683impl ::std::clone::Clone for Struct_scm_t_rstate {
2684 fn clone(&self) -> Self { *self }
2685}
2686impl ::std::default::Default for Struct_scm_t_rstate {
2687 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2688}
2689pub type scm_t_rstate = Struct_scm_t_rstate;
2690#[repr(C)]
2691#[derive(Copy)]
2692pub struct Struct_scm_t_rng {
2693 pub rstate_size: size_t,
2694 pub random_bits: ::std::option::Option<unsafe extern "C" fn(state:
2695 *mut scm_t_rstate)
2696 -> scm_t_uint32>,
2697 pub init_rstate: ::std::option::Option<unsafe extern "C" fn(state:
2698 *mut scm_t_rstate,
2699 seed:
2700 *const c_char,
2701 n:
2702 c_int)>,
2703 pub copy_rstate: ::std::option::Option<unsafe extern "C" fn(state:
2704 *mut scm_t_rstate)
2705 -> *mut scm_t_rstate>,
2706 pub from_datum: ::std::option::Option<unsafe extern "C" fn(state:
2707 *mut scm_t_rstate,
2708 datum: SCM)>,
2709 pub to_datum: ::std::option::Option<unsafe extern "C" fn(state:
2710 *mut scm_t_rstate)
2711 -> SCM>,
2712}
2713impl ::std::clone::Clone for Struct_scm_t_rng {
2714 fn clone(&self) -> Self { *self }
2715}
2716impl ::std::default::Default for Struct_scm_t_rng {
2717 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2718}
2719pub type scm_t_rng = Struct_scm_t_rng;
2720#[repr(C)]
2721#[derive(Copy)]
2722pub struct Struct_scm_smob_descriptor {
2723 pub name: *const c_char,
2724 pub size: size_t,
2725 pub mark: ::std::option::Option<extern "C" fn(arg1: SCM) -> SCM>,
2726 pub free: ::std::option::Option<extern "C" fn(arg1: SCM) -> size_t>,
2727 pub print: ::std::option::Option<unsafe extern "C" fn(exp: SCM, port: SCM,
2728 pstate:
2729 *mut scm_print_state)
2730 -> c_int>,
2731 pub equalp: ::std::option::Option<extern "C" fn(arg1: SCM, arg2: SCM)
2732 -> SCM>,
2733 pub apply: scm_t_subr,
2734 pub apply_trampoline_objcode: SCM,
2735}
2736impl ::std::clone::Clone for Struct_scm_smob_descriptor {
2737 fn clone(&self) -> Self { *self }
2738}
2739impl ::std::default::Default for Struct_scm_smob_descriptor {
2740 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2741}
2742pub type scm_smob_descriptor = Struct_scm_smob_descriptor;
2743pub enum Struct_sockaddr { }
2744#[repr(C)]
2745#[derive(Copy)]
2746pub struct Struct_Unnamed77 {
2747 pub lo: scm_t_wchar,
2748 pub hi: scm_t_wchar,
2749}
2750impl ::std::clone::Clone for Struct_Unnamed77 {
2751 fn clone(&self) -> Self { *self }
2752}
2753impl ::std::default::Default for Struct_Unnamed77 {
2754 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2755}
2756pub type scm_t_char_range = Struct_Unnamed77;
2757#[repr(C)]
2758#[derive(Copy)]
2759pub struct Struct_Unnamed78 {
2760 pub len: size_t,
2761 pub ranges: *mut scm_t_char_range,
2762}
2763impl ::std::clone::Clone for Struct_Unnamed78 {
2764 fn clone(&self) -> Self { *self }
2765}
2766impl ::std::default::Default for Struct_Unnamed78 {
2767 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2768}
2769pub type scm_t_char_set = Struct_Unnamed78;
2770#[repr(C)]
2771#[derive(Copy)]
2772pub struct Struct_Unnamed79 {
2773 pub range: size_t,
2774 pub n: scm_t_wchar,
2775}
2776impl ::std::clone::Clone for Struct_Unnamed79 {
2777 fn clone(&self) -> Self { *self }
2778}
2779impl ::std::default::Default for Struct_Unnamed79 {
2780 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2781}
2782pub type scm_t_char_set_cursor = Struct_Unnamed79;
2783#[repr(C)]
2784#[derive(Copy)]
2785pub struct Struct_scm_objcode {
2786 pub len: scm_t_uint32,
2787 pub metalen: scm_t_uint32,
2788}
2789impl ::std::clone::Clone for Struct_scm_objcode {
2790 fn clone(&self) -> Self { *self }
2791}
2792impl ::std::default::Default for Struct_scm_objcode {
2793 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2794}
2795#[repr(C)]
2796#[derive(Copy)]
2797pub struct Struct_scm_vm_frame {
2798 pub dynamic_link: *mut SCM,
2799 pub mv_return_address: *mut scm_t_uint8,
2800 pub return_address: *mut scm_t_uint8,
2801 pub program: SCM,
2802 pub stack: [SCM; 1usize],
2803}
2804impl ::std::clone::Clone for Struct_scm_vm_frame {
2805 fn clone(&self) -> Self { *self }
2806}
2807impl ::std::default::Default for Struct_scm_vm_frame {
2808 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2809}
2810#[repr(C)]
2811#[derive(Copy)]
2812pub struct Struct_scm_frame {
2813 pub stack_holder: SCM,
2814 pub fp: *mut SCM,
2815 pub sp: *mut SCM,
2816 pub ip: *mut scm_t_uint8,
2817 pub offset: scm_t_ptrdiff,
2818}
2819impl ::std::clone::Clone for Struct_scm_frame {
2820 fn clone(&self) -> Self { *self }
2821}
2822impl ::std::default::Default for Struct_scm_frame {
2823 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2824}
2825pub type FILE = Struct__IO_FILE;
2826pub type __FILE = Struct__IO_FILE;
2827#[repr(C)]
2828#[derive(Copy)]
2829pub struct Struct_Unnamed80 {
2830 pub __count: c_int,
2831 pub __value: Union_Unnamed81,
2832}
2833impl ::std::clone::Clone for Struct_Unnamed80 {
2834 fn clone(&self) -> Self { *self }
2835}
2836impl ::std::default::Default for Struct_Unnamed80 {
2837 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2838}
2839#[repr(C)]
2840#[derive(Copy)]
2841pub struct Union_Unnamed81 {
2842 pub _bindgen_data_: [u32; 1usize],
2843}
2844impl Union_Unnamed81 {
2845 pub unsafe fn __wch(&mut self) -> *mut c_uint {
2846 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
2847 ::std::mem::transmute(raw.offset(0))
2848 }
2849 pub unsafe fn __wchb(&mut self) -> *mut [c_char; 4usize] {
2850 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
2851 ::std::mem::transmute(raw.offset(0))
2852 }
2853}
2854impl ::std::clone::Clone for Union_Unnamed81 {
2855 fn clone(&self) -> Self { *self }
2856}
2857impl ::std::default::Default for Union_Unnamed81 {
2858 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2859}
2860pub type __mbstate_t = Struct_Unnamed80;
2861#[repr(C)]
2862#[derive(Copy)]
2863pub struct Struct_Unnamed82 {
2864 pub __pos: __off_t,
2865 pub __state: __mbstate_t,
2866}
2867impl ::std::clone::Clone for Struct_Unnamed82 {
2868 fn clone(&self) -> Self { *self }
2869}
2870impl ::std::default::Default for Struct_Unnamed82 {
2871 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2872}
2873pub type _G_fpos_t = Struct_Unnamed82;
2874#[repr(C)]
2875#[derive(Copy)]
2876pub struct Struct_Unnamed83 {
2877 pub __pos: __off64_t,
2878 pub __state: __mbstate_t,
2879}
2880impl ::std::clone::Clone for Struct_Unnamed83 {
2881 fn clone(&self) -> Self { *self }
2882}
2883impl ::std::default::Default for Struct_Unnamed83 {
2884 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2885}
2886pub type _G_fpos64_t = Struct_Unnamed83;
2887pub type va_list = __gnuc_va_list;
2888pub type __gnuc_va_list = __builtin_va_list;
2889pub enum Struct__IO_jump_t { }
2890pub type _IO_lock_t = c_void;
2891#[repr(C)]
2892#[derive(Copy)]
2893pub struct Struct__IO_marker {
2894 pub _next: *mut Struct__IO_marker,
2895 pub _sbuf: *mut Struct__IO_FILE,
2896 pub _pos: c_int,
2897}
2898impl ::std::clone::Clone for Struct__IO_marker {
2899 fn clone(&self) -> Self { *self }
2900}
2901impl ::std::default::Default for Struct__IO_marker {
2902 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2903}
2904#[derive(Clone, Copy)]
2905#[repr(u32)]
2906pub enum Enum___codecvt_result {
2907 __codecvt_ok = 0,
2908 __codecvt_partial = 1,
2909 __codecvt_error = 2,
2910 __codecvt_noconv = 3,
2911}
2912#[repr(C)]
2913#[derive(Copy)]
2914pub struct Struct__IO_FILE {
2915 pub _flags: c_int,
2916 pub _IO_read_ptr: *mut c_char,
2917 pub _IO_read_end: *mut c_char,
2918 pub _IO_read_base: *mut c_char,
2919 pub _IO_write_base: *mut c_char,
2920 pub _IO_write_ptr: *mut c_char,
2921 pub _IO_write_end: *mut c_char,
2922 pub _IO_buf_base: *mut c_char,
2923 pub _IO_buf_end: *mut c_char,
2924 pub _IO_save_base: *mut c_char,
2925 pub _IO_backup_base: *mut c_char,
2926 pub _IO_save_end: *mut c_char,
2927 pub _markers: *mut Struct__IO_marker,
2928 pub _chain: *mut Struct__IO_FILE,
2929 pub _fileno: c_int,
2930 pub _flags2: c_int,
2931 pub _old_offset: __off_t,
2932 pub _cur_column: c_ushort,
2933 pub _vtable_offset: c_char,
2934 pub _shortbuf: [c_char; 1usize],
2935 pub _lock: *mut _IO_lock_t,
2936 pub _offset: __off64_t,
2937 pub __pad1: *mut c_void,
2938 pub __pad2: *mut c_void,
2939 pub __pad3: *mut c_void,
2940 pub __pad4: *mut c_void,
2941 pub __pad5: size_t,
2942 pub _mode: c_int,
2943 pub _unused2: [c_char; 20usize],
2944}
2945impl ::std::clone::Clone for Struct__IO_FILE {
2946 fn clone(&self) -> Self { *self }
2947}
2948impl ::std::default::Default for Struct__IO_FILE {
2949 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2950}
2951pub type _IO_FILE = Struct__IO_FILE;
2952pub enum Struct__IO_FILE_plus { }
2953pub type __io_read_fn =
2954 unsafe extern "C" fn(__cookie: *mut c_void,
2955 __buf: *mut c_char, __nbytes: size_t)
2956 -> __ssize_t;
2957pub type __io_write_fn =
2958 unsafe extern "C" fn(__cookie: *mut c_void,
2959 __buf: *const c_char, __n: size_t)
2960 -> __ssize_t;
2961pub type __io_seek_fn =
2962 unsafe extern "C" fn(__cookie: *mut c_void,
2963 __pos: *mut __off64_t, __w: c_int)
2964 -> c_int;
2965pub type __io_close_fn =
2966 unsafe extern "C" fn(__cookie: *mut c_void)
2967 -> c_int;
2968pub type fpos_t = _G_fpos_t;
2969pub type scm_t_inner =
2970 ::std::option::Option<unsafe extern "C" fn(arg1:
2971 *mut c_void)
2972 -> SCM>;
2973pub type scm_t_array = scm_i_t_array;
2974pub type __builtin_va_list = [__va_list_tag; 1usize];
2975pub type __va_list_tag = Struct___va_list_tag;
2976#[repr(C)]
2977#[derive(Copy)]
2978pub struct Struct___va_list_tag {
2979 pub gp_offset: c_uint,
2980 pub fp_offset: c_uint,
2981 pub overflow_arg_area: *mut c_void,
2982 pub reg_save_area: *mut c_void,
2983}
2984impl ::std::clone::Clone for Struct___va_list_tag {
2985 fn clone(&self) -> Self { *self }
2986}
2987impl ::std::default::Default for Struct___va_list_tag {
2988 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
2989}
2990#[link(name = "guile-2.0")]
2991extern "C" {
2992 pub static __gmp_bits_per_limb: c_int;
2993 pub static mut __gmp_errno: c_int;
2994 pub static __gmp_version: *const c_char;
2995 pub static mut __tzname: [*mut c_char; 2usize];
2996 pub static mut __daylight: c_int;
2997 pub static mut __timezone: c_long;
2998 pub static mut tzname: [*mut c_char; 2usize];
2999 pub static mut daylight: c_int;
3000 pub static mut timezone: c_long;
3001 pub static mut scm_system_error_key: SCM;
3002 pub static mut scm_num_overflow_key: SCM;
3003 pub static mut scm_out_of_range_key: SCM;
3004 pub static mut scm_args_number_key: SCM;
3005 pub static mut scm_arg_type_key: SCM;
3006 pub static mut scm_memory_alloc_key: SCM;
3007 pub static mut scm_misc_error_key: SCM;
3008 pub static mut scm_print_state_vtable: SCM;
3009 pub static mut scm_tc16_port_with_ps: scm_t_bits;
3010 pub static mut scm_install_gmp_memory_functions: c_int;
3011 pub static mut scm_i_array_element_types: *mut SCM;
3012 pub static mut scm_sym_documentation: SCM;
3013 pub static mut GC_gc_no: GC_word;
3014 pub static mut GC_parallel: c_int;
3015 pub static mut GC_oom_fn: GC_oom_func;
3016 pub static mut GC_on_heap_resize: GC_on_heap_resize_proc;
3017 pub static mut GC_find_leak: c_int;
3018 pub static mut GC_all_interior_pointers: c_int;
3019 pub static mut GC_finalize_on_demand: c_int;
3020 pub static mut GC_java_finalization: c_int;
3021 pub static mut GC_finalizer_notifier: GC_finalizer_notifier_proc;
3022 pub static mut GC_dont_gc: c_int;
3023 pub static mut GC_dont_expand: c_int;
3024 pub static mut GC_use_entire_heap: c_int;
3025 pub static mut GC_full_freq: c_int;
3026 pub static mut GC_non_gc_bytes: GC_word;
3027 pub static mut GC_no_dls: c_int;
3028 pub static mut GC_free_space_divisor: GC_word;
3029 pub static mut GC_max_retries: GC_word;
3030 pub static mut GC_stackbottom: *mut c_char;
3031 pub static mut GC_dont_precollect: c_int;
3032 pub static mut GC_time_limit: c_ulong;
3033 pub static mut GC_same_obj_print_proc:
3034 ::std::option::Option<unsafe extern "C" fn(arg1:
3035 *mut c_void,
3036 arg2:
3037 *mut c_void)>;
3038 pub static mut GC_is_valid_displacement_print_proc:
3039 ::std::option::Option<unsafe extern "C" fn(arg1:
3040 *mut c_void)>;
3041 pub static mut GC_is_visible_print_proc:
3042 ::std::option::Option<unsafe extern "C" fn(arg1:
3043 *mut c_void)>;
3044 pub static mut _sys_siglist: [*const c_char; 65usize];
3045 pub static mut sys_siglist: [*const c_char; 65usize];
3046 pub static mut scm_i_pthread_mutexattr_recursive:
3047 [pthread_mutexattr_t; 1usize];
3048 pub static mut scm_tc16_thread: scm_t_bits;
3049 pub static mut scm_tc16_mutex: scm_t_bits;
3050 pub static mut scm_tc16_condvar: scm_t_bits;
3051 pub static mut scm_i_misc_mutex: pthread_mutex_t;
3052 pub static mut scm_i_critical_section_mutex: pthread_mutex_t;
3053 pub static mut scm_endianness_big: SCM;
3054 pub static mut scm_endianness_little: SCM;
3055 pub static mut scm_i_native_endianness: SCM;
3056 pub static mut scm_null_bytevector: SCM;
3057 pub static mut scm_standard_vtable_vtable: SCM;
3058 pub static mut scm_applicable_struct_vtable_vtable: SCM;
3059 pub static mut scm_applicable_struct_with_setter_vtable_vtable: SCM;
3060 pub static mut scm_sym_and: SCM;
3061 pub static mut scm_sym_begin: SCM;
3062 pub static mut scm_sym_case: SCM;
3063 pub static mut scm_sym_cond: SCM;
3064 pub static mut scm_sym_define: SCM;
3065 pub static mut scm_sym_do: SCM;
3066 pub static mut scm_sym_if: SCM;
3067 pub static mut scm_sym_lambda: SCM;
3068 pub static mut scm_sym_let: SCM;
3069 pub static mut scm_sym_letstar: SCM;
3070 pub static mut scm_sym_letrec: SCM;
3071 pub static mut scm_sym_quote: SCM;
3072 pub static mut scm_sym_quasiquote: SCM;
3073 pub static mut scm_sym_unquote: SCM;
3074 pub static mut scm_sym_uq_splicing: SCM;
3075 pub static mut scm_sym_with_fluids: SCM;
3076 pub static mut scm_sym_at: SCM;
3077 pub static mut scm_sym_atat: SCM;
3078 pub static mut scm_sym_atapply: SCM;
3079 pub static mut scm_sym_atcall_cc: SCM;
3080 pub static mut scm_sym_at_call_with_values: SCM;
3081 pub static mut scm_sym_at_prompt: SCM;
3082 pub static mut scm_sym_delay: SCM;
3083 pub static mut scm_sym_at_dynamic_wind: SCM;
3084 pub static mut scm_sym_eval_when: SCM;
3085 pub static mut scm_sym_arrow: SCM;
3086 pub static mut scm_sym_else: SCM;
3087 pub static mut scm_sym_apply: SCM;
3088 pub static mut scm_sym_set_x: SCM;
3089 pub static mut scm_sym_args: SCM;
3090 pub static mut scm_tc16_memoized: scm_t_bits;
3091 pub static mut scm_program_arguments_fluid: SCM;
3092 pub static mut scm_tc16_dir: scm_t_bits;
3093 pub static mut __environ: *mut *mut c_char;
3094 pub static mut optarg: *mut c_char;
3095 pub static mut optind: c_int;
3096 pub static mut opterr: c_int;
3097 pub static mut optopt: c_int;
3098 pub static mut scm_nullstr: SCM;
3099 pub static mut scm_i_port_table_mutex: pthread_mutex_t;
3100 pub static mut scm_i_port_weak_hash: SCM;
3101 pub static mut scm_ptobs: *mut scm_t_ptob_descriptor;
3102 pub static mut scm_numptob: c_long;
3103 pub static mut scm_tc16_fport: scm_t_bits;
3104 pub static mut scm_tc16_hook: scm_t_bits;
3105 pub static mut scm_i_gc_admin_mutex: pthread_mutex_t;
3106 pub static mut scm_i_sweep_mutex: pthread_mutex_t;
3107 pub static mut scm_default_init_heap_size_1: size_t;
3108 pub static mut scm_default_min_yield_1: c_int;
3109 pub static mut scm_default_init_heap_size_2: size_t;
3110 pub static mut scm_default_min_yield_2: c_int;
3111 pub static mut scm_default_max_segment_size: size_t;
3112 pub static mut scm_gc_ports_collected: c_ulong;
3113 pub static mut scm_after_gc_hook: SCM;
3114 pub static mut scm_before_gc_c_hook: scm_t_c_hook;
3115 pub static mut scm_before_mark_c_hook: scm_t_c_hook;
3116 pub static mut scm_before_sweep_c_hook: scm_t_c_hook;
3117 pub static mut scm_after_sweep_c_hook: scm_t_c_hook;
3118 pub static mut scm_after_gc_c_hook: scm_t_c_hook;
3119 pub static mut scm_protects: SCM;
3120 pub static mut scm_print_carefully_p: c_int;
3121 pub static mut scm_class_boolean: SCM;
3122 pub static mut scm_class_char: SCM;
3123 pub static mut scm_class_pair: SCM;
3124 pub static mut scm_class_procedure: SCM;
3125 pub static mut scm_class_string: SCM;
3126 pub static mut scm_class_symbol: SCM;
3127 pub static mut scm_class_primitive_generic: SCM;
3128 pub static mut scm_class_vector: SCM;
3129 pub static mut scm_class_null: SCM;
3130 pub static mut scm_class_real: SCM;
3131 pub static mut scm_class_complex: SCM;
3132 pub static mut scm_class_integer: SCM;
3133 pub static mut scm_class_fraction: SCM;
3134 pub static mut scm_class_unknown: SCM;
3135 pub static mut scm_port_class: *mut SCM;
3136 pub static mut scm_smob_class: *mut SCM;
3137 pub static mut scm_class_top: SCM;
3138 pub static mut scm_class_object: SCM;
3139 pub static mut scm_class_class: SCM;
3140 pub static mut scm_class_applicable: SCM;
3141 pub static mut scm_class_applicable_struct: SCM;
3142 pub static mut scm_class_applicable_struct_with_setter: SCM;
3143 pub static mut scm_class_generic: SCM;
3144 pub static mut scm_class_generic_with_setter: SCM;
3145 pub static mut scm_class_accessor: SCM;
3146 pub static mut scm_class_extended_generic: SCM;
3147 pub static mut scm_class_extended_generic_with_setter: SCM;
3148 pub static mut scm_class_extended_accessor: SCM;
3149 pub static mut scm_class_method: SCM;
3150 pub static mut scm_class_accessor_method: SCM;
3151 pub static mut scm_class_procedure_class: SCM;
3152 pub static mut scm_class_applicable_struct_class: SCM;
3153 pub static mut scm_class_number: SCM;
3154 pub static mut scm_class_list: SCM;
3155 pub static mut scm_class_keyword: SCM;
3156 pub static mut scm_class_port: SCM;
3157 pub static mut scm_class_input_output_port: SCM;
3158 pub static mut scm_class_input_port: SCM;
3159 pub static mut scm_class_output_port: SCM;
3160 pub static mut scm_class_foreign_slot: SCM;
3161 pub static mut scm_class_self: SCM;
3162 pub static mut scm_class_protected: SCM;
3163 pub static mut scm_class_hidden: SCM;
3164 pub static mut scm_class_opaque: SCM;
3165 pub static mut scm_class_read_only: SCM;
3166 pub static mut scm_class_protected_hidden: SCM;
3167 pub static mut scm_class_protected_opaque: SCM;
3168 pub static mut scm_class_protected_read_only: SCM;
3169 pub static mut scm_class_scm: SCM;
3170 pub static mut scm_class_int: SCM;
3171 pub static mut scm_class_float: SCM;
3172 pub static mut scm_class_double: SCM;
3173 pub static mut scm_s_slot_set_x: *const c_char;
3174 pub static mut scm_no_applicable_method: SCM;
3175 pub static mut scm_module_goops: SCM;
3176 pub static mut scm_global_locale: SCM;
3177 pub static mut scm_i_init_mutex: pthread_mutex_t;
3178 pub static mut scm_initialized_p: c_int;
3179 pub static mut scm_tc16_keyword: scm_t_bits;
3180 pub static mut scm_tc16_malloc: scm_t_bits;
3181 pub static mut scm_module_system_booted_p: c_int;
3182 pub static mut scm_module_tag: scm_t_bits;
3183 pub static mut scm_i_locale_mutex: pthread_mutex_t;
3184 pub static mut scm_sym_name: SCM;
3185 pub static mut scm_sym_arity: SCM;
3186 pub static mut scm_sym_system_procedure: SCM;
3187 pub static mut scm_tc16_promise: scm_t_bits;
3188 pub static mut scm_the_rng: scm_t_rng;
3189 pub static mut scm_tc16_rstate: scm_t_bits;
3190 pub static mut scm_masktab: [c_uchar; 256usize];
3191 pub static mut scm_var_random_state: SCM;
3192 pub static mut scm_sym_dot: SCM;
3193 pub static mut scm_i_signal_delivery_thread: *mut scm_i_thread;
3194 pub static mut scm_usage_name: *mut c_char;
3195 pub static mut scm_numsmob: c_long;
3196 pub static mut scm_smobs: *mut scm_smob_descriptor;
3197 pub static mut scm_tc16_srcprops: scm_t_bits;
3198 pub static mut scm_sym_filename: SCM;
3199 pub static mut scm_sym_copy: SCM;
3200 pub static mut scm_sym_line: SCM;
3201 pub static mut scm_sym_column: SCM;
3202 pub static mut scm_stack_checking_enabled_p: c_int;
3203 pub static mut scm_c_time_units_per_second: c_long;
3204 pub static mut scm_tc16_charset: c_int;
3205 pub static mut scm_char_set_lower_case: SCM;
3206 pub static mut scm_char_set_upper_case: SCM;
3207 pub static mut scm_char_set_title_case: SCM;
3208 pub static mut scm_char_set_letter: SCM;
3209 pub static mut scm_char_set_digit: SCM;
3210 pub static mut scm_char_set_letter_and_digit: SCM;
3211 pub static mut scm_char_set_graphic: SCM;
3212 pub static mut scm_char_set_printing: SCM;
3213 pub static mut scm_char_set_whitespace: SCM;
3214 pub static mut scm_char_set_iso_control: SCM;
3215 pub static mut scm_char_set_punctuation: SCM;
3216 pub static mut scm_char_set_symbol: SCM;
3217 pub static mut scm_char_set_hex_digit: SCM;
3218 pub static mut scm_char_set_blank: SCM;
3219 pub static mut scm_char_set_ascii: SCM;
3220 pub static mut scm_char_set_empty: SCM;
3221 pub static mut scm_char_set_full: SCM;
3222 pub static mut scm_tc16_strport: scm_t_bits;
3223 pub static mut scm_i_array_element_type_sizes: *const size_t;
3224 pub static mut scm_values_vtable: SCM;
3225 pub static mut scm_stack_type: SCM;
3226 pub static mut _IO_2_1_stdin_: Struct__IO_FILE_plus;
3227 pub static mut _IO_2_1_stdout_: Struct__IO_FILE_plus;
3228 pub static mut _IO_2_1_stderr_: Struct__IO_FILE_plus;
3229 pub static mut stdin: *mut Struct__IO_FILE;
3230 pub static mut stdout: *mut Struct__IO_FILE;
3231 pub static mut stderr: *mut Struct__IO_FILE;
3232 pub static mut sys_nerr: c_int;
3233 pub static mut sys_errlist: *const *const c_char;
3234 pub static mut scm_isymnames: *mut *mut c_char;
3235 pub static mut scm_mallocated: c_ulong;
3236 pub static mut scm_mtrigger: c_ulong;
3237 pub static mut scm_max_segment_size: size_t;
3238 pub static mut scm_struct_table: SCM;
3239 pub static mut scm_tc16_eval_closure: scm_t_bits;
3240}
3241#[link(name = "guile-2.0")]
3242extern "C" {
3243 pub fn __gmp_set_memory_functions(arg1:
3244 ::std::option::Option<extern "C" fn(arg1:
3245 size_t)
3246 ->
3247 *mut c_void>,
3248 arg2:
3249 ::std::option::Option<unsafe extern "C" fn(arg1:
3250 *mut c_void,
3251 arg2:
3252 size_t,
3253 arg3:
3254 size_t)
3255 ->
3256 *mut c_void>,
3257 arg3:
3258 ::std::option::Option<unsafe extern "C" fn(arg1:
3259 *mut c_void,
3260 arg2:
3261 size_t)>);
3262 pub fn __gmp_get_memory_functions(arg1:
3263 *mut ::std::option::Option<extern "C" fn(arg1:
3264 size_t)
3265 ->
3266 *mut c_void>,
3267 arg2:
3268 *mut ::std::option::Option<unsafe extern "C" fn(arg1:
3269 *mut c_void,
3270 arg2:
3271 size_t,
3272 arg3:
3273 size_t)
3274 ->
3275 *mut c_void>,
3276 arg3:
3277 *mut ::std::option::Option<unsafe extern "C" fn(arg1:
3278 *mut c_void,
3279 arg2:
3280 size_t)>);
3281 pub fn __gmp_randinit(arg1: gmp_randstate_t, arg2: gmp_randalg_t, ...);
3282 pub fn __gmp_randinit_default(arg1: gmp_randstate_t);
3283 pub fn __gmp_randinit_lc_2exp(arg1: gmp_randstate_t, arg2: mpz_srcptr,
3284 arg3: c_ulong,
3285 arg4: mp_bitcnt_t);
3286 pub fn __gmp_randinit_lc_2exp_size(arg1: gmp_randstate_t,
3287 arg2: mp_bitcnt_t)
3288 -> c_int;
3289 pub fn __gmp_randinit_mt(arg1: gmp_randstate_t);
3290 pub fn __gmp_randinit_set(arg1: gmp_randstate_t,
3291 arg2: *const __gmp_randstate_struct);
3292 pub fn __gmp_randseed(arg1: gmp_randstate_t, arg2: mpz_srcptr);
3293 pub fn __gmp_randseed_ui(arg1: gmp_randstate_t,
3294 arg2: c_ulong);
3295 pub fn __gmp_randclear(arg1: gmp_randstate_t);
3296 pub fn __gmp_urandomb_ui(arg1: gmp_randstate_t,
3297 arg2: c_ulong)
3298 -> c_ulong;
3299 pub fn __gmp_urandomm_ui(arg1: gmp_randstate_t,
3300 arg2: c_ulong)
3301 -> c_ulong;
3302 pub fn __gmp_asprintf(arg1: *mut *mut c_char,
3303 arg2: *const c_char, ...)
3304 -> c_int;
3305 pub fn __gmp_printf(arg1: *const c_char, ...)
3306 -> c_int;
3307 pub fn __gmp_snprintf(arg1: *mut c_char, arg2: size_t,
3308 arg3: *const c_char, ...)
3309 -> c_int;
3310 pub fn __gmp_sprintf(arg1: *mut c_char,
3311 arg2: *const c_char, ...)
3312 -> c_int;
3313 pub fn __gmp_scanf(arg1: *const c_char, ...)
3314 -> c_int;
3315 pub fn __gmp_sscanf(arg1: *const c_char,
3316 arg2: *const c_char, ...)
3317 -> c_int;
3318 pub fn __gmpz_realloc(arg1: mpz_ptr, arg2: mp_size_t)
3319 -> *mut c_void;
3320 pub fn __gmpz_abs(__gmp_w: mpz_ptr, __gmp_u: mpz_srcptr);
3321 pub fn __gmpz_add(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3322 pub fn __gmpz_add_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3323 arg3: c_ulong);
3324 pub fn __gmpz_addmul(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3325 pub fn __gmpz_addmul_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3326 arg3: c_ulong);
3327 pub fn __gmpz_and(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3328 pub fn __gmpz_array_init(arg1: mpz_ptr, arg2: mp_size_t, arg3: mp_size_t);
3329 pub fn __gmpz_bin_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3330 arg3: c_ulong);
3331 pub fn __gmpz_bin_uiui(arg1: mpz_ptr, arg2: c_ulong,
3332 arg3: c_ulong);
3333 pub fn __gmpz_cdiv_q(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3334 pub fn __gmpz_cdiv_q_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
3335 arg3: mp_bitcnt_t);
3336 pub fn __gmpz_cdiv_q_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3337 arg3: c_ulong)
3338 -> c_ulong;
3339 pub fn __gmpz_cdiv_qr(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
3340 arg4: mpz_srcptr);
3341 pub fn __gmpz_cdiv_qr_ui(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
3342 arg4: c_ulong)
3343 -> c_ulong;
3344 pub fn __gmpz_cdiv_r(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3345 pub fn __gmpz_cdiv_r_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
3346 arg3: mp_bitcnt_t);
3347 pub fn __gmpz_cdiv_r_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3348 arg3: c_ulong)
3349 -> c_ulong;
3350 pub fn __gmpz_cdiv_ui(arg1: mpz_srcptr, arg2: c_ulong)
3351 -> c_ulong;
3352 pub fn __gmpz_clear(arg1: mpz_ptr);
3353 pub fn __gmpz_clears(arg1: mpz_ptr, ...);
3354 pub fn __gmpz_clrbit(arg1: mpz_ptr, arg2: mp_bitcnt_t);
3355 pub fn __gmpz_cmp(arg1: mpz_srcptr, arg2: mpz_srcptr)
3356 -> c_int;
3357 pub fn __gmpz_cmp_d(arg1: mpz_srcptr, arg2: c_double)
3358 -> c_int;
3359 pub fn __gmpz_cmp_si(arg1: mpz_srcptr, arg2: c_long)
3360 -> c_int;
3361 pub fn __gmpz_cmp_ui(arg1: mpz_srcptr, arg2: c_ulong)
3362 -> c_int;
3363 pub fn __gmpz_cmpabs(arg1: mpz_srcptr, arg2: mpz_srcptr)
3364 -> c_int;
3365 pub fn __gmpz_cmpabs_d(arg1: mpz_srcptr, arg2: c_double)
3366 -> c_int;
3367 pub fn __gmpz_cmpabs_ui(arg1: mpz_srcptr, arg2: c_ulong)
3368 -> c_int;
3369 pub fn __gmpz_com(arg1: mpz_ptr, arg2: mpz_srcptr);
3370 pub fn __gmpz_combit(arg1: mpz_ptr, arg2: mp_bitcnt_t);
3371 pub fn __gmpz_congruent_p(arg1: mpz_srcptr, arg2: mpz_srcptr,
3372 arg3: mpz_srcptr) -> c_int;
3373 pub fn __gmpz_congruent_2exp_p(arg1: mpz_srcptr, arg2: mpz_srcptr,
3374 arg3: mp_bitcnt_t)
3375 -> c_int;
3376 pub fn __gmpz_congruent_ui_p(arg1: mpz_srcptr,
3377 arg2: c_ulong,
3378 arg3: c_ulong)
3379 -> c_int;
3380 pub fn __gmpz_divexact(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3381 pub fn __gmpz_divexact_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3382 arg3: c_ulong);
3383 pub fn __gmpz_divisible_p(arg1: mpz_srcptr, arg2: mpz_srcptr)
3384 -> c_int;
3385 pub fn __gmpz_divisible_ui_p(arg1: mpz_srcptr,
3386 arg2: c_ulong)
3387 -> c_int;
3388 pub fn __gmpz_divisible_2exp_p(arg1: mpz_srcptr, arg2: mp_bitcnt_t)
3389 -> c_int;
3390 pub fn __gmpz_dump(arg1: mpz_srcptr);
3391 pub fn __gmpz_export(arg1: *mut c_void, arg2: *mut size_t,
3392 arg3: c_int, arg4: size_t,
3393 arg5: c_int, arg6: size_t,
3394 arg7: mpz_srcptr) -> *mut c_void;
3395 pub fn __gmpz_fac_ui(arg1: mpz_ptr, arg2: c_ulong);
3396 pub fn __gmpz_2fac_ui(arg1: mpz_ptr, arg2: c_ulong);
3397 pub fn __gmpz_mfac_uiui(arg1: mpz_ptr, arg2: c_ulong,
3398 arg3: c_ulong);
3399 pub fn __gmpz_primorial_ui(arg1: mpz_ptr, arg2: c_ulong);
3400 pub fn __gmpz_fdiv_q(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3401 pub fn __gmpz_fdiv_q_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
3402 arg3: mp_bitcnt_t);
3403 pub fn __gmpz_fdiv_q_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3404 arg3: c_ulong)
3405 -> c_ulong;
3406 pub fn __gmpz_fdiv_qr(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
3407 arg4: mpz_srcptr);
3408 pub fn __gmpz_fdiv_qr_ui(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
3409 arg4: c_ulong)
3410 -> c_ulong;
3411 pub fn __gmpz_fdiv_r(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3412 pub fn __gmpz_fdiv_r_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
3413 arg3: mp_bitcnt_t);
3414 pub fn __gmpz_fdiv_r_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3415 arg3: c_ulong)
3416 -> c_ulong;
3417 pub fn __gmpz_fdiv_ui(arg1: mpz_srcptr, arg2: c_ulong)
3418 -> c_ulong;
3419 pub fn __gmpz_fib_ui(arg1: mpz_ptr, arg2: c_ulong);
3420 pub fn __gmpz_fib2_ui(arg1: mpz_ptr, arg2: mpz_ptr,
3421 arg3: c_ulong);
3422 pub fn __gmpz_fits_sint_p(arg1: mpz_srcptr) -> c_int;
3423 pub fn __gmpz_fits_slong_p(arg1: mpz_srcptr) -> c_int;
3424 pub fn __gmpz_fits_sshort_p(arg1: mpz_srcptr) -> c_int;
3425 pub fn __gmpz_fits_uint_p(__gmp_z: mpz_srcptr) -> c_int;
3426 pub fn __gmpz_fits_ulong_p(__gmp_z: mpz_srcptr) -> c_int;
3427 pub fn __gmpz_fits_ushort_p(__gmp_z: mpz_srcptr) -> c_int;
3428 pub fn __gmpz_gcd(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3429 pub fn __gmpz_gcd_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3430 arg3: c_ulong)
3431 -> c_ulong;
3432 pub fn __gmpz_gcdext(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_ptr,
3433 arg4: mpz_srcptr, arg5: mpz_srcptr);
3434 pub fn __gmpz_get_d(arg1: mpz_srcptr) -> c_double;
3435 pub fn __gmpz_get_d_2exp(arg1: *mut c_long,
3436 arg2: mpz_srcptr) -> c_double;
3437 pub fn __gmpz_get_si(arg1: mpz_srcptr) -> c_long;
3438 pub fn __gmpz_get_str(arg1: *mut c_char,
3439 arg2: c_int, arg3: mpz_srcptr)
3440 -> *mut c_char;
3441 pub fn __gmpz_get_ui(__gmp_z: mpz_srcptr) -> c_ulong;
3442 pub fn __gmpz_getlimbn(__gmp_z: mpz_srcptr, __gmp_n: mp_size_t)
3443 -> mp_limb_t;
3444 pub fn __gmpz_hamdist(arg1: mpz_srcptr, arg2: mpz_srcptr) -> mp_bitcnt_t;
3445 pub fn __gmpz_import(arg1: mpz_ptr, arg2: size_t,
3446 arg3: c_int, arg4: size_t,
3447 arg5: c_int, arg6: size_t,
3448 arg7: *const c_void);
3449 pub fn __gmpz_init(arg1: mpz_ptr);
3450 pub fn __gmpz_init2(arg1: mpz_ptr, arg2: mp_bitcnt_t);
3451 pub fn __gmpz_inits(arg1: mpz_ptr, ...);
3452 pub fn __gmpz_init_set(arg1: mpz_ptr, arg2: mpz_srcptr);
3453 pub fn __gmpz_init_set_d(arg1: mpz_ptr, arg2: c_double);
3454 pub fn __gmpz_init_set_si(arg1: mpz_ptr, arg2: c_long);
3455 pub fn __gmpz_init_set_str(arg1: mpz_ptr,
3456 arg2: *const c_char,
3457 arg3: c_int)
3458 -> c_int;
3459 pub fn __gmpz_init_set_ui(arg1: mpz_ptr, arg2: c_ulong);
3460 pub fn __gmpz_invert(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr)
3461 -> c_int;
3462 pub fn __gmpz_ior(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3463 pub fn __gmpz_jacobi(arg1: mpz_srcptr, arg2: mpz_srcptr)
3464 -> c_int;
3465 pub fn __gmpz_kronecker_si(arg1: mpz_srcptr, arg2: c_long)
3466 -> c_int;
3467 pub fn __gmpz_kronecker_ui(arg1: mpz_srcptr,
3468 arg2: c_ulong)
3469 -> c_int;
3470 pub fn __gmpz_si_kronecker(arg1: c_long, arg2: mpz_srcptr)
3471 -> c_int;
3472 pub fn __gmpz_ui_kronecker(arg1: c_ulong,
3473 arg2: mpz_srcptr) -> c_int;
3474 pub fn __gmpz_lcm(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3475 pub fn __gmpz_lcm_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3476 arg3: c_ulong);
3477 pub fn __gmpz_lucnum_ui(arg1: mpz_ptr, arg2: c_ulong);
3478 pub fn __gmpz_lucnum2_ui(arg1: mpz_ptr, arg2: mpz_ptr,
3479 arg3: c_ulong);
3480 pub fn __gmpz_millerrabin(arg1: mpz_srcptr, arg2: c_int)
3481 -> c_int;
3482 pub fn __gmpz_mod(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3483 pub fn __gmpz_mul(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3484 pub fn __gmpz_mul_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
3485 arg3: mp_bitcnt_t);
3486 pub fn __gmpz_mul_si(arg1: mpz_ptr, arg2: mpz_srcptr,
3487 arg3: c_long);
3488 pub fn __gmpz_mul_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3489 arg3: c_ulong);
3490 pub fn __gmpz_neg(__gmp_w: mpz_ptr, __gmp_u: mpz_srcptr);
3491 pub fn __gmpz_nextprime(arg1: mpz_ptr, arg2: mpz_srcptr);
3492 pub fn __gmpz_perfect_power_p(arg1: mpz_srcptr) -> c_int;
3493 pub fn __gmpz_perfect_square_p(__gmp_a: mpz_srcptr)
3494 -> c_int;
3495 pub fn __gmpz_popcount(__gmp_u: mpz_srcptr) -> mp_bitcnt_t;
3496 pub fn __gmpz_pow_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3497 arg3: c_ulong);
3498 pub fn __gmpz_powm(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr,
3499 arg4: mpz_srcptr);
3500 pub fn __gmpz_powm_sec(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr,
3501 arg4: mpz_srcptr);
3502 pub fn __gmpz_powm_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3503 arg3: c_ulong, arg4: mpz_srcptr);
3504 pub fn __gmpz_probab_prime_p(arg1: mpz_srcptr,
3505 arg2: c_int)
3506 -> c_int;
3507 pub fn __gmpz_random(arg1: mpz_ptr, arg2: mp_size_t);
3508 pub fn __gmpz_random2(arg1: mpz_ptr, arg2: mp_size_t);
3509 pub fn __gmpz_realloc2(arg1: mpz_ptr, arg2: mp_bitcnt_t);
3510 pub fn __gmpz_remove(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr)
3511 -> mp_bitcnt_t;
3512 pub fn __gmpz_root(arg1: mpz_ptr, arg2: mpz_srcptr,
3513 arg3: c_ulong)
3514 -> c_int;
3515 pub fn __gmpz_rootrem(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
3516 arg4: c_ulong);
3517 pub fn __gmpz_rrandomb(arg1: mpz_ptr, arg2: gmp_randstate_t,
3518 arg3: mp_bitcnt_t);
3519 pub fn __gmpz_scan0(arg1: mpz_srcptr, arg2: mp_bitcnt_t) -> mp_bitcnt_t;
3520 pub fn __gmpz_scan1(arg1: mpz_srcptr, arg2: mp_bitcnt_t) -> mp_bitcnt_t;
3521 pub fn __gmpz_set(arg1: mpz_ptr, arg2: mpz_srcptr);
3522 pub fn __gmpz_set_d(arg1: mpz_ptr, arg2: c_double);
3523 pub fn __gmpz_set_f(arg1: mpz_ptr, arg2: mpf_srcptr);
3524 pub fn __gmpz_set_q(__gmp_w: mpz_ptr, __gmp_u: mpq_srcptr);
3525 pub fn __gmpz_set_si(arg1: mpz_ptr, arg2: c_long);
3526 pub fn __gmpz_set_str(arg1: mpz_ptr, arg2: *const c_char,
3527 arg3: c_int)
3528 -> c_int;
3529 pub fn __gmpz_set_ui(arg1: mpz_ptr, arg2: c_ulong);
3530 pub fn __gmpz_setbit(arg1: mpz_ptr, arg2: mp_bitcnt_t);
3531 pub fn __gmpz_size(__gmp_z: mpz_srcptr) -> size_t;
3532 pub fn __gmpz_sizeinbase(arg1: mpz_srcptr, arg2: c_int)
3533 -> size_t;
3534 pub fn __gmpz_sqrt(arg1: mpz_ptr, arg2: mpz_srcptr);
3535 pub fn __gmpz_sqrtrem(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr);
3536 pub fn __gmpz_sub(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3537 pub fn __gmpz_sub_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3538 arg3: c_ulong);
3539 pub fn __gmpz_ui_sub(arg1: mpz_ptr, arg2: c_ulong,
3540 arg3: mpz_srcptr);
3541 pub fn __gmpz_submul(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3542 pub fn __gmpz_submul_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3543 arg3: c_ulong);
3544 pub fn __gmpz_swap(arg1: mpz_ptr, arg2: mpz_ptr);
3545 pub fn __gmpz_tdiv_ui(arg1: mpz_srcptr, arg2: c_ulong)
3546 -> c_ulong;
3547 pub fn __gmpz_tdiv_q(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3548 pub fn __gmpz_tdiv_q_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
3549 arg3: mp_bitcnt_t);
3550 pub fn __gmpz_tdiv_q_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3551 arg3: c_ulong)
3552 -> c_ulong;
3553 pub fn __gmpz_tdiv_qr(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
3554 arg4: mpz_srcptr);
3555 pub fn __gmpz_tdiv_qr_ui(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
3556 arg4: c_ulong)
3557 -> c_ulong;
3558 pub fn __gmpz_tdiv_r(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3559 pub fn __gmpz_tdiv_r_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
3560 arg3: mp_bitcnt_t);
3561 pub fn __gmpz_tdiv_r_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
3562 arg3: c_ulong)
3563 -> c_ulong;
3564 pub fn __gmpz_tstbit(arg1: mpz_srcptr, arg2: mp_bitcnt_t)
3565 -> c_int;
3566 pub fn __gmpz_ui_pow_ui(arg1: mpz_ptr, arg2: c_ulong,
3567 arg3: c_ulong);
3568 pub fn __gmpz_urandomb(arg1: mpz_ptr, arg2: gmp_randstate_t,
3569 arg3: mp_bitcnt_t);
3570 pub fn __gmpz_urandomm(arg1: mpz_ptr, arg2: gmp_randstate_t,
3571 arg3: mpz_srcptr);
3572 pub fn __gmpz_xor(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
3573 pub fn __gmpz_limbs_read(arg1: mpz_srcptr) -> mp_srcptr;
3574 pub fn __gmpz_limbs_write(arg1: mpz_ptr, arg2: mp_size_t) -> mp_ptr;
3575 pub fn __gmpz_limbs_modify(arg1: mpz_ptr, arg2: mp_size_t) -> mp_ptr;
3576 pub fn __gmpz_limbs_finish(arg1: mpz_ptr, arg2: mp_size_t);
3577 pub fn __gmpz_roinit_n(arg1: mpz_ptr, arg2: mp_srcptr, arg3: mp_size_t)
3578 -> mpz_srcptr;
3579 pub fn __gmpq_abs(__gmp_w: mpq_ptr, __gmp_u: mpq_srcptr);
3580 pub fn __gmpq_add(arg1: mpq_ptr, arg2: mpq_srcptr, arg3: mpq_srcptr);
3581 pub fn __gmpq_canonicalize(arg1: mpq_ptr);
3582 pub fn __gmpq_clear(arg1: mpq_ptr);
3583 pub fn __gmpq_clears(arg1: mpq_ptr, ...);
3584 pub fn __gmpq_cmp(arg1: mpq_srcptr, arg2: mpq_srcptr)
3585 -> c_int;
3586 pub fn __gmpq_cmp_si(arg1: mpq_srcptr, arg2: c_long,
3587 arg3: c_ulong)
3588 -> c_int;
3589 pub fn __gmpq_cmp_ui(arg1: mpq_srcptr, arg2: c_ulong,
3590 arg3: c_ulong)
3591 -> c_int;
3592 pub fn __gmpq_cmp_z(arg1: mpq_srcptr, arg2: mpz_srcptr)
3593 -> c_int;
3594 pub fn __gmpq_div(arg1: mpq_ptr, arg2: mpq_srcptr, arg3: mpq_srcptr);
3595 pub fn __gmpq_div_2exp(arg1: mpq_ptr, arg2: mpq_srcptr,
3596 arg3: mp_bitcnt_t);
3597 pub fn __gmpq_equal(arg1: mpq_srcptr, arg2: mpq_srcptr)
3598 -> c_int;
3599 pub fn __gmpq_get_num(arg1: mpz_ptr, arg2: mpq_srcptr);
3600 pub fn __gmpq_get_den(arg1: mpz_ptr, arg2: mpq_srcptr);
3601 pub fn __gmpq_get_d(arg1: mpq_srcptr) -> c_double;
3602 pub fn __gmpq_get_str(arg1: *mut c_char,
3603 arg2: c_int, arg3: mpq_srcptr)
3604 -> *mut c_char;
3605 pub fn __gmpq_init(arg1: mpq_ptr);
3606 pub fn __gmpq_inits(arg1: mpq_ptr, ...);
3607 pub fn __gmpq_inv(arg1: mpq_ptr, arg2: mpq_srcptr);
3608 pub fn __gmpq_mul(arg1: mpq_ptr, arg2: mpq_srcptr, arg3: mpq_srcptr);
3609 pub fn __gmpq_mul_2exp(arg1: mpq_ptr, arg2: mpq_srcptr,
3610 arg3: mp_bitcnt_t);
3611 pub fn __gmpq_neg(__gmp_w: mpq_ptr, __gmp_u: mpq_srcptr);
3612 pub fn __gmpq_set(arg1: mpq_ptr, arg2: mpq_srcptr);
3613 pub fn __gmpq_set_d(arg1: mpq_ptr, arg2: c_double);
3614 pub fn __gmpq_set_den(arg1: mpq_ptr, arg2: mpz_srcptr);
3615 pub fn __gmpq_set_f(arg1: mpq_ptr, arg2: mpf_srcptr);
3616 pub fn __gmpq_set_num(arg1: mpq_ptr, arg2: mpz_srcptr);
3617 pub fn __gmpq_set_si(arg1: mpq_ptr, arg2: c_long,
3618 arg3: c_ulong);
3619 pub fn __gmpq_set_str(arg1: mpq_ptr, arg2: *const c_char,
3620 arg3: c_int)
3621 -> c_int;
3622 pub fn __gmpq_set_ui(arg1: mpq_ptr, arg2: c_ulong,
3623 arg3: c_ulong);
3624 pub fn __gmpq_set_z(arg1: mpq_ptr, arg2: mpz_srcptr);
3625 pub fn __gmpq_sub(arg1: mpq_ptr, arg2: mpq_srcptr, arg3: mpq_srcptr);
3626 pub fn __gmpq_swap(arg1: mpq_ptr, arg2: mpq_ptr);
3627 pub fn __gmpf_abs(arg1: mpf_ptr, arg2: mpf_srcptr);
3628 pub fn __gmpf_add(arg1: mpf_ptr, arg2: mpf_srcptr, arg3: mpf_srcptr);
3629 pub fn __gmpf_add_ui(arg1: mpf_ptr, arg2: mpf_srcptr,
3630 arg3: c_ulong);
3631 pub fn __gmpf_ceil(arg1: mpf_ptr, arg2: mpf_srcptr);
3632 pub fn __gmpf_clear(arg1: mpf_ptr);
3633 pub fn __gmpf_clears(arg1: mpf_ptr, ...);
3634 pub fn __gmpf_cmp(arg1: mpf_srcptr, arg2: mpf_srcptr)
3635 -> c_int;
3636 pub fn __gmpf_cmp_z(arg1: mpf_srcptr, arg2: mpz_srcptr)
3637 -> c_int;
3638 pub fn __gmpf_cmp_d(arg1: mpf_srcptr, arg2: c_double)
3639 -> c_int;
3640 pub fn __gmpf_cmp_si(arg1: mpf_srcptr, arg2: c_long)
3641 -> c_int;
3642 pub fn __gmpf_cmp_ui(arg1: mpf_srcptr, arg2: c_ulong)
3643 -> c_int;
3644 pub fn __gmpf_div(arg1: mpf_ptr, arg2: mpf_srcptr, arg3: mpf_srcptr);
3645 pub fn __gmpf_div_2exp(arg1: mpf_ptr, arg2: mpf_srcptr,
3646 arg3: mp_bitcnt_t);
3647 pub fn __gmpf_div_ui(arg1: mpf_ptr, arg2: mpf_srcptr,
3648 arg3: c_ulong);
3649 pub fn __gmpf_dump(arg1: mpf_srcptr);
3650 pub fn __gmpf_eq(arg1: mpf_srcptr, arg2: mpf_srcptr, arg3: mp_bitcnt_t)
3651 -> c_int;
3652 pub fn __gmpf_fits_sint_p(arg1: mpf_srcptr) -> c_int;
3653 pub fn __gmpf_fits_slong_p(arg1: mpf_srcptr) -> c_int;
3654 pub fn __gmpf_fits_sshort_p(arg1: mpf_srcptr) -> c_int;
3655 pub fn __gmpf_fits_uint_p(arg1: mpf_srcptr) -> c_int;
3656 pub fn __gmpf_fits_ulong_p(arg1: mpf_srcptr) -> c_int;
3657 pub fn __gmpf_fits_ushort_p(arg1: mpf_srcptr) -> c_int;
3658 pub fn __gmpf_floor(arg1: mpf_ptr, arg2: mpf_srcptr);
3659 pub fn __gmpf_get_d(arg1: mpf_srcptr) -> c_double;
3660 pub fn __gmpf_get_d_2exp(arg1: *mut c_long,
3661 arg2: mpf_srcptr) -> c_double;
3662 pub fn __gmpf_get_default_prec() -> mp_bitcnt_t;
3663 pub fn __gmpf_get_prec(arg1: mpf_srcptr) -> mp_bitcnt_t;
3664 pub fn __gmpf_get_si(arg1: mpf_srcptr) -> c_long;
3665 pub fn __gmpf_get_str(arg1: *mut c_char,
3666 arg2: *mut mp_exp_t, arg3: c_int,
3667 arg4: size_t, arg5: mpf_srcptr)
3668 -> *mut c_char;
3669 pub fn __gmpf_get_ui(arg1: mpf_srcptr) -> c_ulong;
3670 pub fn __gmpf_init(arg1: mpf_ptr);
3671 pub fn __gmpf_init2(arg1: mpf_ptr, arg2: mp_bitcnt_t);
3672 pub fn __gmpf_inits(arg1: mpf_ptr, ...);
3673 pub fn __gmpf_init_set(arg1: mpf_ptr, arg2: mpf_srcptr);
3674 pub fn __gmpf_init_set_d(arg1: mpf_ptr, arg2: c_double);
3675 pub fn __gmpf_init_set_si(arg1: mpf_ptr, arg2: c_long);
3676 pub fn __gmpf_init_set_str(arg1: mpf_ptr,
3677 arg2: *const c_char,
3678 arg3: c_int)
3679 -> c_int;
3680 pub fn __gmpf_init_set_ui(arg1: mpf_ptr, arg2: c_ulong);
3681 pub fn __gmpf_integer_p(arg1: mpf_srcptr) -> c_int;
3682 pub fn __gmpf_mul(arg1: mpf_ptr, arg2: mpf_srcptr, arg3: mpf_srcptr);
3683 pub fn __gmpf_mul_2exp(arg1: mpf_ptr, arg2: mpf_srcptr,
3684 arg3: mp_bitcnt_t);
3685 pub fn __gmpf_mul_ui(arg1: mpf_ptr, arg2: mpf_srcptr,
3686 arg3: c_ulong);
3687 pub fn __gmpf_neg(arg1: mpf_ptr, arg2: mpf_srcptr);
3688 pub fn __gmpf_pow_ui(arg1: mpf_ptr, arg2: mpf_srcptr,
3689 arg3: c_ulong);
3690 pub fn __gmpf_random2(arg1: mpf_ptr, arg2: mp_size_t, arg3: mp_exp_t);
3691 pub fn __gmpf_reldiff(arg1: mpf_ptr, arg2: mpf_srcptr, arg3: mpf_srcptr);
3692 pub fn __gmpf_set(arg1: mpf_ptr, arg2: mpf_srcptr);
3693 pub fn __gmpf_set_d(arg1: mpf_ptr, arg2: c_double);
3694 pub fn __gmpf_set_default_prec(arg1: mp_bitcnt_t);
3695 pub fn __gmpf_set_prec(arg1: mpf_ptr, arg2: mp_bitcnt_t);
3696 pub fn __gmpf_set_prec_raw(arg1: mpf_ptr, arg2: mp_bitcnt_t);
3697 pub fn __gmpf_set_q(arg1: mpf_ptr, arg2: mpq_srcptr);
3698 pub fn __gmpf_set_si(arg1: mpf_ptr, arg2: c_long);
3699 pub fn __gmpf_set_str(arg1: mpf_ptr, arg2: *const c_char,
3700 arg3: c_int)
3701 -> c_int;
3702 pub fn __gmpf_set_ui(arg1: mpf_ptr, arg2: c_ulong);
3703 pub fn __gmpf_set_z(arg1: mpf_ptr, arg2: mpz_srcptr);
3704 pub fn __gmpf_size(arg1: mpf_srcptr) -> size_t;
3705 pub fn __gmpf_sqrt(arg1: mpf_ptr, arg2: mpf_srcptr);
3706 pub fn __gmpf_sqrt_ui(arg1: mpf_ptr, arg2: c_ulong);
3707 pub fn __gmpf_sub(arg1: mpf_ptr, arg2: mpf_srcptr, arg3: mpf_srcptr);
3708 pub fn __gmpf_sub_ui(arg1: mpf_ptr, arg2: mpf_srcptr,
3709 arg3: c_ulong);
3710 pub fn __gmpf_swap(arg1: mpf_ptr, arg2: mpf_ptr);
3711 pub fn __gmpf_trunc(arg1: mpf_ptr, arg2: mpf_srcptr);
3712 pub fn __gmpf_ui_div(arg1: mpf_ptr, arg2: c_ulong,
3713 arg3: mpf_srcptr);
3714 pub fn __gmpf_ui_sub(arg1: mpf_ptr, arg2: c_ulong,
3715 arg3: mpf_srcptr);
3716 pub fn __gmpf_urandomb(arg1: mpf_t, arg2: gmp_randstate_t,
3717 arg3: mp_bitcnt_t);
3718 pub fn __gmpn_add(__gmp_wp: mp_ptr, __gmp_xp: mp_srcptr,
3719 __gmp_xsize: mp_size_t, __gmp_yp: mp_srcptr,
3720 __gmp_ysize: mp_size_t) -> mp_limb_t;
3721 pub fn __gmpn_add_1(__gmp_dst: mp_ptr, __gmp_src: mp_srcptr,
3722 __gmp_size: mp_size_t, __gmp_n: mp_limb_t)
3723 -> mp_limb_t;
3724 pub fn __gmpn_add_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
3725 arg4: mp_size_t) -> mp_limb_t;
3726 pub fn __gmpn_addmul_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3727 arg4: mp_limb_t) -> mp_limb_t;
3728 pub fn __gmpn_cmp(__gmp_xp: mp_srcptr, __gmp_yp: mp_srcptr,
3729 __gmp_size: mp_size_t) -> c_int;
3730 pub fn __gmpn_zero_p(__gmp_p: mp_srcptr, __gmp_n: mp_size_t)
3731 -> c_int;
3732 pub fn __gmpn_divexact_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3733 arg4: mp_limb_t);
3734 pub fn __gmpn_divexact_by3c(arg1: mp_ptr, arg2: mp_srcptr,
3735 arg3: mp_size_t, arg4: mp_limb_t)
3736 -> mp_limb_t;
3737 pub fn __gmpn_divrem(arg1: mp_ptr, arg2: mp_size_t, arg3: mp_ptr,
3738 arg4: mp_size_t, arg5: mp_srcptr, arg6: mp_size_t)
3739 -> mp_limb_t;
3740 pub fn __gmpn_divrem_1(arg1: mp_ptr, arg2: mp_size_t, arg3: mp_srcptr,
3741 arg4: mp_size_t, arg5: mp_limb_t) -> mp_limb_t;
3742 pub fn __gmpn_divrem_2(arg1: mp_ptr, arg2: mp_size_t, arg3: mp_ptr,
3743 arg4: mp_size_t, arg5: mp_srcptr) -> mp_limb_t;
3744 pub fn __gmpn_div_qr_1(arg1: mp_ptr, arg2: *mut mp_limb_t,
3745 arg3: mp_srcptr, arg4: mp_size_t, arg5: mp_limb_t)
3746 -> mp_limb_t;
3747 pub fn __gmpn_div_qr_2(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_srcptr,
3748 arg4: mp_size_t, arg5: mp_srcptr) -> mp_limb_t;
3749 pub fn __gmpn_gcd(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_size_t,
3750 arg4: mp_ptr, arg5: mp_size_t) -> mp_size_t;
3751 pub fn __gmpn_gcd_1(arg1: mp_srcptr, arg2: mp_size_t, arg3: mp_limb_t)
3752 -> mp_limb_t;
3753 pub fn __gmpn_gcdext_1(arg1: *mut mp_limb_signed_t,
3754 arg2: *mut mp_limb_signed_t, arg3: mp_limb_t,
3755 arg4: mp_limb_t) -> mp_limb_t;
3756 pub fn __gmpn_gcdext(arg1: mp_ptr, arg2: mp_ptr, arg3: *mut mp_size_t,
3757 arg4: mp_ptr, arg5: mp_size_t, arg6: mp_ptr,
3758 arg7: mp_size_t) -> mp_size_t;
3759 pub fn __gmpn_get_str(arg1: *mut c_uchar,
3760 arg2: c_int, arg3: mp_ptr,
3761 arg4: mp_size_t) -> size_t;
3762 pub fn __gmpn_hamdist(arg1: mp_srcptr, arg2: mp_srcptr, arg3: mp_size_t)
3763 -> mp_bitcnt_t;
3764 pub fn __gmpn_lshift(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3765 arg4: c_uint) -> mp_limb_t;
3766 pub fn __gmpn_mod_1(arg1: mp_srcptr, arg2: mp_size_t, arg3: mp_limb_t)
3767 -> mp_limb_t;
3768 pub fn __gmpn_mul(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3769 arg4: mp_srcptr, arg5: mp_size_t) -> mp_limb_t;
3770 pub fn __gmpn_mul_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3771 arg4: mp_limb_t) -> mp_limb_t;
3772 pub fn __gmpn_mul_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
3773 arg4: mp_size_t);
3774 pub fn __gmpn_sqr(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t);
3775 pub fn __gmpn_neg(__gmp_rp: mp_ptr, __gmp_up: mp_srcptr,
3776 __gmp_n: mp_size_t) -> mp_limb_t;
3777 pub fn __gmpn_com(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t);
3778 pub fn __gmpn_perfect_square_p(arg1: mp_srcptr, arg2: mp_size_t)
3779 -> c_int;
3780 pub fn __gmpn_perfect_power_p(arg1: mp_srcptr, arg2: mp_size_t)
3781 -> c_int;
3782 pub fn __gmpn_popcount(arg1: mp_srcptr, arg2: mp_size_t) -> mp_bitcnt_t;
3783 pub fn __gmpn_pow_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3784 arg4: mp_limb_t, arg5: mp_ptr) -> mp_size_t;
3785 pub fn __gmpn_preinv_mod_1(arg1: mp_srcptr, arg2: mp_size_t,
3786 arg3: mp_limb_t, arg4: mp_limb_t) -> mp_limb_t;
3787 pub fn __gmpn_random(arg1: mp_ptr, arg2: mp_size_t);
3788 pub fn __gmpn_random2(arg1: mp_ptr, arg2: mp_size_t);
3789 pub fn __gmpn_rshift(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3790 arg4: c_uint) -> mp_limb_t;
3791 pub fn __gmpn_scan0(arg1: mp_srcptr, arg2: mp_bitcnt_t) -> mp_bitcnt_t;
3792 pub fn __gmpn_scan1(arg1: mp_srcptr, arg2: mp_bitcnt_t) -> mp_bitcnt_t;
3793 pub fn __gmpn_set_str(arg1: mp_ptr, arg2: *const c_uchar,
3794 arg3: size_t, arg4: c_int)
3795 -> mp_size_t;
3796 pub fn __gmpn_sizeinbase(arg1: mp_srcptr, arg2: mp_size_t,
3797 arg3: c_int) -> size_t;
3798 pub fn __gmpn_sqrtrem(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_srcptr,
3799 arg4: mp_size_t) -> mp_size_t;
3800 pub fn __gmpn_sub(__gmp_wp: mp_ptr, __gmp_xp: mp_srcptr,
3801 __gmp_xsize: mp_size_t, __gmp_yp: mp_srcptr,
3802 __gmp_ysize: mp_size_t) -> mp_limb_t;
3803 pub fn __gmpn_sub_1(__gmp_dst: mp_ptr, __gmp_src: mp_srcptr,
3804 __gmp_size: mp_size_t, __gmp_n: mp_limb_t)
3805 -> mp_limb_t;
3806 pub fn __gmpn_sub_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
3807 arg4: mp_size_t) -> mp_limb_t;
3808 pub fn __gmpn_submul_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3809 arg4: mp_limb_t) -> mp_limb_t;
3810 pub fn __gmpn_tdiv_qr(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_size_t,
3811 arg4: mp_srcptr, arg5: mp_size_t, arg6: mp_srcptr,
3812 arg7: mp_size_t);
3813 pub fn __gmpn_and_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
3814 arg4: mp_size_t);
3815 pub fn __gmpn_andn_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
3816 arg4: mp_size_t);
3817 pub fn __gmpn_nand_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
3818 arg4: mp_size_t);
3819 pub fn __gmpn_ior_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
3820 arg4: mp_size_t);
3821 pub fn __gmpn_iorn_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
3822 arg4: mp_size_t);
3823 pub fn __gmpn_nior_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
3824 arg4: mp_size_t);
3825 pub fn __gmpn_xor_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
3826 arg4: mp_size_t);
3827 pub fn __gmpn_xnor_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
3828 arg4: mp_size_t);
3829 pub fn __gmpn_copyi(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t);
3830 pub fn __gmpn_copyd(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t);
3831 pub fn __gmpn_zero(arg1: mp_ptr, arg2: mp_size_t);
3832 pub fn __gmpn_cnd_add_n(arg1: mp_limb_t, arg2: mp_ptr, arg3: mp_srcptr,
3833 arg4: mp_srcptr, arg5: mp_size_t) -> mp_limb_t;
3834 pub fn __gmpn_cnd_sub_n(arg1: mp_limb_t, arg2: mp_ptr, arg3: mp_srcptr,
3835 arg4: mp_srcptr, arg5: mp_size_t) -> mp_limb_t;
3836 pub fn __gmpn_sec_add_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3837 arg4: mp_limb_t, arg5: mp_ptr) -> mp_limb_t;
3838 pub fn __gmpn_sec_add_1_itch(arg1: mp_size_t) -> mp_size_t;
3839 pub fn __gmpn_sec_sub_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3840 arg4: mp_limb_t, arg5: mp_ptr) -> mp_limb_t;
3841 pub fn __gmpn_sec_sub_1_itch(arg1: mp_size_t) -> mp_size_t;
3842 pub fn __gmpn_cnd_swap(arg1: mp_limb_t, arg2: *mut mp_limb_t,
3843 arg3: *mut mp_limb_t, arg4: mp_size_t);
3844 pub fn __gmpn_sec_mul(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3845 arg4: mp_srcptr, arg5: mp_size_t, arg6: mp_ptr);
3846 pub fn __gmpn_sec_mul_itch(arg1: mp_size_t, arg2: mp_size_t) -> mp_size_t;
3847 pub fn __gmpn_sec_sqr(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3848 arg4: mp_ptr);
3849 pub fn __gmpn_sec_sqr_itch(arg1: mp_size_t) -> mp_size_t;
3850 pub fn __gmpn_sec_powm(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
3851 arg4: mp_srcptr, arg5: mp_bitcnt_t,
3852 arg6: mp_srcptr, arg7: mp_size_t, arg8: mp_ptr);
3853 pub fn __gmpn_sec_powm_itch(arg1: mp_size_t, arg2: mp_bitcnt_t,
3854 arg3: mp_size_t) -> mp_size_t;
3855 pub fn __gmpn_sec_tabselect(arg1: *mut mp_limb_t, arg2: *const mp_limb_t,
3856 arg3: mp_size_t, arg4: mp_size_t,
3857 arg5: mp_size_t);
3858 pub fn __gmpn_sec_div_qr(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_size_t,
3859 arg4: mp_srcptr, arg5: mp_size_t, arg6: mp_ptr)
3860 -> mp_limb_t;
3861 pub fn __gmpn_sec_div_qr_itch(arg1: mp_size_t, arg2: mp_size_t)
3862 -> mp_size_t;
3863 pub fn __gmpn_sec_div_r(arg1: mp_ptr, arg2: mp_size_t, arg3: mp_srcptr,
3864 arg4: mp_size_t, arg5: mp_ptr);
3865 pub fn __gmpn_sec_div_r_itch(arg1: mp_size_t, arg2: mp_size_t)
3866 -> mp_size_t;
3867 pub fn __gmpn_sec_invert(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_srcptr,
3868 arg4: mp_size_t, arg5: mp_bitcnt_t, arg6: mp_ptr)
3869 -> c_int;
3870 pub fn __gmpn_sec_invert_itch(arg1: mp_size_t) -> mp_size_t;
3871 pub fn select(__nfds: c_int, __readfds: *mut fd_set,
3872 __writefds: *mut fd_set, __exceptfds: *mut fd_set,
3873 __timeout: *mut Struct_timeval) -> c_int;
3874 pub fn pselect(__nfds: c_int, __readfds: *mut fd_set,
3875 __writefds: *mut fd_set, __exceptfds: *mut fd_set,
3876 __timeout: *const Struct_timespec,
3877 __sigmask: *const __sigset_t) -> c_int;
3878 pub fn gettimeofday(__tv: *mut Struct_timeval, __tz: __timezone_ptr_t)
3879 -> c_int;
3880 pub fn settimeofday(__tv: *const Struct_timeval,
3881 __tz: *const Struct_timezone)
3882 -> c_int;
3883 pub fn adjtime(__delta: *const Struct_timeval,
3884 __olddelta: *mut Struct_timeval) -> c_int;
3885 pub fn getitimer(__which: __itimer_which_t,
3886 __value: *mut Struct_itimerval) -> c_int;
3887 pub fn setitimer(__which: __itimer_which_t,
3888 __new: *const Struct_itimerval,
3889 __old: *mut Struct_itimerval) -> c_int;
3890 pub fn utimes(__file: *const c_char,
3891 __tvp: *mut Struct_timeval) -> c_int;
3892 pub fn lutimes(__file: *const c_char,
3893 __tvp: *mut Struct_timeval) -> c_int;
3894 pub fn futimes(__fd: c_int, __tvp: *mut Struct_timeval)
3895 -> c_int;
3896 pub fn clock() -> clock_t;
3897 pub fn time(__timer: *mut time_t) -> time_t;
3898 pub fn difftime(__time1: time_t, __time0: time_t)
3899 -> c_double;
3900 pub fn mktime(__tp: *mut Struct_tm) -> time_t;
3901 pub fn strftime(__s: *mut c_char, __maxsize: size_t,
3902 __format: *const c_char,
3903 __tp: *const Struct_tm) -> size_t;
3904 pub fn strftime_l(__s: *mut c_char, __maxsize: size_t,
3905 __format: *const c_char,
3906 __tp: *const Struct_tm, __loc: __locale_t) -> size_t;
3907 pub fn gmtime(__timer: *const time_t) -> *mut Struct_tm;
3908 pub fn localtime(__timer: *const time_t) -> *mut Struct_tm;
3909 pub fn gmtime_r(__timer: *const time_t, __tp: *mut Struct_tm)
3910 -> *mut Struct_tm;
3911 pub fn localtime_r(__timer: *const time_t, __tp: *mut Struct_tm)
3912 -> *mut Struct_tm;
3913 pub fn asctime(__tp: *const Struct_tm) -> *mut c_char;
3914 pub fn ctime(__timer: *const time_t) -> *mut c_char;
3915 pub fn asctime_r(__tp: *const Struct_tm,
3916 __buf: *mut c_char)
3917 -> *mut c_char;
3918 pub fn ctime_r(__timer: *const time_t, __buf: *mut c_char)
3919 -> *mut c_char;
3920 pub fn tzset();
3921 pub fn stime(__when: *const time_t) -> c_int;
3922 pub fn timegm(__tp: *mut Struct_tm) -> time_t;
3923 pub fn timelocal(__tp: *mut Struct_tm) -> time_t;
3924 pub fn dysize(__year: c_int) -> c_int;
3925 pub fn nanosleep(__requested_time: *const Struct_timespec,
3926 __remaining: *mut Struct_timespec)
3927 -> c_int;
3928 pub fn clock_getres(__clock_id: clockid_t, __res: *mut Struct_timespec)
3929 -> c_int;
3930 pub fn clock_gettime(__clock_id: clockid_t, __tp: *mut Struct_timespec)
3931 -> c_int;
3932 pub fn clock_settime(__clock_id: clockid_t, __tp: *const Struct_timespec)
3933 -> c_int;
3934 pub fn clock_nanosleep(__clock_id: clockid_t,
3935 __flags: c_int,
3936 __req: *const Struct_timespec,
3937 __rem: *mut Struct_timespec)
3938 -> c_int;
3939 pub fn clock_getcpuclockid(__pid: pid_t, __clock_id: *mut clockid_t)
3940 -> c_int;
3941 pub fn timer_create(__clock_id: clockid_t, __evp: *mut Struct_sigevent,
3942 __timerid: *mut timer_t) -> c_int;
3943 pub fn timer_delete(__timerid: timer_t) -> c_int;
3944 pub fn timer_settime(__timerid: timer_t, __flags: c_int,
3945 __value: *const Struct_itimerspec,
3946 __ovalue: *mut Struct_itimerspec)
3947 -> c_int;
3948 pub fn timer_gettime(__timerid: timer_t, __value: *mut Struct_itimerspec)
3949 -> c_int;
3950 pub fn timer_getoverrun(__timerid: timer_t) -> c_int;
3951 pub fn timespec_get(__ts: *mut Struct_timespec,
3952 __base: c_int)
3953 -> c_int;
3954 pub fn __ctype_get_mb_cur_max() -> size_t;
3955 pub fn atof(__nptr: *const c_char)
3956 -> c_double;
3957 pub fn atoi(__nptr: *const c_char)
3958 -> c_int;
3959 pub fn atol(__nptr: *const c_char)
3960 -> c_long;
3961 pub fn atoll(__nptr: *const c_char)
3962 -> c_longlong;
3963 pub fn strtod(__nptr: *const c_char,
3964 __endptr: *mut *mut c_char)
3965 -> c_double;
3966 pub fn strtof(__nptr: *const c_char,
3967 __endptr: *mut *mut c_char)
3968 -> c_float;
3969 pub fn strtold(__nptr: *const c_char,
3970 __endptr: *mut *mut c_char)
3971 -> c_double;
3972 pub fn strtol(__nptr: *const c_char,
3973 __endptr: *mut *mut c_char,
3974 __base: c_int) -> c_long;
3975 pub fn strtoul(__nptr: *const c_char,
3976 __endptr: *mut *mut c_char,
3977 __base: c_int) -> c_ulong;
3978 pub fn strtoq(__nptr: *const c_char,
3979 __endptr: *mut *mut c_char,
3980 __base: c_int)
3981 -> c_longlong;
3982 pub fn strtouq(__nptr: *const c_char,
3983 __endptr: *mut *mut c_char,
3984 __base: c_int)
3985 -> c_ulonglong;
3986 pub fn strtoll(__nptr: *const c_char,
3987 __endptr: *mut *mut c_char,
3988 __base: c_int)
3989 -> c_longlong;
3990 pub fn strtoull(__nptr: *const c_char,
3991 __endptr: *mut *mut c_char,
3992 __base: c_int)
3993 -> c_ulonglong;
3994 pub fn l64a(__n: c_long) -> *mut c_char;
3995 pub fn a64l(__s: *const c_char) -> c_long;
3996 pub fn gnu_dev_major(__dev: c_ulonglong)
3997 -> c_uint;
3998 pub fn gnu_dev_minor(__dev: c_ulonglong)
3999 -> c_uint;
4000 pub fn gnu_dev_makedev(__major: c_uint,
4001 __minor: c_uint)
4002 -> c_ulonglong;
4003 pub fn random() -> c_long;
4004 pub fn srandom(__seed: c_uint);
4005 pub fn initstate(__seed: c_uint,
4006 __statebuf: *mut c_char,
4007 __statelen: size_t) -> *mut c_char;
4008 pub fn setstate(__statebuf: *mut c_char)
4009 -> *mut c_char;
4010 pub fn random_r(__buf: *mut Struct_random_data, __result: *mut int32_t)
4011 -> c_int;
4012 pub fn srandom_r(__seed: c_uint,
4013 __buf: *mut Struct_random_data) -> c_int;
4014 pub fn initstate_r(__seed: c_uint,
4015 __statebuf: *mut c_char,
4016 __statelen: size_t, __buf: *mut Struct_random_data)
4017 -> c_int;
4018 pub fn setstate_r(__statebuf: *mut c_char,
4019 __buf: *mut Struct_random_data)
4020 -> c_int;
4021 pub fn rand() -> c_int;
4022 pub fn srand(__seed: c_uint);
4023 pub fn rand_r(__seed: *mut c_uint)
4024 -> c_int;
4025 pub fn drand48() -> c_double;
4026 pub fn erand48(__xsubi: *mut c_ushort)
4027 -> c_double;
4028 pub fn lrand48() -> c_long;
4029 pub fn nrand48(__xsubi: *mut c_ushort)
4030 -> c_long;
4031 pub fn mrand48() -> c_long;
4032 pub fn jrand48(__xsubi: *mut c_ushort)
4033 -> c_long;
4034 pub fn srand48(__seedval: c_long);
4035 pub fn seed48(__seed16v: *mut c_ushort)
4036 -> *mut c_ushort;
4037 pub fn lcong48(__param: *mut c_ushort);
4038 pub fn drand48_r(__buffer: *mut Struct_drand48_data,
4039 __result: *mut c_double)
4040 -> c_int;
4041 pub fn erand48_r(__xsubi: *mut c_ushort,
4042 __buffer: *mut Struct_drand48_data,
4043 __result: *mut c_double)
4044 -> c_int;
4045 pub fn lrand48_r(__buffer: *mut Struct_drand48_data,
4046 __result: *mut c_long)
4047 -> c_int;
4048 pub fn nrand48_r(__xsubi: *mut c_ushort,
4049 __buffer: *mut Struct_drand48_data,
4050 __result: *mut c_long)
4051 -> c_int;
4052 pub fn mrand48_r(__buffer: *mut Struct_drand48_data,
4053 __result: *mut c_long)
4054 -> c_int;
4055 pub fn jrand48_r(__xsubi: *mut c_ushort,
4056 __buffer: *mut Struct_drand48_data,
4057 __result: *mut c_long)
4058 -> c_int;
4059 pub fn srand48_r(__seedval: c_long,
4060 __buffer: *mut Struct_drand48_data)
4061 -> c_int;
4062 pub fn seed48_r(__seed16v: *mut c_ushort,
4063 __buffer: *mut Struct_drand48_data)
4064 -> c_int;
4065 pub fn lcong48_r(__param: *mut c_ushort,
4066 __buffer: *mut Struct_drand48_data)
4067 -> c_int;
4068 pub fn malloc(__size: size_t) -> *mut c_void;
4069 pub fn calloc(__nmemb: size_t, __size: size_t)
4070 -> *mut c_void;
4071 pub fn realloc(__ptr: *mut c_void, __size: size_t)
4072 -> *mut c_void;
4073 pub fn free(__ptr: *mut c_void);
4074 pub fn cfree(__ptr: *mut c_void);
4075 pub fn alloca(__size: size_t) -> *mut c_void;
4076 pub fn valloc(__size: size_t) -> *mut c_void;
4077 pub fn posix_memalign(__memptr: *mut *mut c_void,
4078 __alignment: size_t, __size: size_t)
4079 -> c_int;
4080 pub fn aligned_alloc(__alignment: size_t, __size: size_t)
4081 -> *mut c_void;
4082 pub fn abort();
4083 pub fn atexit(__func: ::std::option::Option<extern "C" fn()>)
4084 -> c_int;
4085 pub fn at_quick_exit(__func: ::std::option::Option<extern "C" fn()>)
4086 -> c_int;
4087 pub fn on_exit(__func:
4088 ::std::option::Option<unsafe extern "C" fn(__status:
4089 c_int,
4090 __arg:
4091 *mut c_void)>,
4092 __arg: *mut c_void)
4093 -> c_int;
4094 pub fn exit(__status: c_int);
4095 pub fn quick_exit(__status: c_int);
4096 pub fn _Exit(__status: c_int);
4097 pub fn getenv(__name: *const c_char)
4098 -> *mut c_char;
4099 pub fn putenv(__string: *mut c_char)
4100 -> c_int;
4101 pub fn setenv(__name: *const c_char,
4102 __value: *const c_char,
4103 __replace: c_int) -> c_int;
4104 pub fn unsetenv(__name: *const c_char)
4105 -> c_int;
4106 pub fn clearenv() -> c_int;
4107 pub fn mktemp(__template: *mut c_char)
4108 -> *mut c_char;
4109 pub fn mkstemp(__template: *mut c_char)
4110 -> c_int;
4111 pub fn mkstemps(__template: *mut c_char,
4112 __suffixlen: c_int)
4113 -> c_int;
4114 pub fn mkdtemp(__template: *mut c_char)
4115 -> *mut c_char;
4116 pub fn system(__command: *const c_char)
4117 -> c_int;
4118 pub fn realpath(__name: *const c_char,
4119 __resolved: *mut c_char)
4120 -> *mut c_char;
4121 pub fn bsearch(__key: *const c_void,
4122 __base: *const c_void, __nmemb: size_t,
4123 __size: size_t, __compar: __compar_fn_t)
4124 -> *mut c_void;
4125 pub fn qsort(__base: *mut c_void, __nmemb: size_t,
4126 __size: size_t, __compar: __compar_fn_t);
4127 pub fn abs(__x: c_int) -> c_int;
4128 pub fn labs(__x: c_long) -> c_long;
4129 pub fn llabs(__x: c_longlong)
4130 -> c_longlong;
4131 pub fn div(__numer: c_int, __denom: c_int)
4132 -> div_t;
4133 pub fn ldiv(__numer: c_long,
4134 __denom: c_long) -> ldiv_t;
4135 pub fn lldiv(__numer: c_longlong,
4136 __denom: c_longlong) -> lldiv_t;
4137 pub fn ecvt(__value: c_double,
4138 __ndigit: c_int,
4139 __decpt: *mut c_int,
4140 __sign: *mut c_int)
4141 -> *mut c_char;
4142 pub fn fcvt(__value: c_double,
4143 __ndigit: c_int,
4144 __decpt: *mut c_int,
4145 __sign: *mut c_int)
4146 -> *mut c_char;
4147 pub fn gcvt(__value: c_double,
4148 __ndigit: c_int,
4149 __buf: *mut c_char)
4150 -> *mut c_char;
4151 pub fn qecvt(__value: c_double,
4152 __ndigit: c_int,
4153 __decpt: *mut c_int,
4154 __sign: *mut c_int)
4155 -> *mut c_char;
4156 pub fn qfcvt(__value: c_double,
4157 __ndigit: c_int,
4158 __decpt: *mut c_int,
4159 __sign: *mut c_int)
4160 -> *mut c_char;
4161 pub fn qgcvt(__value: c_double,
4162 __ndigit: c_int,
4163 __buf: *mut c_char)
4164 -> *mut c_char;
4165 pub fn ecvt_r(__value: c_double,
4166 __ndigit: c_int,
4167 __decpt: *mut c_int,
4168 __sign: *mut c_int,
4169 __buf: *mut c_char, __len: size_t)
4170 -> c_int;
4171 pub fn fcvt_r(__value: c_double,
4172 __ndigit: c_int,
4173 __decpt: *mut c_int,
4174 __sign: *mut c_int,
4175 __buf: *mut c_char, __len: size_t)
4176 -> c_int;
4177 pub fn qecvt_r(__value: c_double,
4178 __ndigit: c_int,
4179 __decpt: *mut c_int,
4180 __sign: *mut c_int,
4181 __buf: *mut c_char, __len: size_t)
4182 -> c_int;
4183 pub fn qfcvt_r(__value: c_double,
4184 __ndigit: c_int,
4185 __decpt: *mut c_int,
4186 __sign: *mut c_int,
4187 __buf: *mut c_char, __len: size_t)
4188 -> c_int;
4189 pub fn mblen(__s: *const c_char, __n: size_t)
4190 -> c_int;
4191 pub fn mbtowc(__pwc: *mut wchar_t, __s: *const c_char,
4192 __n: size_t) -> c_int;
4193 pub fn wctomb(__s: *mut c_char, __wchar: wchar_t)
4194 -> c_int;
4195 pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const c_char,
4196 __n: size_t) -> size_t;
4197 pub fn wcstombs(__s: *mut c_char, __pwcs: *const wchar_t,
4198 __n: size_t) -> size_t;
4199 pub fn rpmatch(__response: *const c_char)
4200 -> c_int;
4201 pub fn getsubopt(__optionp: *mut *mut c_char,
4202 __tokens: *const *mut c_char,
4203 __valuep: *mut *mut c_char)
4204 -> c_int;
4205 pub fn getloadavg(__loadavg: *mut c_double,
4206 __nelem: c_int)
4207 -> c_int;
4208 pub fn setjmp(__env: jmp_buf) -> c_int;
4209 pub fn __sigsetjmp(__env: *mut Struct___jmp_buf_tag,
4210 __savemask: c_int)
4211 -> c_int;
4212 pub fn _setjmp(__env: *mut Struct___jmp_buf_tag) -> c_int;
4213 pub fn longjmp(__env: *mut Struct___jmp_buf_tag,
4214 __val: c_int);
4215 pub fn _longjmp(__env: *mut Struct___jmp_buf_tag,
4216 __val: c_int);
4217 pub fn siglongjmp(__env: sigjmp_buf, __val: c_int);
4218 pub fn scm_async_tick();
4219 pub fn scm_call_generic_0(gf: SCM) -> SCM;
4220 pub fn scm_call_generic_1(gf: SCM, a1: SCM) -> SCM;
4221 pub fn scm_call_generic_2(gf: SCM, a1: SCM, a2: SCM) -> SCM;
4222 pub fn scm_apply_generic(gf: SCM, args: SCM) -> SCM;
4223 pub fn scm_acons(w: SCM, x: SCM, y: SCM) -> SCM;
4224 pub fn scm_sloppy_assq(x: SCM, alist: SCM) -> SCM;
4225 pub fn scm_sloppy_assv(x: SCM, alist: SCM) -> SCM;
4226 pub fn scm_sloppy_assoc(x: SCM, alist: SCM) -> SCM;
4227 pub fn scm_assq(x: SCM, alist: SCM) -> SCM;
4228 pub fn scm_assv(x: SCM, alist: SCM) -> SCM;
4229 pub fn scm_assoc(x: SCM, alist: SCM) -> SCM;
4230 pub fn scm_assq_ref(alist: SCM, key: SCM) -> SCM;
4231 pub fn scm_assv_ref(alist: SCM, key: SCM) -> SCM;
4232 pub fn scm_assoc_ref(alist: SCM, key: SCM) -> SCM;
4233 pub fn scm_assq_set_x(alist: SCM, key: SCM, val: SCM) -> SCM;
4234 pub fn scm_assv_set_x(alist: SCM, key: SCM, val: SCM) -> SCM;
4235 pub fn scm_assoc_set_x(alist: SCM, key: SCM, val: SCM) -> SCM;
4236 pub fn scm_assq_remove_x(alist: SCM, key: SCM) -> SCM;
4237 pub fn scm_assv_remove_x(alist: SCM, key: SCM) -> SCM;
4238 pub fn scm_assoc_remove_x(alist: SCM, key: SCM) -> SCM;
4239 pub fn scm_init_alist();
4240 pub fn scm_make_arbiter(name: SCM) -> SCM;
4241 pub fn scm_try_arbiter(arb: SCM) -> SCM;
4242 pub fn scm_release_arbiter(arb: SCM) -> SCM;
4243 pub fn scm_init_arbiters();
4244 pub fn scm_error(key: SCM, subr: *const c_char,
4245 message: *const c_char, args: SCM,
4246 rest: SCM);
4247 pub fn scm_error_scm(key: SCM, subr: SCM, message: SCM, args: SCM,
4248 rest: SCM) -> SCM;
4249 pub fn scm_strerror(err: SCM) -> SCM;
4250 pub fn scm_syserror(subr: *const c_char);
4251 pub fn scm_syserror_msg(subr: *const c_char,
4252 message: *const c_char, args: SCM,
4253 eno: c_int);
4254 pub fn scm_num_overflow(subr: *const c_char);
4255 pub fn scm_out_of_range(subr: *const c_char,
4256 bad_value: SCM);
4257 pub fn scm_out_of_range_pos(subr: *const c_char,
4258 bad_value: SCM, pos: SCM);
4259 pub fn scm_wrong_num_args(_proc: SCM);
4260 pub fn scm_error_num_args_subr(subr: *const c_char);
4261 pub fn scm_wrong_type_arg(subr: *const c_char,
4262 pos: c_int, bad_value: SCM);
4263 pub fn scm_i_wrong_type_arg_symbol(symbol: SCM,
4264 pos: c_int,
4265 bad_value: SCM);
4266 pub fn scm_wrong_type_arg_msg(subr: *const c_char,
4267 pos: c_int, bad_value: SCM,
4268 sz: *const c_char);
4269 pub fn scm_memory_error(subr: *const c_char);
4270 pub fn scm_misc_error(subr: *const c_char,
4271 message: *const c_char, args: SCM);
4272 pub fn scm_init_error();
4273 pub fn scm_char_p(x: SCM) -> SCM;
4274 pub fn scm_char_eq_p(x: SCM, y: SCM) -> SCM;
4275 pub fn scm_char_less_p(x: SCM, y: SCM) -> SCM;
4276 pub fn scm_char_leq_p(x: SCM, y: SCM) -> SCM;
4277 pub fn scm_char_gr_p(x: SCM, y: SCM) -> SCM;
4278 pub fn scm_char_geq_p(x: SCM, y: SCM) -> SCM;
4279 pub fn scm_char_ci_eq_p(x: SCM, y: SCM) -> SCM;
4280 pub fn scm_char_ci_less_p(x: SCM, y: SCM) -> SCM;
4281 pub fn scm_char_ci_leq_p(x: SCM, y: SCM) -> SCM;
4282 pub fn scm_char_ci_gr_p(x: SCM, y: SCM) -> SCM;
4283 pub fn scm_char_ci_geq_p(x: SCM, y: SCM) -> SCM;
4284 pub fn scm_char_alphabetic_p(chr: SCM) -> SCM;
4285 pub fn scm_char_numeric_p(chr: SCM) -> SCM;
4286 pub fn scm_char_whitespace_p(chr: SCM) -> SCM;
4287 pub fn scm_char_upper_case_p(chr: SCM) -> SCM;
4288 pub fn scm_char_lower_case_p(chr: SCM) -> SCM;
4289 pub fn scm_char_is_both_p(chr: SCM) -> SCM;
4290 pub fn scm_char_to_integer(chr: SCM) -> SCM;
4291 pub fn scm_integer_to_char(n: SCM) -> SCM;
4292 pub fn scm_char_upcase(chr: SCM) -> SCM;
4293 pub fn scm_char_downcase(chr: SCM) -> SCM;
4294 pub fn scm_char_titlecase(chr: SCM) -> SCM;
4295 pub fn scm_char_general_category(chr: SCM) -> SCM;
4296 pub fn scm_c_upcase(c: scm_t_wchar) -> scm_t_wchar;
4297 pub fn scm_c_downcase(c: scm_t_wchar) -> scm_t_wchar;
4298 pub fn scm_c_titlecase(c: scm_t_wchar) -> scm_t_wchar;
4299 pub fn scm_i_charname(chr: SCM) -> *const c_char;
4300 pub fn scm_i_charname_to_char(charname: *const c_char,
4301 charname_len: size_t) -> SCM;
4302 pub fn scm_init_chars();
4303 pub fn scm_options_try(args: SCM, options: *mut scm_t_option,
4304 s: *const c_char,
4305 dry_run: c_int) -> SCM;
4306 pub fn scm_options(arg1: SCM, arg2: *mut scm_t_option,
4307 arg3: *const c_char) -> SCM;
4308 pub fn scm_init_opts(arg1:
4309 ::std::option::Option<extern "C" fn(arg1: SCM)
4310 -> SCM>,
4311 arg2: *mut scm_t_option);
4312 pub fn scm_init_options();
4313 pub fn scm_print_options(setting: SCM) -> SCM;
4314 pub fn scm_make_print_state() -> SCM;
4315 pub fn scm_free_print_state(print_state: SCM);
4316 pub fn scm_i_port_with_print_state(port: SCM, print_state: SCM) -> SCM;
4317 pub fn scm_i_display_substring(str: SCM, start: size_t, end: size_t,
4318 port: SCM);
4319 pub fn scm_intprint(n: scm_t_intmax, radix: c_int,
4320 port: SCM);
4321 pub fn scm_uintprint(n: scm_t_uintmax, radix: c_int,
4322 port: SCM);
4323 pub fn scm_ipruk(hdr: *mut c_char, ptr: SCM, port: SCM);
4324 pub fn scm_iprlist(hdr: *mut c_char, exp: SCM,
4325 tlr: c_int, port: SCM,
4326 pstate: *mut scm_print_state);
4327 pub fn scm_i_print_symbol_name(sym: SCM, port: SCM);
4328 pub fn scm_print_symbol_name(str: *const c_char,
4329 len: size_t, port: SCM);
4330 pub fn scm_prin1(exp: SCM, port: SCM, writingp: c_int);
4331 pub fn scm_iprin1(exp: SCM, port: SCM, pstate: *mut scm_print_state);
4332 pub fn scm_write(obj: SCM, port: SCM) -> SCM;
4333 pub fn scm_display(obj: SCM, port: SCM) -> SCM;
4334 pub fn scm_simple_format(port: SCM, message: SCM, args: SCM) -> SCM;
4335 pub fn scm_newline(port: SCM) -> SCM;
4336 pub fn scm_write_char(chr: SCM, port: SCM) -> SCM;
4337 pub fn scm_printer_apply(_proc: SCM, exp: SCM, port: SCM,
4338 arg1: *mut scm_print_state) -> SCM;
4339 pub fn scm_port_with_print_state(port: SCM, pstate: SCM) -> SCM;
4340 pub fn scm_get_print_state(port: SCM) -> SCM;
4341 pub fn scm_valid_oport_value_p(val: SCM) -> c_int;
4342 pub fn scm_init_print();
4343 pub fn scm_exact_p(x: SCM) -> SCM;
4344 pub fn scm_is_exact(x: SCM) -> c_int;
4345 pub fn scm_odd_p(n: SCM) -> SCM;
4346 pub fn scm_even_p(n: SCM) -> SCM;
4347 pub fn scm_finite_p(x: SCM) -> SCM;
4348 pub fn scm_inf_p(x: SCM) -> SCM;
4349 pub fn scm_nan_p(x: SCM) -> SCM;
4350 pub fn scm_inf() -> SCM;
4351 pub fn scm_nan() -> SCM;
4352 pub fn scm_abs(x: SCM) -> SCM;
4353 pub fn scm_quotient(x: SCM, y: SCM) -> SCM;
4354 pub fn scm_remainder(x: SCM, y: SCM) -> SCM;
4355 pub fn scm_modulo(x: SCM, y: SCM) -> SCM;
4356 pub fn scm_euclidean_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
4357 pub fn scm_euclidean_quotient(x: SCM, y: SCM) -> SCM;
4358 pub fn scm_euclidean_remainder(x: SCM, y: SCM) -> SCM;
4359 pub fn scm_floor_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
4360 pub fn scm_floor_quotient(x: SCM, y: SCM) -> SCM;
4361 pub fn scm_floor_remainder(x: SCM, y: SCM) -> SCM;
4362 pub fn scm_ceiling_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
4363 pub fn scm_ceiling_quotient(x: SCM, y: SCM) -> SCM;
4364 pub fn scm_ceiling_remainder(x: SCM, y: SCM) -> SCM;
4365 pub fn scm_truncate_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
4366 pub fn scm_truncate_quotient(x: SCM, y: SCM) -> SCM;
4367 pub fn scm_truncate_remainder(x: SCM, y: SCM) -> SCM;
4368 pub fn scm_centered_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
4369 pub fn scm_centered_quotient(x: SCM, y: SCM) -> SCM;
4370 pub fn scm_centered_remainder(x: SCM, y: SCM) -> SCM;
4371 pub fn scm_round_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
4372 pub fn scm_round_quotient(x: SCM, y: SCM) -> SCM;
4373 pub fn scm_round_remainder(x: SCM, y: SCM) -> SCM;
4374 pub fn scm_gcd(x: SCM, y: SCM) -> SCM;
4375 pub fn scm_lcm(n1: SCM, n2: SCM) -> SCM;
4376 pub fn scm_logand(n1: SCM, n2: SCM) -> SCM;
4377 pub fn scm_logior(n1: SCM, n2: SCM) -> SCM;
4378 pub fn scm_logxor(n1: SCM, n2: SCM) -> SCM;
4379 pub fn scm_logtest(n1: SCM, n2: SCM) -> SCM;
4380 pub fn scm_logbit_p(n1: SCM, n2: SCM) -> SCM;
4381 pub fn scm_lognot(n: SCM) -> SCM;
4382 pub fn scm_modulo_expt(n: SCM, k: SCM, m: SCM) -> SCM;
4383 pub fn scm_integer_expt(z1: SCM, z2: SCM) -> SCM;
4384 pub fn scm_ash(n: SCM, count: SCM) -> SCM;
4385 pub fn scm_round_ash(n: SCM, count: SCM) -> SCM;
4386 pub fn scm_bit_extract(n: SCM, start: SCM, end: SCM) -> SCM;
4387 pub fn scm_logcount(n: SCM) -> SCM;
4388 pub fn scm_integer_length(n: SCM) -> SCM;
4389 pub fn scm_i_euclidean_divide(x: SCM, y: SCM) -> SCM;
4390 pub fn scm_i_floor_divide(x: SCM, y: SCM) -> SCM;
4391 pub fn scm_i_ceiling_divide(x: SCM, y: SCM) -> SCM;
4392 pub fn scm_i_truncate_divide(x: SCM, y: SCM) -> SCM;
4393 pub fn scm_i_centered_divide(x: SCM, y: SCM) -> SCM;
4394 pub fn scm_i_round_divide(x: SCM, y: SCM) -> SCM;
4395 pub fn scm_i_gcd(x: SCM, y: SCM, rest: SCM) -> SCM;
4396 pub fn scm_i_lcm(x: SCM, y: SCM, rest: SCM) -> SCM;
4397 pub fn scm_i_logand(x: SCM, y: SCM, rest: SCM) -> SCM;
4398 pub fn scm_i_logior(x: SCM, y: SCM, rest: SCM) -> SCM;
4399 pub fn scm_i_logxor(x: SCM, y: SCM, rest: SCM) -> SCM;
4400 pub fn scm_iint2str(num: scm_t_intmax, rad: c_int,
4401 p: *mut c_char) -> size_t;
4402 pub fn scm_iuint2str(num: scm_t_uintmax, rad: c_int,
4403 p: *mut c_char) -> size_t;
4404 pub fn scm_number_to_string(x: SCM, radix: SCM) -> SCM;
4405 pub fn scm_print_real(sexp: SCM, port: SCM, pstate: *mut scm_print_state)
4406 -> c_int;
4407 pub fn scm_print_complex(sexp: SCM, port: SCM,
4408 pstate: *mut scm_print_state)
4409 -> c_int;
4410 pub fn scm_bigprint(exp: SCM, port: SCM, pstate: *mut scm_print_state)
4411 -> c_int;
4412 pub fn scm_c_locale_stringn_to_number(mem: *const c_char,
4413 len: size_t,
4414 radix: c_uint)
4415 -> SCM;
4416 pub fn scm_i_string_to_number(str: SCM, radix: c_uint)
4417 -> SCM;
4418 pub fn scm_string_to_number(str: SCM, radix: SCM) -> SCM;
4419 pub fn scm_bigequal(x: SCM, y: SCM) -> SCM;
4420 pub fn scm_real_equalp(x: SCM, y: SCM) -> SCM;
4421 pub fn scm_complex_equalp(x: SCM, y: SCM) -> SCM;
4422 pub fn scm_number_p(x: SCM) -> SCM;
4423 pub fn scm_complex_p(x: SCM) -> SCM;
4424 pub fn scm_real_p(x: SCM) -> SCM;
4425 pub fn scm_rational_p(z: SCM) -> SCM;
4426 pub fn scm_integer_p(x: SCM) -> SCM;
4427 pub fn scm_exact_integer_p(x: SCM) -> SCM;
4428 pub fn scm_inexact_p(x: SCM) -> SCM;
4429 pub fn scm_is_inexact(x: SCM) -> c_int;
4430 pub fn scm_num_eq_p(x: SCM, y: SCM) -> SCM;
4431 pub fn scm_less_p(x: SCM, y: SCM) -> SCM;
4432 pub fn scm_gr_p(x: SCM, y: SCM) -> SCM;
4433 pub fn scm_leq_p(x: SCM, y: SCM) -> SCM;
4434 pub fn scm_geq_p(x: SCM, y: SCM) -> SCM;
4435 pub fn scm_zero_p(z: SCM) -> SCM;
4436 pub fn scm_positive_p(x: SCM) -> SCM;
4437 pub fn scm_negative_p(x: SCM) -> SCM;
4438 pub fn scm_max(x: SCM, y: SCM) -> SCM;
4439 pub fn scm_min(x: SCM, y: SCM) -> SCM;
4440 pub fn scm_sum(x: SCM, y: SCM) -> SCM;
4441 pub fn scm_oneplus(x: SCM) -> SCM;
4442 pub fn scm_difference(x: SCM, y: SCM) -> SCM;
4443 pub fn scm_oneminus(x: SCM) -> SCM;
4444 pub fn scm_product(x: SCM, y: SCM) -> SCM;
4445 pub fn scm_divide(x: SCM, y: SCM) -> SCM;
4446 pub fn scm_floor(x: SCM) -> SCM;
4447 pub fn scm_ceiling(x: SCM) -> SCM;
4448 pub fn scm_c_truncate(x: c_double)
4449 -> c_double;
4450 pub fn scm_c_round(x: c_double)
4451 -> c_double;
4452 pub fn scm_truncate_number(x: SCM) -> SCM;
4453 pub fn scm_round_number(x: SCM) -> SCM;
4454 pub fn scm_expt(z1: SCM, z2: SCM) -> SCM;
4455 pub fn scm_sin(z: SCM) -> SCM;
4456 pub fn scm_cos(z: SCM) -> SCM;
4457 pub fn scm_tan(z: SCM) -> SCM;
4458 pub fn scm_sinh(z: SCM) -> SCM;
4459 pub fn scm_cosh(z: SCM) -> SCM;
4460 pub fn scm_tanh(z: SCM) -> SCM;
4461 pub fn scm_asin(z: SCM) -> SCM;
4462 pub fn scm_acos(z: SCM) -> SCM;
4463 pub fn scm_atan(x: SCM, y: SCM) -> SCM;
4464 pub fn scm_sys_asinh(z: SCM) -> SCM;
4465 pub fn scm_sys_acosh(z: SCM) -> SCM;
4466 pub fn scm_sys_atanh(z: SCM) -> SCM;
4467 pub fn scm_make_rectangular(z1: SCM, z2: SCM) -> SCM;
4468 pub fn scm_make_polar(z1: SCM, z2: SCM) -> SCM;
4469 pub fn scm_real_part(z: SCM) -> SCM;
4470 pub fn scm_imag_part(z: SCM) -> SCM;
4471 pub fn scm_magnitude(z: SCM) -> SCM;
4472 pub fn scm_angle(z: SCM) -> SCM;
4473 pub fn scm_exact_to_inexact(z: SCM) -> SCM;
4474 pub fn scm_inexact_to_exact(z: SCM) -> SCM;
4475 pub fn scm_trunc(x: SCM) -> SCM;
4476 pub fn scm_log(z: SCM) -> SCM;
4477 pub fn scm_log10(z: SCM) -> SCM;
4478 pub fn scm_exp(z: SCM) -> SCM;
4479 pub fn scm_sqrt(z: SCM) -> SCM;
4480 pub fn scm_exact_integer_sqrt(k: SCM, s: *mut SCM, r: *mut SCM);
4481 pub fn scm_i_min(x: SCM, y: SCM, rest: SCM) -> SCM;
4482 pub fn scm_i_max(x: SCM, y: SCM, rest: SCM) -> SCM;
4483 pub fn scm_i_sum(x: SCM, y: SCM, rest: SCM) -> SCM;
4484 pub fn scm_i_difference(x: SCM, y: SCM, rest: SCM) -> SCM;
4485 pub fn scm_i_product(x: SCM, y: SCM, rest: SCM) -> SCM;
4486 pub fn scm_i_divide(x: SCM, y: SCM, rest: SCM) -> SCM;
4487 pub fn scm_i_exact_integer_sqrt(k: SCM) -> SCM;
4488 pub fn scm_i_mkbig() -> SCM;
4489 pub fn scm_i_normbig(x: SCM) -> SCM;
4490 pub fn scm_i_bigcmp(a: SCM, b: SCM) -> c_int;
4491 pub fn scm_i_dbl2big(d: c_double) -> SCM;
4492 pub fn scm_i_dbl2num(d: c_double) -> SCM;
4493 pub fn scm_i_big2dbl(b: SCM) -> c_double;
4494 pub fn scm_i_long2big(n: c_long) -> SCM;
4495 pub fn scm_i_ulong2big(n: c_ulong) -> SCM;
4496 pub fn scm_i_clonebig(src_big: SCM, same_sign_p: c_int)
4497 -> SCM;
4498 pub fn scm_rationalize(x: SCM, err: SCM) -> SCM;
4499 pub fn scm_numerator(z: SCM) -> SCM;
4500 pub fn scm_denominator(z: SCM) -> SCM;
4501 pub fn scm_i_fraction2double(z: SCM) -> c_double;
4502 pub fn scm_i_fraction_equalp(x: SCM, y: SCM) -> SCM;
4503 pub fn scm_i_print_fraction(sexp: SCM, port: SCM,
4504 pstate: *mut scm_print_state)
4505 -> c_int;
4506 pub fn scm_i_print_double(val: c_double, port: SCM);
4507 pub fn scm_i_print_complex(real: c_double,
4508 imag: c_double, port: SCM);
4509 pub fn scm_is_integer(val: SCM) -> c_int;
4510 pub fn scm_is_exact_integer(val: SCM) -> c_int;
4511 pub fn scm_is_signed_integer(val: SCM, min: scm_t_intmax,
4512 max: scm_t_intmax) -> c_int;
4513 pub fn scm_is_unsigned_integer(val: SCM, min: scm_t_uintmax,
4514 max: scm_t_uintmax)
4515 -> c_int;
4516 pub fn scm_from_signed_integer(val: scm_t_intmax) -> SCM;
4517 pub fn scm_from_unsigned_integer(val: scm_t_uintmax) -> SCM;
4518 pub fn scm_to_signed_integer(val: SCM, min: scm_t_intmax,
4519 max: scm_t_intmax) -> scm_t_intmax;
4520 pub fn scm_to_unsigned_integer(val: SCM, min: scm_t_uintmax,
4521 max: scm_t_uintmax) -> scm_t_uintmax;
4522 pub fn scm_to_int8(x: SCM) -> scm_t_int8;
4523 pub fn scm_from_int8(x: scm_t_int8) -> SCM;
4524 pub fn scm_to_uint8(x: SCM) -> scm_t_uint8;
4525 pub fn scm_from_uint8(x: scm_t_uint8) -> SCM;
4526 pub fn scm_to_int16(x: SCM) -> scm_t_int16;
4527 pub fn scm_from_int16(x: scm_t_int16) -> SCM;
4528 pub fn scm_to_uint16(x: SCM) -> scm_t_uint16;
4529 pub fn scm_from_uint16(x: scm_t_uint16) -> SCM;
4530 pub fn scm_to_int32(x: SCM) -> scm_t_int32;
4531 pub fn scm_from_int32(x: scm_t_int32) -> SCM;
4532 pub fn scm_to_uint32(x: SCM) -> scm_t_uint32;
4533 pub fn scm_from_uint32(x: scm_t_uint32) -> SCM;
4534 pub fn scm_to_wchar(x: SCM) -> scm_t_wchar;
4535 pub fn scm_from_wchar(x: scm_t_wchar) -> SCM;
4536 pub fn scm_to_int64(x: SCM) -> scm_t_int64;
4537 pub fn scm_from_int64(x: scm_t_int64) -> SCM;
4538 pub fn scm_to_uint64(x: SCM) -> scm_t_uint64;
4539 pub fn scm_from_uint64(x: scm_t_uint64) -> SCM;
4540 pub fn scm_to_mpz(x: SCM, rop: mpz_t);
4541 pub fn scm_from_mpz(rop: mpz_t) -> SCM;
4542 pub fn scm_is_real(val: SCM) -> c_int;
4543 pub fn scm_is_rational(val: SCM) -> c_int;
4544 pub fn scm_to_double(val: SCM) -> c_double;
4545 pub fn scm_from_double(val: c_double) -> SCM;
4546 pub fn scm_is_complex(val: SCM) -> c_int;
4547 pub fn scm_c_make_rectangular(re: c_double,
4548 im: c_double) -> SCM;
4549 pub fn scm_c_make_polar(mag: c_double,
4550 ang: c_double) -> SCM;
4551 pub fn scm_c_real_part(z: SCM) -> c_double;
4552 pub fn scm_c_imag_part(z: SCM) -> c_double;
4553 pub fn scm_c_magnitude(z: SCM) -> c_double;
4554 pub fn scm_c_angle(z: SCM) -> c_double;
4555 pub fn scm_is_number(val: SCM) -> c_int;
4556 pub fn scm_init_numbers();
4557 pub fn scm_i_register_array_implementation(_impl:
4558 *mut scm_t_array_implementation);
4559 pub fn scm_i_array_implementation_for_obj(obj: SCM)
4560 -> *mut scm_t_array_implementation;
4561 pub fn scm_array_get_handle(array: SCM, h: *mut scm_t_array_handle);
4562 pub fn scm_array_handle_pos(h: *mut scm_t_array_handle, indices: SCM)
4563 -> ssize_t;
4564 pub fn scm_array_handle_pos_1(h: *mut scm_t_array_handle, idx0: ssize_t)
4565 -> ssize_t;
4566 pub fn scm_array_handle_pos_2(h: *mut scm_t_array_handle, idx0: ssize_t,
4567 idx1: ssize_t) -> ssize_t;
4568 pub fn scm_array_handle_element_type(h: *mut scm_t_array_handle) -> SCM;
4569 pub fn scm_array_handle_release(h: *mut scm_t_array_handle);
4570 pub fn scm_array_handle_elements(h: *mut scm_t_array_handle)
4571 -> *const SCM;
4572 pub fn scm_array_handle_writable_elements(h: *mut scm_t_array_handle)
4573 -> *mut SCM;
4574 pub fn scm_array_handle_ref(h: *mut scm_t_array_handle, p: ssize_t)
4575 -> SCM;
4576 pub fn scm_array_handle_set(h: *mut scm_t_array_handle, p: ssize_t,
4577 v: SCM);
4578 pub fn scm_init_array_handle();
4579 pub fn scm_ra_matchp(ra0: SCM, ras: SCM) -> c_int;
4580 pub fn scm_ramapc(cproc: *mut c_void, data: SCM, ra0: SCM,
4581 lra: SCM, what: *const c_char)
4582 -> c_int;
4583 pub fn scm_array_fill_x(ra: SCM, fill: SCM) -> SCM;
4584 pub fn scm_array_copy_x(src: SCM, dst: SCM) -> SCM;
4585 pub fn scm_array_map_x(ra0: SCM, _proc: SCM, lra: SCM) -> SCM;
4586 pub fn scm_array_for_each(_proc: SCM, ra0: SCM, lra: SCM) -> SCM;
4587 pub fn scm_array_index_map_x(ra: SCM, _proc: SCM) -> SCM;
4588 pub fn scm_array_equal_p(ra0: SCM, ra1: SCM) -> SCM;
4589 pub fn scm_init_array_map();
4590 pub fn scm_array_fill_int(ra: SCM, fill: SCM, ignore: SCM)
4591 -> c_int;
4592 pub fn scm_ra_eqp(ra0: SCM, ras: SCM) -> c_int;
4593 pub fn scm_ra_lessp(ra0: SCM, ras: SCM) -> c_int;
4594 pub fn scm_ra_leqp(ra0: SCM, ras: SCM) -> c_int;
4595 pub fn scm_ra_grp(ra0: SCM, ras: SCM) -> c_int;
4596 pub fn scm_ra_greqp(ra0: SCM, ras: SCM) -> c_int;
4597 pub fn scm_ra_sum(ra0: SCM, ras: SCM) -> c_int;
4598 pub fn scm_ra_difference(ra0: SCM, ras: SCM) -> c_int;
4599 pub fn scm_ra_product(ra0: SCM, ras: SCM) -> c_int;
4600 pub fn scm_ra_divide(ra0: SCM, ras: SCM) -> c_int;
4601 pub fn scm_array_identity(src: SCM, dst: SCM) -> c_int;
4602 pub fn scm_make_array(fill: SCM, bounds: SCM) -> SCM;
4603 pub fn scm_from_contiguous_array(bounds: SCM, elts: *const SCM,
4604 len: size_t) -> SCM;
4605 pub fn scm_make_typed_array(_type: SCM, fill: SCM, bounds: SCM) -> SCM;
4606 pub fn scm_from_contiguous_typed_array(_type: SCM, bounds: SCM,
4607 bytes:
4608 *const c_void,
4609 byte_len: size_t) -> SCM;
4610 pub fn scm_shared_array_root(ra: SCM) -> SCM;
4611 pub fn scm_shared_array_offset(ra: SCM) -> SCM;
4612 pub fn scm_shared_array_increments(ra: SCM) -> SCM;
4613 pub fn scm_make_shared_array(oldra: SCM, mapfunc: SCM, dims: SCM) -> SCM;
4614 pub fn scm_transpose_array(ra: SCM, args: SCM) -> SCM;
4615 pub fn scm_array_contents(ra: SCM, strict: SCM) -> SCM;
4616 pub fn scm_list_to_array(ndim: SCM, lst: SCM) -> SCM;
4617 pub fn scm_list_to_typed_array(_type: SCM, ndim: SCM, lst: SCM) -> SCM;
4618 pub fn scm_i_make_array(ndim: c_int) -> SCM;
4619 pub fn scm_i_print_array(array: SCM, port: SCM,
4620 pstate: *mut scm_print_state)
4621 -> c_int;
4622 pub fn scm_init_arrays();
4623 pub fn scm_local_eval(exp: SCM, env: SCM) -> SCM;
4624 pub fn scm_reverse_lookup(env: SCM, data: SCM) -> SCM;
4625 pub fn scm_procedure_source(_proc: SCM) -> SCM;
4626 pub fn scm_procedure_name(_proc: SCM) -> SCM;
4627 pub fn scm_debug_options(setting: SCM) -> SCM;
4628 pub fn scm_init_debug();
4629 pub fn scm_c_catch(tag: SCM, body: scm_t_catch_body,
4630 body_data: *mut c_void,
4631 handler: scm_t_catch_handler,
4632 handler_data: *mut c_void,
4633 pre_unwind_handler: scm_t_catch_handler,
4634 pre_unwind_handler_data: *mut c_void)
4635 -> SCM;
4636 pub fn scm_c_with_throw_handler(tag: SCM, body: scm_t_catch_body,
4637 body_data: *mut c_void,
4638 handler: scm_t_catch_handler,
4639 handler_data: *mut c_void,
4640 lazy_catch_p: c_int)
4641 -> SCM;
4642 pub fn scm_internal_catch(tag: SCM, body: scm_t_catch_body,
4643 body_data: *mut c_void,
4644 handler: scm_t_catch_handler,
4645 handler_data: *mut c_void)
4646 -> SCM;
4647 pub fn scm_body_thunk(arg1: *mut c_void) -> SCM;
4648 pub fn scm_handle_by_proc(arg1: *mut c_void, arg2: SCM,
4649 arg3: SCM) -> SCM;
4650 pub fn scm_handle_by_proc_catching_all(arg1: *mut c_void,
4651 arg2: SCM, arg3: SCM) -> SCM;
4652 pub fn scm_handle_by_message(arg1: *mut c_void, arg2: SCM,
4653 arg3: SCM) -> SCM;
4654 pub fn scm_handle_by_message_noexit(arg1: *mut c_void,
4655 arg2: SCM, arg3: SCM) -> SCM;
4656 pub fn scm_handle_by_throw(arg1: *mut c_void, arg2: SCM,
4657 arg3: SCM) -> SCM;
4658 pub fn scm_exit_status(args: SCM) -> c_int;
4659 pub fn scm_catch_with_pre_unwind_handler(tag: SCM, thunk: SCM,
4660 handler: SCM, lazy_handler: SCM)
4661 -> SCM;
4662 pub fn scm_catch(tag: SCM, thunk: SCM, handler: SCM) -> SCM;
4663 pub fn scm_with_throw_handler(tag: SCM, thunk: SCM, handler: SCM) -> SCM;
4664 pub fn scm_ithrow(key: SCM, args: SCM, no_return: c_int)
4665 -> SCM;
4666 pub fn scm_throw(key: SCM, args: SCM) -> SCM;
4667 pub fn scm_init_throw();
4668 pub fn scm_internal_cwdr(body: scm_t_catch_body,
4669 body_data: *mut c_void,
4670 handler: scm_t_catch_handler,
4671 handler_data: *mut c_void,
4672 stack_start: *mut SCM_STACKITEM) -> SCM;
4673 pub fn scm_call_with_dynamic_root(thunk: SCM, handler: SCM) -> SCM;
4674 pub fn scm_dynamic_root() -> SCM;
4675 pub fn scm_apply_with_dynamic_root(_proc: SCM, a1: SCM, args: SCM,
4676 handler: SCM) -> SCM;
4677 pub fn scm_init_root();
4678 pub fn scm_procedure_p(obj: SCM) -> SCM;
4679 pub fn scm_thunk_p(obj: SCM) -> SCM;
4680 pub fn scm_procedure_documentation(_proc: SCM) -> SCM;
4681 pub fn scm_procedure_with_setter_p(obj: SCM) -> SCM;
4682 pub fn scm_make_procedure_with_setter(procedure: SCM, setter: SCM) -> SCM;
4683 pub fn scm_procedure(_proc: SCM) -> SCM;
4684 pub fn scm_setter(_proc: SCM) -> SCM;
4685 pub fn scm_init_procs();
4686 pub fn scm_std_select(fds: c_int, rfds: *mut fd_set,
4687 wfds: *mut fd_set, efds: *mut fd_set,
4688 timeout: *mut Struct_timeval)
4689 -> c_int;
4690 pub fn scm_dynamic_wind(thunk1: SCM, thunk2: SCM, thunk3: SCM) -> SCM;
4691 pub fn scm_dowinds(to: SCM, delta: c_long);
4692 pub fn scm_i_dowinds(to: SCM, delta: c_long,
4693 turn_func:
4694 ::std::option::Option<unsafe extern "C" fn(arg1:
4695 *mut c_void)>,
4696 data: *mut c_void);
4697 pub fn scm_init_dynwind();
4698 pub fn scm_swap_bindings(vars: SCM, vals: SCM);
4699 pub fn scm_dynwind_begin(arg1: scm_t_dynwind_flags);
4700 pub fn scm_dynwind_end();
4701 pub fn scm_dynwind_unwind_handler(func:
4702 ::std::option::Option<unsafe extern "C" fn(arg1:
4703 *mut c_void)>,
4704 data: *mut c_void,
4705 arg1: scm_t_wind_flags);
4706 pub fn scm_dynwind_rewind_handler(func:
4707 ::std::option::Option<unsafe extern "C" fn(arg1:
4708 *mut c_void)>,
4709 data: *mut c_void,
4710 arg1: scm_t_wind_flags);
4711 pub fn scm_dynwind_unwind_handler_with_scm(func:
4712 ::std::option::Option<extern "C" fn(arg1:
4713 SCM)>,
4714 data: SCM,
4715 arg1: scm_t_wind_flags);
4716 pub fn scm_dynwind_rewind_handler_with_scm(func:
4717 ::std::option::Option<extern "C" fn(arg1:
4718 SCM)>,
4719 data: SCM,
4720 arg1: scm_t_wind_flags);
4721 pub fn scm_dynwind_free(mem: *mut c_void);
4722 pub fn scm_i_make_continuation(first: *mut c_int, vm: SCM,
4723 vm_cont: SCM) -> SCM;
4724 pub fn scm_i_check_continuation(cont: SCM);
4725 pub fn scm_i_reinstate_continuation(cont: SCM);
4726 pub fn scm_i_call_with_current_continuation(_proc: SCM) -> SCM;
4727 pub fn scm_i_continuation_to_frame(cont: SCM) -> SCM;
4728 pub fn scm_i_contregs_vm(contregs: SCM) -> SCM;
4729 pub fn scm_i_contregs_vm_cont(contregs: SCM) -> SCM;
4730 pub fn scm_c_with_continuation_barrier(func:
4731 ::std::option::Option<unsafe extern "C" fn(arg1:
4732 *mut c_void)
4733 ->
4734 *mut c_void>,
4735 arg1: *mut c_void)
4736 -> *mut c_void;
4737 pub fn scm_with_continuation_barrier(_proc: SCM) -> SCM;
4738 pub fn scm_i_with_continuation_barrier(body: scm_t_catch_body,
4739 body_data:
4740 *mut c_void,
4741 handler: scm_t_catch_handler,
4742 handler_data:
4743 *mut c_void,
4744 pre_unwind_handler:
4745 scm_t_catch_handler,
4746 pre_unwind_handler_data:
4747 *mut c_void)
4748 -> SCM;
4749 pub fn scm_init_continuations();
4750 pub fn __sched_cpucount(__setsize: size_t, __setp: *const cpu_set_t)
4751 -> c_int;
4752 pub fn __sched_cpualloc(__count: size_t) -> *mut cpu_set_t;
4753 pub fn __sched_cpufree(__set: *mut cpu_set_t);
4754 pub fn sched_setparam(__pid: __pid_t, __param: *const Struct_sched_param)
4755 -> c_int;
4756 pub fn sched_getparam(__pid: __pid_t, __param: *mut Struct_sched_param)
4757 -> c_int;
4758 pub fn sched_setscheduler(__pid: __pid_t, __policy: c_int,
4759 __param: *const Struct_sched_param)
4760 -> c_int;
4761 pub fn sched_getscheduler(__pid: __pid_t) -> c_int;
4762 pub fn sched_yield() -> c_int;
4763 pub fn sched_get_priority_max(__algorithm: c_int)
4764 -> c_int;
4765 pub fn sched_get_priority_min(__algorithm: c_int)
4766 -> c_int;
4767 pub fn sched_rr_get_interval(__pid: __pid_t, __t: *mut Struct_timespec)
4768 -> c_int;
4769 pub fn pthread_create(__newthread: *mut pthread_t,
4770 __attr: *const pthread_attr_t,
4771 __start_routine:
4772 ::std::option::Option<unsafe extern "C" fn(arg1:
4773 *mut c_void)
4774 ->
4775 *mut c_void>,
4776 __arg: *mut c_void)
4777 -> c_int;
4778 pub fn pthread_exit(__retval: *mut c_void);
4779 pub fn pthread_join(__th: pthread_t,
4780 __thread_return: *mut *mut c_void)
4781 -> c_int;
4782 pub fn pthread_detach(__th: pthread_t) -> c_int;
4783 pub fn pthread_self() -> pthread_t;
4784 pub fn pthread_equal(__thread1: pthread_t, __thread2: pthread_t)
4785 -> c_int;
4786 pub fn pthread_attr_init(__attr: *mut pthread_attr_t)
4787 -> c_int;
4788 pub fn pthread_attr_destroy(__attr: *mut pthread_attr_t)
4789 -> c_int;
4790 pub fn pthread_attr_getdetachstate(__attr: *const pthread_attr_t,
4791 __detachstate:
4792 *mut c_int)
4793 -> c_int;
4794 pub fn pthread_attr_setdetachstate(__attr: *mut pthread_attr_t,
4795 __detachstate: c_int)
4796 -> c_int;
4797 pub fn pthread_attr_getguardsize(__attr: *const pthread_attr_t,
4798 __guardsize: *mut size_t)
4799 -> c_int;
4800 pub fn pthread_attr_setguardsize(__attr: *mut pthread_attr_t,
4801 __guardsize: size_t)
4802 -> c_int;
4803 pub fn pthread_attr_getschedparam(__attr: *const pthread_attr_t,
4804 __param: *mut Struct_sched_param)
4805 -> c_int;
4806 pub fn pthread_attr_setschedparam(__attr: *mut pthread_attr_t,
4807 __param: *const Struct_sched_param)
4808 -> c_int;
4809 pub fn pthread_attr_getschedpolicy(__attr: *const pthread_attr_t,
4810 __policy: *mut c_int)
4811 -> c_int;
4812 pub fn pthread_attr_setschedpolicy(__attr: *mut pthread_attr_t,
4813 __policy: c_int)
4814 -> c_int;
4815 pub fn pthread_attr_getinheritsched(__attr: *const pthread_attr_t,
4816 __inherit: *mut c_int)
4817 -> c_int;
4818 pub fn pthread_attr_setinheritsched(__attr: *mut pthread_attr_t,
4819 __inherit: c_int)
4820 -> c_int;
4821 pub fn pthread_attr_getscope(__attr: *const pthread_attr_t,
4822 __scope: *mut c_int)
4823 -> c_int;
4824 pub fn pthread_attr_setscope(__attr: *mut pthread_attr_t,
4825 __scope: c_int)
4826 -> c_int;
4827 pub fn pthread_attr_getstackaddr(__attr: *const pthread_attr_t,
4828 __stackaddr:
4829 *mut *mut c_void)
4830 -> c_int;
4831 pub fn pthread_attr_setstackaddr(__attr: *mut pthread_attr_t,
4832 __stackaddr: *mut c_void)
4833 -> c_int;
4834 pub fn pthread_attr_getstacksize(__attr: *const pthread_attr_t,
4835 __stacksize: *mut size_t)
4836 -> c_int;
4837 pub fn pthread_attr_setstacksize(__attr: *mut pthread_attr_t,
4838 __stacksize: size_t)
4839 -> c_int;
4840 pub fn pthread_attr_getstack(__attr: *const pthread_attr_t,
4841 __stackaddr:
4842 *mut *mut c_void,
4843 __stacksize: *mut size_t)
4844 -> c_int;
4845 pub fn pthread_attr_setstack(__attr: *mut pthread_attr_t,
4846 __stackaddr: *mut c_void,
4847 __stacksize: size_t)
4848 -> c_int;
4849 pub fn pthread_setschedparam(__target_thread: pthread_t,
4850 __policy: c_int,
4851 __param: *const Struct_sched_param)
4852 -> c_int;
4853 pub fn pthread_getschedparam(__target_thread: pthread_t,
4854 __policy: *mut c_int,
4855 __param: *mut Struct_sched_param)
4856 -> c_int;
4857 pub fn pthread_setschedprio(__target_thread: pthread_t,
4858 __prio: c_int)
4859 -> c_int;
4860 pub fn pthread_once(__once_control: *mut pthread_once_t,
4861 __init_routine:
4862 ::std::option::Option<extern "C" fn()>)
4863 -> c_int;
4864 pub fn pthread_setcancelstate(__state: c_int,
4865 __oldstate: *mut c_int)
4866 -> c_int;
4867 pub fn pthread_setcanceltype(__type: c_int,
4868 __oldtype: *mut c_int)
4869 -> c_int;
4870 pub fn pthread_cancel(__th: pthread_t) -> c_int;
4871 pub fn pthread_testcancel();
4872 pub fn __pthread_register_cancel(__buf: *mut __pthread_unwind_buf_t);
4873 pub fn __pthread_unregister_cancel(__buf: *mut __pthread_unwind_buf_t);
4874 pub fn __pthread_unwind_next(__buf: *mut __pthread_unwind_buf_t);
4875 pub fn pthread_mutex_init(__mutex: *mut pthread_mutex_t,
4876 __mutexattr: *const pthread_mutexattr_t)
4877 -> c_int;
4878 pub fn pthread_mutex_destroy(__mutex: *mut pthread_mutex_t)
4879 -> c_int;
4880 pub fn pthread_mutex_trylock(__mutex: *mut pthread_mutex_t)
4881 -> c_int;
4882 pub fn pthread_mutex_lock(__mutex: *mut pthread_mutex_t)
4883 -> c_int;
4884 pub fn pthread_mutex_timedlock(__mutex: *mut pthread_mutex_t,
4885 __abstime: *const Struct_timespec)
4886 -> c_int;
4887 pub fn pthread_mutex_unlock(__mutex: *mut pthread_mutex_t)
4888 -> c_int;
4889 pub fn pthread_mutex_getprioceiling(__mutex: *const pthread_mutex_t,
4890 __prioceiling:
4891 *mut c_int)
4892 -> c_int;
4893 pub fn pthread_mutex_setprioceiling(__mutex: *mut pthread_mutex_t,
4894 __prioceiling: c_int,
4895 __old_ceiling:
4896 *mut c_int)
4897 -> c_int;
4898 pub fn pthread_mutex_consistent(__mutex: *mut pthread_mutex_t)
4899 -> c_int;
4900 pub fn pthread_mutexattr_init(__attr: *mut pthread_mutexattr_t)
4901 -> c_int;
4902 pub fn pthread_mutexattr_destroy(__attr: *mut pthread_mutexattr_t)
4903 -> c_int;
4904 pub fn pthread_mutexattr_getpshared(__attr: *const pthread_mutexattr_t,
4905 __pshared: *mut c_int)
4906 -> c_int;
4907 pub fn pthread_mutexattr_setpshared(__attr: *mut pthread_mutexattr_t,
4908 __pshared: c_int)
4909 -> c_int;
4910 pub fn pthread_mutexattr_gettype(__attr: *const pthread_mutexattr_t,
4911 __kind: *mut c_int)
4912 -> c_int;
4913 pub fn pthread_mutexattr_settype(__attr: *mut pthread_mutexattr_t,
4914 __kind: c_int)
4915 -> c_int;
4916 pub fn pthread_mutexattr_getprotocol(__attr: *const pthread_mutexattr_t,
4917 __protocol:
4918 *mut c_int)
4919 -> c_int;
4920 pub fn pthread_mutexattr_setprotocol(__attr: *mut pthread_mutexattr_t,
4921 __protocol: c_int)
4922 -> c_int;
4923 pub fn pthread_mutexattr_getprioceiling(__attr:
4924 *const pthread_mutexattr_t,
4925 __prioceiling:
4926 *mut c_int)
4927 -> c_int;
4928 pub fn pthread_mutexattr_setprioceiling(__attr: *mut pthread_mutexattr_t,
4929 __prioceiling:
4930 c_int)
4931 -> c_int;
4932 pub fn pthread_mutexattr_getrobust(__attr: *const pthread_mutexattr_t,
4933 __robustness:
4934 *mut c_int)
4935 -> c_int;
4936 pub fn pthread_mutexattr_setrobust(__attr: *mut pthread_mutexattr_t,
4937 __robustness: c_int)
4938 -> c_int;
4939 pub fn pthread_rwlock_init(__rwlock: *mut pthread_rwlock_t,
4940 __attr: *const pthread_rwlockattr_t)
4941 -> c_int;
4942 pub fn pthread_rwlock_destroy(__rwlock: *mut pthread_rwlock_t)
4943 -> c_int;
4944 pub fn pthread_rwlock_rdlock(__rwlock: *mut pthread_rwlock_t)
4945 -> c_int;
4946 pub fn pthread_rwlock_tryrdlock(__rwlock: *mut pthread_rwlock_t)
4947 -> c_int;
4948 pub fn pthread_rwlock_timedrdlock(__rwlock: *mut pthread_rwlock_t,
4949 __abstime: *const Struct_timespec)
4950 -> c_int;
4951 pub fn pthread_rwlock_wrlock(__rwlock: *mut pthread_rwlock_t)
4952 -> c_int;
4953 pub fn pthread_rwlock_trywrlock(__rwlock: *mut pthread_rwlock_t)
4954 -> c_int;
4955 pub fn pthread_rwlock_timedwrlock(__rwlock: *mut pthread_rwlock_t,
4956 __abstime: *const Struct_timespec)
4957 -> c_int;
4958 pub fn pthread_rwlock_unlock(__rwlock: *mut pthread_rwlock_t)
4959 -> c_int;
4960 pub fn pthread_rwlockattr_init(__attr: *mut pthread_rwlockattr_t)
4961 -> c_int;
4962 pub fn pthread_rwlockattr_destroy(__attr: *mut pthread_rwlockattr_t)
4963 -> c_int;
4964 pub fn pthread_rwlockattr_getpshared(__attr: *const pthread_rwlockattr_t,
4965 __pshared:
4966 *mut c_int)
4967 -> c_int;
4968 pub fn pthread_rwlockattr_setpshared(__attr: *mut pthread_rwlockattr_t,
4969 __pshared: c_int)
4970 -> c_int;
4971 pub fn pthread_rwlockattr_getkind_np(__attr: *const pthread_rwlockattr_t,
4972 __pref: *mut c_int)
4973 -> c_int;
4974 pub fn pthread_rwlockattr_setkind_np(__attr: *mut pthread_rwlockattr_t,
4975 __pref: c_int)
4976 -> c_int;
4977 pub fn pthread_cond_init(__cond: *mut pthread_cond_t,
4978 __cond_attr: *const pthread_condattr_t)
4979 -> c_int;
4980 pub fn pthread_cond_destroy(__cond: *mut pthread_cond_t)
4981 -> c_int;
4982 pub fn pthread_cond_signal(__cond: *mut pthread_cond_t)
4983 -> c_int;
4984 pub fn pthread_cond_broadcast(__cond: *mut pthread_cond_t)
4985 -> c_int;
4986 pub fn pthread_cond_wait(__cond: *mut pthread_cond_t,
4987 __mutex: *mut pthread_mutex_t)
4988 -> c_int;
4989 pub fn pthread_cond_timedwait(__cond: *mut pthread_cond_t,
4990 __mutex: *mut pthread_mutex_t,
4991 __abstime: *const Struct_timespec)
4992 -> c_int;
4993 pub fn pthread_condattr_init(__attr: *mut pthread_condattr_t)
4994 -> c_int;
4995 pub fn pthread_condattr_destroy(__attr: *mut pthread_condattr_t)
4996 -> c_int;
4997 pub fn pthread_condattr_getpshared(__attr: *const pthread_condattr_t,
4998 __pshared: *mut c_int)
4999 -> c_int;
5000 pub fn pthread_condattr_setpshared(__attr: *mut pthread_condattr_t,
5001 __pshared: c_int)
5002 -> c_int;
5003 pub fn pthread_condattr_getclock(__attr: *const pthread_condattr_t,
5004 __clock_id: *mut __clockid_t)
5005 -> c_int;
5006 pub fn pthread_condattr_setclock(__attr: *mut pthread_condattr_t,
5007 __clock_id: __clockid_t)
5008 -> c_int;
5009 pub fn pthread_spin_init(__lock: *mut pthread_spinlock_t,
5010 __pshared: c_int)
5011 -> c_int;
5012 pub fn pthread_spin_destroy(__lock: *mut pthread_spinlock_t)
5013 -> c_int;
5014 pub fn pthread_spin_lock(__lock: *mut pthread_spinlock_t)
5015 -> c_int;
5016 pub fn pthread_spin_trylock(__lock: *mut pthread_spinlock_t)
5017 -> c_int;
5018 pub fn pthread_spin_unlock(__lock: *mut pthread_spinlock_t)
5019 -> c_int;
5020 pub fn pthread_barrier_init(__barrier: *mut pthread_barrier_t,
5021 __attr: *const pthread_barrierattr_t,
5022 __count: c_uint)
5023 -> c_int;
5024 pub fn pthread_barrier_destroy(__barrier: *mut pthread_barrier_t)
5025 -> c_int;
5026 pub fn pthread_barrier_wait(__barrier: *mut pthread_barrier_t)
5027 -> c_int;
5028 pub fn pthread_barrierattr_init(__attr: *mut pthread_barrierattr_t)
5029 -> c_int;
5030 pub fn pthread_barrierattr_destroy(__attr: *mut pthread_barrierattr_t)
5031 -> c_int;
5032 pub fn pthread_barrierattr_getpshared(__attr:
5033 *const pthread_barrierattr_t,
5034 __pshared:
5035 *mut c_int)
5036 -> c_int;
5037 pub fn pthread_barrierattr_setpshared(__attr: *mut pthread_barrierattr_t,
5038 __pshared: c_int)
5039 -> c_int;
5040 pub fn pthread_key_create(__key: *mut pthread_key_t,
5041 __destr_function:
5042 ::std::option::Option<unsafe extern "C" fn(arg1:
5043 *mut c_void)>)
5044 -> c_int;
5045 pub fn pthread_key_delete(__key: pthread_key_t) -> c_int;
5046 pub fn pthread_getspecific(__key: pthread_key_t)
5047 -> *mut c_void;
5048 pub fn pthread_setspecific(__key: pthread_key_t,
5049 __pointer: *const c_void)
5050 -> c_int;
5051 pub fn pthread_getcpuclockid(__thread_id: pthread_t,
5052 __clock_id: *mut __clockid_t)
5053 -> c_int;
5054 pub fn pthread_atfork(__prepare: ::std::option::Option<extern "C" fn()>,
5055 __parent: ::std::option::Option<extern "C" fn()>,
5056 __child: ::std::option::Option<extern "C" fn()>)
5057 -> c_int;
5058 pub fn GC_get_version() -> c_uint;
5059 pub fn GC_get_gc_no() -> GC_word;
5060 pub fn GC_get_parallel() -> c_int;
5061 pub fn GC_set_oom_fn(arg1: GC_oom_func);
5062 pub fn GC_get_oom_fn() -> GC_oom_func;
5063 pub fn GC_set_on_heap_resize(arg1: GC_on_heap_resize_proc);
5064 pub fn GC_get_on_heap_resize() -> GC_on_heap_resize_proc;
5065 pub fn GC_set_find_leak(arg1: c_int);
5066 pub fn GC_get_find_leak() -> c_int;
5067 pub fn GC_set_all_interior_pointers(arg1: c_int);
5068 pub fn GC_get_all_interior_pointers() -> c_int;
5069 pub fn GC_set_finalize_on_demand(arg1: c_int);
5070 pub fn GC_get_finalize_on_demand() -> c_int;
5071 pub fn GC_set_java_finalization(arg1: c_int);
5072 pub fn GC_get_java_finalization() -> c_int;
5073 pub fn GC_set_finalizer_notifier(arg1: GC_finalizer_notifier_proc);
5074 pub fn GC_get_finalizer_notifier() -> GC_finalizer_notifier_proc;
5075 pub fn GC_set_dont_expand(arg1: c_int);
5076 pub fn GC_get_dont_expand() -> c_int;
5077 pub fn GC_set_full_freq(arg1: c_int);
5078 pub fn GC_get_full_freq() -> c_int;
5079 pub fn GC_set_non_gc_bytes(arg1: GC_word);
5080 pub fn GC_get_non_gc_bytes() -> GC_word;
5081 pub fn GC_set_no_dls(arg1: c_int);
5082 pub fn GC_get_no_dls() -> c_int;
5083 pub fn GC_set_free_space_divisor(arg1: GC_word);
5084 pub fn GC_get_free_space_divisor() -> GC_word;
5085 pub fn GC_set_max_retries(arg1: GC_word);
5086 pub fn GC_get_max_retries() -> GC_word;
5087 pub fn GC_set_dont_precollect(arg1: c_int);
5088 pub fn GC_get_dont_precollect() -> c_int;
5089 pub fn GC_set_time_limit(arg1: c_ulong);
5090 pub fn GC_get_time_limit() -> c_ulong;
5091 pub fn GC_set_pages_executable(arg1: c_int);
5092 pub fn GC_get_pages_executable() -> c_int;
5093 pub fn GC_set_handle_fork(arg1: c_int);
5094 pub fn GC_atfork_prepare();
5095 pub fn GC_atfork_parent();
5096 pub fn GC_atfork_child();
5097 pub fn GC_init();
5098 pub fn GC_malloc(arg1: size_t) -> *mut c_void;
5099 pub fn GC_malloc_atomic(arg1: size_t) -> *mut c_void;
5100 pub fn GC_strdup(arg1: *const c_char)
5101 -> *mut c_char;
5102 pub fn GC_strndup(arg1: *const c_char, arg2: size_t)
5103 -> *mut c_char;
5104 pub fn GC_malloc_uncollectable(arg1: size_t)
5105 -> *mut c_void;
5106 pub fn GC_malloc_stubborn(arg1: size_t) -> *mut c_void;
5107 pub fn GC_memalign(arg1: size_t, arg2: size_t)
5108 -> *mut c_void;
5109 pub fn GC_posix_memalign(arg1: *mut *mut c_void,
5110 arg2: size_t, arg3: size_t)
5111 -> c_int;
5112 pub fn GC_free(arg1: *mut c_void);
5113 pub fn GC_change_stubborn(arg1: *const c_void);
5114 pub fn GC_end_stubborn_change(arg1: *const c_void);
5115 pub fn GC_base(arg1: *mut c_void)
5116 -> *mut c_void;
5117 pub fn GC_is_heap_ptr(arg1: *const c_void)
5118 -> c_int;
5119 pub fn GC_size(arg1: *const c_void) -> size_t;
5120 pub fn GC_realloc(arg1: *mut c_void, arg2: size_t)
5121 -> *mut c_void;
5122 pub fn GC_expand_hp(arg1: size_t) -> c_int;
5123 pub fn GC_set_max_heap_size(arg1: GC_word);
5124 pub fn GC_exclude_static_roots(arg1: *mut c_void,
5125 arg2: *mut c_void);
5126 pub fn GC_clear_roots();
5127 pub fn GC_add_roots(arg1: *mut c_void,
5128 arg2: *mut c_void);
5129 pub fn GC_remove_roots(arg1: *mut c_void,
5130 arg2: *mut c_void);
5131 pub fn GC_register_displacement(arg1: size_t);
5132 pub fn GC_debug_register_displacement(arg1: size_t);
5133 pub fn GC_gcollect();
5134 pub fn GC_gcollect_and_unmap();
5135 pub fn GC_try_to_collect(arg1: GC_stop_func) -> c_int;
5136 pub fn GC_set_stop_func(arg1: GC_stop_func);
5137 pub fn GC_get_stop_func() -> GC_stop_func;
5138 pub fn GC_get_heap_size() -> size_t;
5139 pub fn GC_get_free_bytes() -> size_t;
5140 pub fn GC_get_unmapped_bytes() -> size_t;
5141 pub fn GC_get_bytes_since_gc() -> size_t;
5142 pub fn GC_get_total_bytes() -> size_t;
5143 pub fn GC_get_heap_usage_safe(arg1: *mut GC_word, arg2: *mut GC_word,
5144 arg3: *mut GC_word, arg4: *mut GC_word,
5145 arg5: *mut GC_word);
5146 pub fn GC_get_prof_stats(arg1: *mut Struct_GC_prof_stats_s, arg2: size_t)
5147 -> size_t;
5148 pub fn GC_get_prof_stats_unsafe(arg1: *mut Struct_GC_prof_stats_s,
5149 arg2: size_t) -> size_t;
5150 pub fn GC_disable();
5151 pub fn GC_is_disabled() -> c_int;
5152 pub fn GC_enable();
5153 pub fn GC_enable_incremental();
5154 pub fn GC_incremental_protection_needs() -> c_int;
5155 pub fn GC_collect_a_little() -> c_int;
5156 pub fn GC_malloc_ignore_off_page(arg1: size_t)
5157 -> *mut c_void;
5158 pub fn GC_malloc_atomic_ignore_off_page(arg1: size_t)
5159 -> *mut c_void;
5160 pub fn GC_malloc_atomic_uncollectable(arg1: size_t)
5161 -> *mut c_void;
5162 pub fn GC_debug_malloc_atomic_uncollectable(arg1: size_t,
5163 s:
5164 *const c_char,
5165 i: c_int)
5166 -> *mut c_void;
5167 pub fn GC_debug_malloc(arg1: size_t, s: *const c_char,
5168 i: c_int)
5169 -> *mut c_void;
5170 pub fn GC_debug_malloc_atomic(arg1: size_t,
5171 s: *const c_char,
5172 i: c_int)
5173 -> *mut c_void;
5174 pub fn GC_debug_strdup(arg1: *const c_char,
5175 s: *const c_char,
5176 i: c_int)
5177 -> *mut c_char;
5178 pub fn GC_debug_strndup(arg1: *const c_char, arg2: size_t,
5179 s: *const c_char,
5180 i: c_int)
5181 -> *mut c_char;
5182 pub fn GC_debug_malloc_uncollectable(arg1: size_t,
5183 s: *const c_char,
5184 i: c_int)
5185 -> *mut c_void;
5186 pub fn GC_debug_malloc_stubborn(arg1: size_t,
5187 s: *const c_char,
5188 i: c_int)
5189 -> *mut c_void;
5190 pub fn GC_debug_malloc_ignore_off_page(arg1: size_t,
5191 s: *const c_char,
5192 i: c_int)
5193 -> *mut c_void;
5194 pub fn GC_debug_malloc_atomic_ignore_off_page(arg1: size_t,
5195 s:
5196 *const c_char,
5197 i: c_int)
5198 -> *mut c_void;
5199 pub fn GC_debug_free(arg1: *mut c_void);
5200 pub fn GC_debug_realloc(arg1: *mut c_void, arg2: size_t,
5201 s: *const c_char,
5202 i: c_int)
5203 -> *mut c_void;
5204 pub fn GC_debug_change_stubborn(arg1: *const c_void);
5205 pub fn GC_debug_end_stubborn_change(arg1: *const c_void);
5206 pub fn GC_debug_malloc_replacement(arg1: size_t)
5207 -> *mut c_void;
5208 pub fn GC_debug_realloc_replacement(arg1: *mut c_void,
5209 arg2: size_t)
5210 -> *mut c_void;
5211 pub fn GC_register_finalizer(arg1: *mut c_void,
5212 arg2: GC_finalization_proc,
5213 arg3: *mut c_void,
5214 arg4: *mut GC_finalization_proc,
5215 arg5: *mut *mut c_void);
5216 pub fn GC_debug_register_finalizer(arg1: *mut c_void,
5217 arg2: GC_finalization_proc,
5218 arg3: *mut c_void,
5219 arg4: *mut GC_finalization_proc,
5220 arg5:
5221 *mut *mut c_void);
5222 pub fn GC_register_finalizer_ignore_self(arg1:
5223 *mut c_void,
5224 arg2: GC_finalization_proc,
5225 arg3:
5226 *mut c_void,
5227 arg4: *mut GC_finalization_proc,
5228 arg5:
5229 *mut *mut c_void);
5230 pub fn GC_debug_register_finalizer_ignore_self(arg1:
5231 *mut c_void,
5232 arg2: GC_finalization_proc,
5233 arg3:
5234 *mut c_void,
5235 arg4:
5236 *mut GC_finalization_proc,
5237 arg5:
5238 *mut *mut c_void);
5239 pub fn GC_register_finalizer_no_order(arg1: *mut c_void,
5240 arg2: GC_finalization_proc,
5241 arg3: *mut c_void,
5242 arg4: *mut GC_finalization_proc,
5243 arg5:
5244 *mut *mut c_void);
5245 pub fn GC_debug_register_finalizer_no_order(arg1:
5246 *mut c_void,
5247 arg2: GC_finalization_proc,
5248 arg3:
5249 *mut c_void,
5250 arg4:
5251 *mut GC_finalization_proc,
5252 arg5:
5253 *mut *mut c_void);
5254 pub fn GC_register_finalizer_unreachable(arg1:
5255 *mut c_void,
5256 arg2: GC_finalization_proc,
5257 arg3:
5258 *mut c_void,
5259 arg4: *mut GC_finalization_proc,
5260 arg5:
5261 *mut *mut c_void);
5262 pub fn GC_debug_register_finalizer_unreachable(arg1:
5263 *mut c_void,
5264 arg2: GC_finalization_proc,
5265 arg3:
5266 *mut c_void,
5267 arg4:
5268 *mut GC_finalization_proc,
5269 arg5:
5270 *mut *mut c_void);
5271 pub fn GC_register_disappearing_link(arg1:
5272 *mut *mut c_void)
5273 -> c_int;
5274 pub fn GC_general_register_disappearing_link(arg1:
5275 *mut *mut c_void,
5276 arg2:
5277 *const c_void)
5278 -> c_int;
5279 pub fn GC_move_disappearing_link(arg1: *mut *mut c_void,
5280 arg2: *mut *mut c_void)
5281 -> c_int;
5282 pub fn GC_unregister_disappearing_link(arg1:
5283 *mut *mut c_void)
5284 -> c_int;
5285 pub fn GC_register_long_link(arg1: *mut *mut c_void,
5286 arg2: *const c_void)
5287 -> c_int;
5288 pub fn GC_move_long_link(arg1: *mut *mut c_void,
5289 arg2: *mut *mut c_void)
5290 -> c_int;
5291 pub fn GC_unregister_long_link(arg1: *mut *mut c_void)
5292 -> c_int;
5293 pub fn GC_should_invoke_finalizers() -> c_int;
5294 pub fn GC_invoke_finalizers() -> c_int;
5295 pub fn GC_set_warn_proc(arg1: GC_warn_proc);
5296 pub fn GC_get_warn_proc() -> GC_warn_proc;
5297 pub fn GC_ignore_warn_proc(arg1: *mut c_char,
5298 arg2: GC_word);
5299 pub fn GC_set_abort_func(arg1: GC_abort_func);
5300 pub fn GC_get_abort_func() -> GC_abort_func;
5301 pub fn GC_call_with_alloc_lock(arg1: GC_fn_type,
5302 arg2: *mut c_void)
5303 -> *mut c_void;
5304 pub fn GC_call_with_stack_base(arg1: GC_stack_base_func,
5305 arg2: *mut c_void)
5306 -> *mut c_void;
5307 pub fn GC_set_suspend_signal(arg1: c_int);
5308 pub fn GC_set_thr_restart_signal(arg1: c_int);
5309 pub fn GC_get_suspend_signal() -> c_int;
5310 pub fn GC_get_thr_restart_signal() -> c_int;
5311 pub fn GC_start_mark_threads();
5312 pub fn GC_allow_register_threads();
5313 pub fn GC_register_my_thread(arg1: *const Struct_GC_stack_base)
5314 -> c_int;
5315 pub fn GC_thread_is_registered() -> c_int;
5316 pub fn GC_unregister_my_thread() -> c_int;
5317 pub fn GC_do_blocking(arg1: GC_fn_type, arg2: *mut c_void)
5318 -> *mut c_void;
5319 pub fn GC_call_with_gc_active(arg1: GC_fn_type,
5320 arg2: *mut c_void)
5321 -> *mut c_void;
5322 pub fn GC_get_stack_base(arg1: *mut Struct_GC_stack_base)
5323 -> c_int;
5324 pub fn GC_same_obj(arg1: *mut c_void,
5325 arg2: *mut c_void)
5326 -> *mut c_void;
5327 pub fn GC_pre_incr(arg1: *mut *mut c_void,
5328 arg2: ptrdiff_t) -> *mut c_void;
5329 pub fn GC_post_incr(arg1: *mut *mut c_void,
5330 arg2: ptrdiff_t) -> *mut c_void;
5331 pub fn GC_is_visible(arg1: *mut c_void)
5332 -> *mut c_void;
5333 pub fn GC_is_valid_displacement(arg1: *mut c_void)
5334 -> *mut c_void;
5335 pub fn GC_dump();
5336 pub fn dlopen(__file: *const c_char,
5337 __mode: c_int)
5338 -> *mut c_void;
5339 pub fn dlclose(__handle: *mut c_void)
5340 -> c_int;
5341 pub fn dlsym(__handle: *mut c_void,
5342 __name: *const c_char)
5343 -> *mut c_void;
5344 pub fn dlerror() -> *mut c_char;
5345 pub fn GC_dlopen(arg1: *const c_char,
5346 arg2: c_int)
5347 -> *mut c_void;
5348 pub fn __sigismember(arg1: *const __sigset_t, arg2: c_int)
5349 -> c_int;
5350 pub fn __sigaddset(arg1: *mut __sigset_t, arg2: c_int)
5351 -> c_int;
5352 pub fn __sigdelset(arg1: *mut __sigset_t, arg2: c_int)
5353 -> c_int;
5354 pub fn __sysv_signal(__sig: c_int,
5355 __handler: __sighandler_t) -> __sighandler_t;
5356 pub fn signal(__sig: c_int, __handler: __sighandler_t)
5357 -> __sighandler_t;
5358 pub fn kill(__pid: __pid_t, __sig: c_int)
5359 -> c_int;
5360 pub fn killpg(__pgrp: __pid_t, __sig: c_int)
5361 -> c_int;
5362 pub fn raise(__sig: c_int) -> c_int;
5363 pub fn ssignal(__sig: c_int, __handler: __sighandler_t)
5364 -> __sighandler_t;
5365 pub fn gsignal(__sig: c_int) -> c_int;
5366 pub fn psignal(__sig: c_int,
5367 __s: *const c_char);
5368 pub fn psiginfo(__pinfo: *const siginfo_t,
5369 __s: *const c_char);
5370 pub fn sigblock(__mask: c_int) -> c_int;
5371 pub fn sigsetmask(__mask: c_int) -> c_int;
5372 pub fn siggetmask() -> c_int;
5373 pub fn sigemptyset(__set: *mut sigset_t) -> c_int;
5374 pub fn sigfillset(__set: *mut sigset_t) -> c_int;
5375 pub fn sigaddset(__set: *mut sigset_t, __signo: c_int)
5376 -> c_int;
5377 pub fn sigdelset(__set: *mut sigset_t, __signo: c_int)
5378 -> c_int;
5379 pub fn sigismember(__set: *const sigset_t, __signo: c_int)
5380 -> c_int;
5381 pub fn sigprocmask(__how: c_int, __set: *const sigset_t,
5382 __oset: *mut sigset_t) -> c_int;
5383 pub fn sigsuspend(__set: *const sigset_t) -> c_int;
5384 pub fn sigaction(__sig: c_int,
5385 __act: *const Struct_sigaction,
5386 __oact: *mut Struct_sigaction) -> c_int;
5387 pub fn sigpending(__set: *mut sigset_t) -> c_int;
5388 pub fn sigwait(__set: *const sigset_t, __sig: *mut c_int)
5389 -> c_int;
5390 pub fn sigwaitinfo(__set: *const sigset_t, __info: *mut siginfo_t)
5391 -> c_int;
5392 pub fn sigtimedwait(__set: *const sigset_t, __info: *mut siginfo_t,
5393 __timeout: *const Struct_timespec)
5394 -> c_int;
5395 pub fn sigqueue(__pid: __pid_t, __sig: c_int,
5396 __val: Union_sigval) -> c_int;
5397 pub fn sigreturn(__scp: *mut Struct_sigcontext) -> c_int;
5398 pub fn siginterrupt(__sig: c_int,
5399 __interrupt: c_int)
5400 -> c_int;
5401 pub fn sigstack(__ss: *mut Struct_sigstack, __oss: *mut Struct_sigstack)
5402 -> c_int;
5403 pub fn sigaltstack(__ss: *const Struct_sigaltstack,
5404 __oss: *mut Struct_sigaltstack)
5405 -> c_int;
5406 pub fn pthread_sigmask(__how: c_int,
5407 __newmask: *const __sigset_t,
5408 __oldmask: *mut __sigset_t)
5409 -> c_int;
5410 pub fn pthread_kill(__threadid: pthread_t, __signo: c_int)
5411 -> c_int;
5412 pub fn __libc_current_sigrtmin() -> c_int;
5413 pub fn __libc_current_sigrtmax() -> c_int;
5414 pub fn GC_pthread_sigmask(arg1: c_int,
5415 arg2: *const sigset_t, arg3: *mut sigset_t)
5416 -> c_int;
5417 pub fn GC_pthread_create(arg1: *mut pthread_t,
5418 arg2: *const pthread_attr_t,
5419 arg3:
5420 ::std::option::Option<unsafe extern "C" fn(arg1:
5421 *mut c_void)
5422 ->
5423 *mut c_void>,
5424 arg4: *mut c_void)
5425 -> c_int;
5426 pub fn GC_pthread_join(arg1: pthread_t,
5427 arg2: *mut *mut c_void)
5428 -> c_int;
5429 pub fn GC_pthread_detach(arg1: pthread_t) -> c_int;
5430 pub fn GC_pthread_cancel(arg1: pthread_t) -> c_int;
5431 pub fn GC_pthread_exit(arg1: *mut c_void);
5432 pub fn GC_malloc_many(arg1: size_t) -> *mut c_void;
5433 pub fn GC_register_has_static_roots_callback(arg1:
5434 GC_has_static_roots_func);
5435 pub fn GC_set_force_unmap_on_gcollect(arg1: c_int);
5436 pub fn GC_get_force_unmap_on_gcollect() -> c_int;
5437 pub fn GC_win32_free_heap();
5438 pub fn scm_spawn_thread(body: scm_t_catch_body,
5439 body_data: *mut c_void,
5440 handler: scm_t_catch_handler,
5441 handler_data: *mut c_void) -> SCM;
5442 pub fn scm_without_guile(func:
5443 ::std::option::Option<unsafe extern "C" fn(arg1:
5444 *mut c_void)
5445 ->
5446 *mut c_void>,
5447 data: *mut c_void)
5448 -> *mut c_void;
5449 pub fn scm_with_guile(func:
5450 ::std::option::Option<unsafe extern "C" fn(arg1:
5451 *mut c_void)
5452 ->
5453 *mut c_void>,
5454 data: *mut c_void)
5455 -> *mut c_void;
5456 pub fn scm_i_reset_fluid(arg1: size_t);
5457 pub fn scm_threads_prehistory(arg1: *mut c_void);
5458 pub fn scm_init_threads();
5459 pub fn scm_init_thread_procs();
5460 pub fn scm_init_threads_default_dynamic_state();
5461 pub fn scm_i_dynwind_pthread_mutex_lock_block_asyncs(mutex:
5462 *mut pthread_mutex_t);
5463 pub fn scm_call_with_new_thread(thunk: SCM, handler: SCM) -> SCM;
5464 pub fn scm_yield() -> SCM;
5465 pub fn scm_cancel_thread(t: SCM) -> SCM;
5466 pub fn scm_set_thread_cleanup_x(thread: SCM, _proc: SCM) -> SCM;
5467 pub fn scm_thread_cleanup(thread: SCM) -> SCM;
5468 pub fn scm_join_thread(t: SCM) -> SCM;
5469 pub fn scm_join_thread_timed(t: SCM, timeout: SCM, timeoutval: SCM)
5470 -> SCM;
5471 pub fn scm_thread_p(t: SCM) -> SCM;
5472 pub fn scm_make_mutex() -> SCM;
5473 pub fn scm_make_recursive_mutex() -> SCM;
5474 pub fn scm_make_mutex_with_flags(flags: SCM) -> SCM;
5475 pub fn scm_lock_mutex(m: SCM) -> SCM;
5476 pub fn scm_lock_mutex_timed(m: SCM, timeout: SCM, owner: SCM) -> SCM;
5477 pub fn scm_dynwind_lock_mutex(mutex: SCM);
5478 pub fn scm_try_mutex(m: SCM) -> SCM;
5479 pub fn scm_unlock_mutex(m: SCM) -> SCM;
5480 pub fn scm_unlock_mutex_timed(m: SCM, cond: SCM, timeout: SCM) -> SCM;
5481 pub fn scm_mutex_p(o: SCM) -> SCM;
5482 pub fn scm_mutex_locked_p(m: SCM) -> SCM;
5483 pub fn scm_mutex_owner(m: SCM) -> SCM;
5484 pub fn scm_mutex_level(m: SCM) -> SCM;
5485 pub fn scm_make_condition_variable() -> SCM;
5486 pub fn scm_wait_condition_variable(cond: SCM, mutex: SCM) -> SCM;
5487 pub fn scm_timed_wait_condition_variable(cond: SCM, mutex: SCM,
5488 abstime: SCM) -> SCM;
5489 pub fn scm_signal_condition_variable(cond: SCM) -> SCM;
5490 pub fn scm_broadcast_condition_variable(cond: SCM) -> SCM;
5491 pub fn scm_condition_variable_p(o: SCM) -> SCM;
5492 pub fn scm_current_thread() -> SCM;
5493 pub fn scm_all_threads() -> SCM;
5494 pub fn scm_c_thread_exited_p(thread: SCM) -> c_int;
5495 pub fn scm_thread_exited_p(thread: SCM) -> SCM;
5496 pub fn scm_dynwind_critical_section(mutex: SCM);
5497 pub fn scm_pthread_mutex_lock(mutex: *mut pthread_mutex_t)
5498 -> c_int;
5499 pub fn scm_dynwind_pthread_mutex_lock(mutex: *mut pthread_mutex_t);
5500 pub fn scm_pthread_cond_wait(cond: *mut pthread_cond_t,
5501 mutex: *mut pthread_mutex_t)
5502 -> c_int;
5503 pub fn scm_pthread_cond_timedwait(cond: *mut pthread_cond_t,
5504 mutex: *mut pthread_mutex_t,
5505 abstime: *const scm_t_timespec)
5506 -> c_int;
5507 pub fn scm_std_sleep(arg1: c_uint)
5508 -> c_uint;
5509 pub fn scm_std_usleep(arg1: c_ulong)
5510 -> c_ulong;
5511 pub fn scm_total_processor_count() -> SCM;
5512 pub fn scm_current_processor_count() -> SCM;
5513 pub fn scm_async_click();
5514 pub fn scm_switch();
5515 pub fn scm_async(thunk: SCM) -> SCM;
5516 pub fn scm_async_mark(a: SCM) -> SCM;
5517 pub fn scm_system_async_mark(a: SCM) -> SCM;
5518 pub fn scm_system_async_mark_for_thread(a: SCM, thread: SCM) -> SCM;
5519 pub fn scm_i_queue_async_cell(cell: SCM, arg1: *mut scm_i_thread);
5520 pub fn scm_i_setup_sleep(arg1: *mut scm_i_thread, obj: SCM,
5521 m: *mut pthread_mutex_t,
5522 fd: c_int)
5523 -> c_int;
5524 pub fn scm_i_reset_sleep(arg1: *mut scm_i_thread);
5525 pub fn scm_run_asyncs(list_of_a: SCM) -> SCM;
5526 pub fn scm_noop(args: SCM) -> SCM;
5527 pub fn scm_call_with_blocked_asyncs(_proc: SCM) -> SCM;
5528 pub fn scm_call_with_unblocked_asyncs(_proc: SCM) -> SCM;
5529 pub fn scm_c_call_with_blocked_asyncs(p:
5530 ::std::option::Option<unsafe extern "C" fn(d:
5531 *mut c_void)
5532 ->
5533 *mut c_void>,
5534 d: *mut c_void)
5535 -> *mut c_void;
5536 pub fn scm_c_call_with_unblocked_asyncs(p:
5537 ::std::option::Option<unsafe extern "C" fn(d:
5538 *mut c_void)
5539 ->
5540 *mut c_void>,
5541 d: *mut c_void)
5542 -> *mut c_void;
5543 pub fn scm_dynwind_block_asyncs();
5544 pub fn scm_dynwind_unblock_asyncs();
5545 pub fn scm_critical_section_start();
5546 pub fn scm_critical_section_end();
5547 pub fn scm_init_async();
5548 pub fn scm_system_async(thunk: SCM) -> SCM;
5549 pub fn scm_unmask_signals() -> SCM;
5550 pub fn scm_mask_signals() -> SCM;
5551 pub fn scm_is_bool(arg1: SCM) -> c_int;
5552 pub fn scm_to_bool(x: SCM) -> c_int;
5553 pub fn scm_not(x: SCM) -> SCM;
5554 pub fn scm_boolean_p(obj: SCM) -> SCM;
5555 pub fn scm_init_boolean();
5556 pub fn scm_bitvector_p(vec: SCM) -> SCM;
5557 pub fn scm_bitvector(bits: SCM) -> SCM;
5558 pub fn scm_make_bitvector(len: SCM, fill: SCM) -> SCM;
5559 pub fn scm_bitvector_length(vec: SCM) -> SCM;
5560 pub fn scm_bitvector_ref(vec: SCM, idx: SCM) -> SCM;
5561 pub fn scm_bitvector_set_x(vec: SCM, idx: SCM, val: SCM) -> SCM;
5562 pub fn scm_list_to_bitvector(list: SCM) -> SCM;
5563 pub fn scm_bitvector_to_list(vec: SCM) -> SCM;
5564 pub fn scm_bitvector_fill_x(vec: SCM, val: SCM) -> SCM;
5565 pub fn scm_bit_count(item: SCM, seq: SCM) -> SCM;
5566 pub fn scm_bit_position(item: SCM, v: SCM, k: SCM) -> SCM;
5567 pub fn scm_bit_set_star_x(v: SCM, kv: SCM, obj: SCM) -> SCM;
5568 pub fn scm_bit_count_star(v: SCM, kv: SCM, obj: SCM) -> SCM;
5569 pub fn scm_bit_invert_x(v: SCM) -> SCM;
5570 pub fn scm_istr2bve(str: SCM) -> SCM;
5571 pub fn scm_is_bitvector(obj: SCM) -> c_int;
5572 pub fn scm_c_make_bitvector(len: size_t, fill: SCM) -> SCM;
5573 pub fn scm_c_bitvector_length(vec: SCM) -> size_t;
5574 pub fn scm_c_bitvector_ref(vec: SCM, idx: size_t) -> SCM;
5575 pub fn scm_c_bitvector_set_x(vec: SCM, idx: size_t, val: SCM);
5576 pub fn scm_array_handle_bit_elements(h: *mut scm_t_array_handle)
5577 -> *const scm_t_uint32;
5578 pub fn scm_array_handle_bit_writable_elements(h: *mut scm_t_array_handle)
5579 -> *mut scm_t_uint32;
5580 pub fn scm_array_handle_bit_elements_offset(h: *mut scm_t_array_handle)
5581 -> size_t;
5582 pub fn scm_bitvector_elements(vec: SCM, h: *mut scm_t_array_handle,
5583 offp: *mut size_t, lenp: *mut size_t,
5584 incp: *mut ssize_t) -> *const scm_t_uint32;
5585 pub fn scm_bitvector_writable_elements(vec: SCM,
5586 h: *mut scm_t_array_handle,
5587 offp: *mut size_t,
5588 lenp: *mut size_t,
5589 incp: *mut ssize_t)
5590 -> *mut scm_t_uint32;
5591 pub fn scm_i_print_bitvector(vec: SCM, port: SCM,
5592 pstate: *mut scm_print_state)
5593 -> c_int;
5594 pub fn scm_i_bitvector_equal_p(vec1: SCM, vec2: SCM) -> SCM;
5595 pub fn scm_init_bitvectors();
5596 pub fn scm_c_make_bytevector(arg1: size_t) -> SCM;
5597 pub fn scm_is_bytevector(arg1: SCM) -> c_int;
5598 pub fn scm_c_bytevector_length(arg1: SCM) -> size_t;
5599 pub fn scm_c_bytevector_ref(arg1: SCM, arg2: size_t) -> scm_t_uint8;
5600 pub fn scm_c_bytevector_set_x(arg1: SCM, arg2: size_t, arg3: scm_t_uint8);
5601 pub fn scm_make_bytevector(arg1: SCM, arg2: SCM) -> SCM;
5602 pub fn scm_native_endianness() -> SCM;
5603 pub fn scm_bytevector_p(arg1: SCM) -> SCM;
5604 pub fn scm_bytevector_length(arg1: SCM) -> SCM;
5605 pub fn scm_bytevector_eq_p(arg1: SCM, arg2: SCM) -> SCM;
5606 pub fn scm_bytevector_fill_x(arg1: SCM, arg2: SCM) -> SCM;
5607 pub fn scm_bytevector_copy_x(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
5608 arg5: SCM) -> SCM;
5609 pub fn scm_bytevector_copy(arg1: SCM) -> SCM;
5610 pub fn scm_uniform_array_to_bytevector(arg1: SCM) -> SCM;
5611 pub fn scm_bytevector_to_u8_list(arg1: SCM) -> SCM;
5612 pub fn scm_u8_list_to_bytevector(arg1: SCM) -> SCM;
5613 pub fn scm_uint_list_to_bytevector(arg1: SCM, arg2: SCM, arg3: SCM)
5614 -> SCM;
5615 pub fn scm_bytevector_to_uint_list(arg1: SCM, arg2: SCM, arg3: SCM)
5616 -> SCM;
5617 pub fn scm_sint_list_to_bytevector(arg1: SCM, arg2: SCM, arg3: SCM)
5618 -> SCM;
5619 pub fn scm_bytevector_to_sint_list(arg1: SCM, arg2: SCM, arg3: SCM)
5620 -> SCM;
5621 pub fn scm_bytevector_u16_native_ref(arg1: SCM, arg2: SCM) -> SCM;
5622 pub fn scm_bytevector_s16_native_ref(arg1: SCM, arg2: SCM) -> SCM;
5623 pub fn scm_bytevector_u32_native_ref(arg1: SCM, arg2: SCM) -> SCM;
5624 pub fn scm_bytevector_s32_native_ref(arg1: SCM, arg2: SCM) -> SCM;
5625 pub fn scm_bytevector_u64_native_ref(arg1: SCM, arg2: SCM) -> SCM;
5626 pub fn scm_bytevector_s64_native_ref(arg1: SCM, arg2: SCM) -> SCM;
5627 pub fn scm_bytevector_u8_ref(arg1: SCM, arg2: SCM) -> SCM;
5628 pub fn scm_bytevector_s8_ref(arg1: SCM, arg2: SCM) -> SCM;
5629 pub fn scm_bytevector_uint_ref(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
5630 -> SCM;
5631 pub fn scm_bytevector_sint_ref(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
5632 -> SCM;
5633 pub fn scm_bytevector_u16_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
5634 pub fn scm_bytevector_s16_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
5635 pub fn scm_bytevector_u32_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
5636 pub fn scm_bytevector_s32_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
5637 pub fn scm_bytevector_u64_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
5638 pub fn scm_bytevector_s64_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
5639 pub fn scm_bytevector_u16_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
5640 -> SCM;
5641 pub fn scm_bytevector_s16_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
5642 -> SCM;
5643 pub fn scm_bytevector_u32_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
5644 -> SCM;
5645 pub fn scm_bytevector_s32_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
5646 -> SCM;
5647 pub fn scm_bytevector_u64_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
5648 -> SCM;
5649 pub fn scm_bytevector_s64_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
5650 -> SCM;
5651 pub fn scm_bytevector_u8_set_x(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
5652 pub fn scm_bytevector_s8_set_x(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
5653 pub fn scm_bytevector_uint_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
5654 arg4: SCM, arg5: SCM) -> SCM;
5655 pub fn scm_bytevector_sint_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
5656 arg4: SCM, arg5: SCM) -> SCM;
5657 pub fn scm_bytevector_u16_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
5658 arg4: SCM) -> SCM;
5659 pub fn scm_bytevector_s16_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
5660 arg4: SCM) -> SCM;
5661 pub fn scm_bytevector_u32_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
5662 arg4: SCM) -> SCM;
5663 pub fn scm_bytevector_s32_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
5664 arg4: SCM) -> SCM;
5665 pub fn scm_bytevector_u64_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
5666 arg4: SCM) -> SCM;
5667 pub fn scm_bytevector_s64_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
5668 arg4: SCM) -> SCM;
5669 pub fn scm_bytevector_ieee_single_ref(arg1: SCM, arg2: SCM, arg3: SCM)
5670 -> SCM;
5671 pub fn scm_bytevector_ieee_single_native_ref(arg1: SCM, arg2: SCM) -> SCM;
5672 pub fn scm_bytevector_ieee_single_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
5673 arg4: SCM) -> SCM;
5674 pub fn scm_bytevector_ieee_single_native_set_x(arg1: SCM, arg2: SCM,
5675 arg3: SCM) -> SCM;
5676 pub fn scm_bytevector_ieee_double_ref(arg1: SCM, arg2: SCM, arg3: SCM)
5677 -> SCM;
5678 pub fn scm_bytevector_ieee_double_native_ref(arg1: SCM, arg2: SCM) -> SCM;
5679 pub fn scm_bytevector_ieee_double_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
5680 arg4: SCM) -> SCM;
5681 pub fn scm_bytevector_ieee_double_native_set_x(arg1: SCM, arg2: SCM,
5682 arg3: SCM) -> SCM;
5683 pub fn scm_string_to_utf8(arg1: SCM) -> SCM;
5684 pub fn scm_string_to_utf16(arg1: SCM, arg2: SCM) -> SCM;
5685 pub fn scm_string_to_utf32(arg1: SCM, arg2: SCM) -> SCM;
5686 pub fn scm_utf8_to_string(arg1: SCM) -> SCM;
5687 pub fn scm_utf16_to_string(arg1: SCM, arg2: SCM) -> SCM;
5688 pub fn scm_utf32_to_string(arg1: SCM, arg2: SCM) -> SCM;
5689 pub fn scm_i_make_typed_bytevector(arg1: size_t,
5690 arg2: scm_t_array_element_type) -> SCM;
5691 pub fn scm_c_take_typed_bytevector(arg1: *mut c_char,
5692 arg2: size_t,
5693 arg3: scm_t_array_element_type) -> SCM;
5694 pub fn scm_bootstrap_bytevectors();
5695 pub fn scm_init_bytevectors();
5696 pub fn scm_c_take_gc_bytevector(arg1: *mut c_char,
5697 arg2: size_t) -> SCM;
5698 pub fn scm_i_print_bytevector(arg1: SCM, arg2: SCM,
5699 arg3: *mut scm_print_state)
5700 -> c_int;
5701 pub fn scm_c_shrink_bytevector(arg1: SCM, arg2: size_t) -> SCM;
5702 pub fn scm_i_bytevector_generalized_set_x(arg1: SCM, arg2: size_t,
5703 arg3: SCM);
5704 pub fn scm_dynamic_link(fname: SCM) -> SCM;
5705 pub fn scm_dynamic_unlink(dobj: SCM) -> SCM;
5706 pub fn scm_dynamic_object_p(obj: SCM) -> SCM;
5707 pub fn scm_dynamic_pointer(name: SCM, dobj: SCM) -> SCM;
5708 pub fn scm_dynamic_func(symb: SCM, dobj: SCM) -> SCM;
5709 pub fn scm_dynamic_call(symb: SCM, dobj: SCM) -> SCM;
5710 pub fn scm_init_dynamic_linking();
5711 pub fn scm_eq_p(x: SCM, y: SCM) -> SCM;
5712 pub fn scm_eqv_p(x: SCM, y: SCM) -> SCM;
5713 pub fn scm_equal_p(x: SCM, y: SCM) -> SCM;
5714 pub fn scm_init_eq();
5715 pub fn scm_make_struct_layout(fields: SCM) -> SCM;
5716 pub fn scm_struct_p(x: SCM) -> SCM;
5717 pub fn scm_struct_vtable_p(x: SCM) -> SCM;
5718 pub fn scm_make_struct(vtable: SCM, tail_array_size: SCM, init: SCM)
5719 -> SCM;
5720 pub fn scm_c_make_struct(vtable: SCM, n_tail: size_t, n_inits: size_t,
5721 init: scm_t_bits, ...) -> SCM;
5722 pub fn scm_c_make_structv(vtable: SCM, n_tail: size_t, n_inits: size_t,
5723 init: *mut scm_t_bits) -> SCM;
5724 pub fn scm_make_vtable(fields: SCM, printer: SCM) -> SCM;
5725 pub fn scm_i_make_vtable_vtable(extra_fields: SCM) -> SCM;
5726 pub fn scm_make_vtable_vtable(extra_fields: SCM, tail_array_size: SCM,
5727 init: SCM) -> SCM;
5728 pub fn scm_struct_ref(handle: SCM, pos: SCM) -> SCM;
5729 pub fn scm_struct_set_x(handle: SCM, pos: SCM, val: SCM) -> SCM;
5730 pub fn scm_struct_vtable(handle: SCM) -> SCM;
5731 pub fn scm_struct_vtable_name(vtable: SCM) -> SCM;
5732 pub fn scm_set_struct_vtable_name_x(vtable: SCM, name: SCM) -> SCM;
5733 pub fn scm_print_struct(exp: SCM, port: SCM, arg1: *mut scm_print_state);
5734 pub fn scm_i_struct_equalp(s1: SCM, s2: SCM) -> SCM;
5735 pub fn scm_struct_ihashq(arg1: SCM, arg2: c_ulong,
5736 arg3: *mut c_void)
5737 -> c_ulong;
5738 pub fn scm_i_struct_hash(s: SCM, n: c_ulong,
5739 depth: size_t) -> c_ulong;
5740 pub fn scm_i_alloc_struct(vtable_data: *mut scm_t_bits,
5741 n_words: c_int) -> SCM;
5742 pub fn scm_i_struct_inherit_vtable_magic(vtable: SCM, obj: SCM);
5743 pub fn scm_init_struct();
5744 pub fn scm_memoize_expression(exp: SCM) -> SCM;
5745 pub fn scm_unmemoize_expression(memoized: SCM) -> SCM;
5746 pub fn scm_memoized_expression_typecode(memoized: SCM) -> SCM;
5747 pub fn scm_memoized_expression_data(memoized: SCM) -> SCM;
5748 pub fn scm_memoized_typecode(sym: SCM) -> SCM;
5749 pub fn scm_memoize_variable_access_x(memoized: SCM, module: SCM) -> SCM;
5750 pub fn scm_memoized_p(obj: SCM) -> SCM;
5751 pub fn scm_init_memoize();
5752 pub fn scm_call_0(_proc: SCM) -> SCM;
5753 pub fn scm_call_1(_proc: SCM, arg1: SCM) -> SCM;
5754 pub fn scm_call_2(_proc: SCM, arg1: SCM, arg2: SCM) -> SCM;
5755 pub fn scm_call_3(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
5756 pub fn scm_call_4(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
5757 -> SCM;
5758 pub fn scm_call_5(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
5759 arg5: SCM) -> SCM;
5760 pub fn scm_call_6(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
5761 arg5: SCM, arg6: SCM) -> SCM;
5762 pub fn scm_call_7(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
5763 arg5: SCM, arg6: SCM, arg7: SCM) -> SCM;
5764 pub fn scm_call_8(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
5765 arg5: SCM, arg6: SCM, arg7: SCM, arg8: SCM) -> SCM;
5766 pub fn scm_call_9(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
5767 arg5: SCM, arg6: SCM, arg7: SCM, arg8: SCM, arg9: SCM)
5768 -> SCM;
5769 pub fn scm_call_n(_proc: SCM, argv: *mut SCM, nargs: size_t) -> SCM;
5770 pub fn scm_call(_proc: SCM, ...) -> SCM;
5771 pub fn scm_apply_0(_proc: SCM, args: SCM) -> SCM;
5772 pub fn scm_apply_1(_proc: SCM, arg1: SCM, args: SCM) -> SCM;
5773 pub fn scm_apply_2(_proc: SCM, arg1: SCM, arg2: SCM, args: SCM) -> SCM;
5774 pub fn scm_apply_3(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, args: SCM)
5775 -> SCM;
5776 pub fn scm_nconc2last(lst: SCM) -> SCM;
5777 pub fn scm_apply(_proc: SCM, arg1: SCM, args: SCM) -> SCM;
5778 pub fn scm_map(_proc: SCM, arg1: SCM, args: SCM) -> SCM;
5779 pub fn scm_for_each(_proc: SCM, arg1: SCM, args: SCM) -> SCM;
5780 pub fn scm_primitive_eval(exp: SCM) -> SCM;
5781 pub fn scm_eval(exp: SCM, module: SCM) -> SCM;
5782 pub fn scm_init_eval();
5783 pub fn scm_defined_p(sym: SCM, env: SCM) -> SCM;
5784 pub fn scm_self_evaluating_p(obj: SCM) -> SCM;
5785 pub fn scm_init_evalext();
5786 pub fn scm_c_register_extension(lib: *const c_char,
5787 init: *const c_char,
5788 func:
5789 ::std::option::Option<unsafe extern "C" fn(arg1:
5790 *mut c_void)>,
5791 data: *mut c_void);
5792 pub fn scm_c_load_extension(lib: *const c_char,
5793 init: *const c_char);
5794 pub fn scm_load_extension(lib: SCM, init: SCM) -> SCM;
5795 pub fn scm_init_extensions();
5796 pub fn scm_add_feature(str: *const c_char);
5797 pub fn scm_program_arguments() -> SCM;
5798 pub fn scm_set_program_arguments(argc: c_int,
5799 argv: *mut *mut c_char,
5800 first: *mut c_char);
5801 pub fn scm_set_program_arguments_scm(lst: SCM) -> SCM;
5802 pub fn scm_init_feature();
5803 pub fn scm_chown(object: SCM, owner: SCM, group: SCM) -> SCM;
5804 pub fn scm_chmod(object: SCM, mode: SCM) -> SCM;
5805 pub fn scm_umask(mode: SCM) -> SCM;
5806 pub fn scm_open_fdes(path: SCM, flags: SCM, mode: SCM) -> SCM;
5807 pub fn scm_open(path: SCM, flags: SCM, mode: SCM) -> SCM;
5808 pub fn scm_close(fd_or_port: SCM) -> SCM;
5809 pub fn scm_close_fdes(fd: SCM) -> SCM;
5810 pub fn scm_stat(object: SCM, exception_on_error: SCM) -> SCM;
5811 pub fn scm_link(oldpath: SCM, newpath: SCM) -> SCM;
5812 pub fn scm_rename(oldname: SCM, newname: SCM) -> SCM;
5813 pub fn scm_delete_file(str: SCM) -> SCM;
5814 pub fn scm_mkdir(path: SCM, mode: SCM) -> SCM;
5815 pub fn scm_rmdir(path: SCM) -> SCM;
5816 pub fn scm_directory_stream_p(obj: SCM) -> SCM;
5817 pub fn scm_opendir(dirname: SCM) -> SCM;
5818 pub fn scm_readdir(port: SCM) -> SCM;
5819 pub fn scm_rewinddir(port: SCM) -> SCM;
5820 pub fn scm_closedir(port: SCM) -> SCM;
5821 pub fn scm_chdir(str: SCM) -> SCM;
5822 pub fn scm_getcwd() -> SCM;
5823 pub fn scm_select(reads: SCM, writes: SCM, excepts: SCM, secs: SCM,
5824 msecs: SCM) -> SCM;
5825 pub fn scm_fcntl(object: SCM, cmd: SCM, value: SCM) -> SCM;
5826 pub fn scm_fsync(object: SCM) -> SCM;
5827 pub fn scm_symlink(oldpath: SCM, newpath: SCM) -> SCM;
5828 pub fn scm_readlink(path: SCM) -> SCM;
5829 pub fn scm_lstat(str: SCM) -> SCM;
5830 pub fn scm_copy_file(oldfile: SCM, newfile: SCM) -> SCM;
5831 pub fn scm_dirname(filename: SCM) -> SCM;
5832 pub fn scm_basename(filename: SCM, suffix: SCM) -> SCM;
5833 pub fn scm_canonicalize_path(path: SCM) -> SCM;
5834 pub fn scm_sendfile(out: SCM, _in: SCM, count: SCM, offset: SCM) -> SCM;
5835 pub fn scm_i_relativize_path(path: SCM, in_path: SCM) -> SCM;
5836 pub fn scm_init_filesys();
5837 pub fn scm_i_set_finalizer(obj: *mut c_void,
5838 arg1: scm_t_finalizer_proc,
5839 data: *mut c_void);
5840 pub fn scm_i_add_finalizer(obj: *mut c_void,
5841 arg1: scm_t_finalizer_proc,
5842 data: *mut c_void);
5843 pub fn scm_i_add_resuscitator(obj: *mut c_void,
5844 arg1: scm_t_finalizer_proc,
5845 data: *mut c_void);
5846 pub fn scm_init_finalizers();
5847 pub fn scm_vector_p(x: SCM) -> SCM;
5848 pub fn scm_vector_length(v: SCM) -> SCM;
5849 pub fn scm_vector(l: SCM) -> SCM;
5850 pub fn scm_vector_ref(v: SCM, k: SCM) -> SCM;
5851 pub fn scm_vector_set_x(v: SCM, k: SCM, obj: SCM) -> SCM;
5852 pub fn scm_make_vector(k: SCM, fill: SCM) -> SCM;
5853 pub fn scm_vector_to_list(v: SCM) -> SCM;
5854 pub fn scm_vector_fill_x(v: SCM, fill_x: SCM) -> SCM;
5855 pub fn scm_vector_move_left_x(vec1: SCM, start1: SCM, end1: SCM,
5856 vec2: SCM, start2: SCM) -> SCM;
5857 pub fn scm_vector_move_right_x(vec1: SCM, start1: SCM, end1: SCM,
5858 vec2: SCM, start2: SCM) -> SCM;
5859 pub fn scm_vector_copy(vec: SCM) -> SCM;
5860 pub fn scm_is_vector(obj: SCM) -> c_int;
5861 pub fn scm_is_simple_vector(obj: SCM) -> c_int;
5862 pub fn scm_c_make_vector(len: size_t, fill: SCM) -> SCM;
5863 pub fn scm_c_vector_length(vec: SCM) -> size_t;
5864 pub fn scm_c_vector_ref(vec: SCM, k: size_t) -> SCM;
5865 pub fn scm_c_vector_set_x(vec: SCM, k: size_t, obj: SCM);
5866 pub fn scm_vector_elements(vec: SCM, h: *mut scm_t_array_handle,
5867 lenp: *mut size_t, incp: *mut ssize_t)
5868 -> *const SCM;
5869 pub fn scm_vector_writable_elements(vec: SCM, h: *mut scm_t_array_handle,
5870 lenp: *mut size_t, incp: *mut ssize_t)
5871 -> *mut SCM;
5872 pub fn scm_i_vector_equal_p(x: SCM, y: SCM) -> SCM;
5873 pub fn scm_i_make_weak_vector(_type: scm_t_bits, size: SCM, fill: SCM)
5874 -> SCM;
5875 pub fn scm_i_make_weak_vector_from_list(_type: scm_t_bits, lst: SCM)
5876 -> SCM;
5877 pub fn scm_init_vectors();
5878 pub fn scm_make_fluid() -> SCM;
5879 pub fn scm_make_fluid_with_default(dflt: SCM) -> SCM;
5880 pub fn scm_make_unbound_fluid() -> SCM;
5881 pub fn scm_is_fluid(obj: SCM) -> c_int;
5882 pub fn scm_fluid_p(fl: SCM) -> SCM;
5883 pub fn scm_fluid_ref(fluid: SCM) -> SCM;
5884 pub fn scm_fluid_set_x(fluid: SCM, value: SCM) -> SCM;
5885 pub fn scm_fluid_unset_x(fluid: SCM) -> SCM;
5886 pub fn scm_fluid_bound_p(fluid: SCM) -> SCM;
5887 pub fn scm_i_make_with_fluids(n: size_t, fluids: *mut SCM, vals: *mut SCM)
5888 -> SCM;
5889 pub fn scm_i_swap_with_fluids(with_fluids: SCM, dynamic_state: SCM);
5890 pub fn scm_c_with_fluids(fluids: SCM, vals: SCM,
5891 cproc:
5892 ::std::option::Option<unsafe extern "C" fn(arg1:
5893 *mut c_void)
5894 -> SCM>,
5895 cdata: *mut c_void) -> SCM;
5896 pub fn scm_c_with_fluid(fluid: SCM, val: SCM,
5897 cproc:
5898 ::std::option::Option<unsafe extern "C" fn(arg1:
5899 *mut c_void)
5900 -> SCM>,
5901 cdata: *mut c_void) -> SCM;
5902 pub fn scm_with_fluids(fluids: SCM, vals: SCM, thunk: SCM) -> SCM;
5903 pub fn scm_with_fluid(fluid: SCM, val: SCM, thunk: SCM) -> SCM;
5904 pub fn scm_dynwind_fluid(fluid: SCM, value: SCM);
5905 pub fn scm_make_dynamic_state(parent: SCM) -> SCM;
5906 pub fn scm_dynamic_state_p(obj: SCM) -> SCM;
5907 pub fn scm_is_dynamic_state(obj: SCM) -> c_int;
5908 pub fn scm_current_dynamic_state() -> SCM;
5909 pub fn scm_set_current_dynamic_state(state: SCM) -> SCM;
5910 pub fn scm_dynwind_current_dynamic_state(state: SCM);
5911 pub fn scm_c_with_dynamic_state(state: SCM,
5912 func:
5913 ::std::option::Option<unsafe extern "C" fn(arg1:
5914 *mut c_void)
5915 ->
5916 *mut c_void>,
5917 data: *mut c_void)
5918 -> *mut c_void;
5919 pub fn scm_with_dynamic_state(state: SCM, _proc: SCM) -> SCM;
5920 pub fn scm_i_make_initial_dynamic_state() -> SCM;
5921 pub fn scm_i_fluid_print(exp: SCM, port: SCM,
5922 pstate: *mut scm_print_state);
5923 pub fn scm_i_dynamic_state_print(exp: SCM, port: SCM,
5924 pstate: *mut scm_print_state);
5925 pub fn scm_i_with_fluids_print(exp: SCM, port: SCM,
5926 pstate: *mut scm_print_state);
5927 pub fn scm_init_fluids();
5928 pub fn scm_to_pointer(pointer: SCM) -> *mut c_void;
5929 pub fn scm_from_pointer(arg1: *mut c_void,
5930 arg2: scm_t_pointer_finalizer) -> SCM;
5931 pub fn scm_alignof(_type: SCM) -> SCM;
5932 pub fn scm_sizeof(_type: SCM) -> SCM;
5933 pub fn scm_pointer_address(pointer: SCM) -> SCM;
5934 pub fn scm_pointer_to_bytevector(pointer: SCM, _type: SCM, offset: SCM,
5935 len: SCM) -> SCM;
5936 pub fn scm_set_pointer_finalizer_x(pointer: SCM, finalizer: SCM) -> SCM;
5937 pub fn scm_bytevector_to_pointer(bv: SCM, offset: SCM) -> SCM;
5938 pub fn scm_pointer_p(obj: SCM) -> SCM;
5939 pub fn scm_make_pointer(address: SCM, finalizer: SCM) -> SCM;
5940 pub fn scm_i_pointer_print(pointer: SCM, port: SCM,
5941 pstate: *mut scm_print_state);
5942 pub fn scm_dereference_pointer(pointer: SCM) -> SCM;
5943 pub fn scm_string_to_pointer(string: SCM, encoding: SCM) -> SCM;
5944 pub fn scm_pointer_to_string(pointer: SCM, length: SCM, encoding: SCM)
5945 -> SCM;
5946 pub fn scm_pointer_to_procedure(return_type: SCM, func_ptr: SCM,
5947 arg_types: SCM) -> SCM;
5948 pub fn scm_procedure_to_pointer(return_type: SCM, func_ptr: SCM,
5949 arg_types: SCM) -> SCM;
5950 pub fn scm_i_foreign_call(foreign: SCM, argv: *const SCM) -> SCM;
5951 pub fn scm_register_foreign();
5952 pub fn access(__name: *const c_char,
5953 __type: c_int) -> c_int;
5954 pub fn faccessat(__fd: c_int,
5955 __file: *const c_char,
5956 __type: c_int,
5957 __flag: c_int) -> c_int;
5958 pub fn lseek(__fd: c_int, __offset: __off_t,
5959 __whence: c_int) -> __off_t;
5960 pub fn close(__fd: c_int) -> c_int;
5961 pub fn read(__fd: c_int,
5962 __buf: *mut c_void, __nbytes: size_t)
5963 -> ssize_t;
5964 pub fn write(__fd: c_int,
5965 __buf: *const c_void, __n: size_t)
5966 -> ssize_t;
5967 pub fn pread(__fd: c_int,
5968 __buf: *mut c_void, __nbytes: size_t,
5969 __offset: __off_t) -> ssize_t;
5970 pub fn pwrite(__fd: c_int,
5971 __buf: *const c_void, __n: size_t,
5972 __offset: __off_t) -> ssize_t;
5973 pub fn pipe(__pipedes: *mut c_int)
5974 -> c_int;
5975 pub fn alarm(__seconds: c_uint) -> c_uint;
5976 pub fn sleep(__seconds: c_uint) -> c_uint;
5977 pub fn ualarm(__value: __useconds_t, __interval: __useconds_t)
5978 -> __useconds_t;
5979 pub fn usleep(__useconds: __useconds_t) -> c_int;
5980 pub fn pause() -> c_int;
5981 pub fn chown(__file: *const c_char, __owner: __uid_t,
5982 __group: __gid_t) -> c_int;
5983 pub fn fchown(__fd: c_int, __owner: __uid_t,
5984 __group: __gid_t) -> c_int;
5985 pub fn lchown(__file: *const c_char, __owner: __uid_t,
5986 __group: __gid_t) -> c_int;
5987 pub fn fchownat(__fd: c_int,
5988 __file: *const c_char, __owner: __uid_t,
5989 __group: __gid_t, __flag: c_int)
5990 -> c_int;
5991 pub fn chdir(__path: *const c_char)
5992 -> c_int;
5993 pub fn fchdir(__fd: c_int) -> c_int;
5994 pub fn getcwd(__buf: *mut c_char, __size: size_t)
5995 -> *mut c_char;
5996 pub fn getwd(__buf: *mut c_char)
5997 -> *mut c_char;
5998 pub fn dup(__fd: c_int) -> c_int;
5999 pub fn dup2(__fd: c_int, __fd2: c_int)
6000 -> c_int;
6001 pub fn execve(__path: *const c_char,
6002 __argv: *const *mut c_char,
6003 __envp: *const *mut c_char)
6004 -> c_int;
6005 pub fn fexecve(__fd: c_int,
6006 __argv: *const *mut c_char,
6007 __envp: *const *mut c_char)
6008 -> c_int;
6009 pub fn execv(__path: *const c_char,
6010 __argv: *const *mut c_char)
6011 -> c_int;
6012 pub fn execle(__path: *const c_char,
6013 __arg: *const c_char, ...)
6014 -> c_int;
6015 pub fn execl(__path: *const c_char,
6016 __arg: *const c_char, ...)
6017 -> c_int;
6018 pub fn execvp(__file: *const c_char,
6019 __argv: *const *mut c_char)
6020 -> c_int;
6021 pub fn execlp(__file: *const c_char,
6022 __arg: *const c_char, ...)
6023 -> c_int;
6024 pub fn nice(__inc: c_int) -> c_int;
6025 pub fn _exit(__status: c_int);
6026 pub fn pathconf(__path: *const c_char,
6027 __name: c_int) -> c_long;
6028 pub fn fpathconf(__fd: c_int,
6029 __name: c_int) -> c_long;
6030 pub fn sysconf(__name: c_int) -> c_long;
6031 pub fn confstr(__name: c_int,
6032 __buf: *mut c_char, __len: size_t)
6033 -> size_t;
6034 pub fn getpid() -> __pid_t;
6035 pub fn getppid() -> __pid_t;
6036 pub fn getpgrp() -> __pid_t;
6037 pub fn __getpgid(__pid: __pid_t) -> __pid_t;
6038 pub fn getpgid(__pid: __pid_t) -> __pid_t;
6039 pub fn setpgid(__pid: __pid_t, __pgid: __pid_t) -> c_int;
6040 pub fn setpgrp() -> c_int;
6041 pub fn setsid() -> __pid_t;
6042 pub fn getsid(__pid: __pid_t) -> __pid_t;
6043 pub fn getuid() -> __uid_t;
6044 pub fn geteuid() -> __uid_t;
6045 pub fn getgid() -> __gid_t;
6046 pub fn getegid() -> __gid_t;
6047 pub fn getgroups(__size: c_int, __list: *mut __gid_t)
6048 -> c_int;
6049 pub fn setuid(__uid: __uid_t) -> c_int;
6050 pub fn setreuid(__ruid: __uid_t, __euid: __uid_t)
6051 -> c_int;
6052 pub fn seteuid(__uid: __uid_t) -> c_int;
6053 pub fn setgid(__gid: __gid_t) -> c_int;
6054 pub fn setregid(__rgid: __gid_t, __egid: __gid_t)
6055 -> c_int;
6056 pub fn setegid(__gid: __gid_t) -> c_int;
6057 pub fn fork() -> __pid_t;
6058 pub fn vfork() -> __pid_t;
6059 pub fn ttyname(__fd: c_int)
6060 -> *mut c_char;
6061 pub fn ttyname_r(__fd: c_int,
6062 __buf: *mut c_char, __buflen: size_t)
6063 -> c_int;
6064 pub fn isatty(__fd: c_int) -> c_int;
6065 pub fn ttyslot() -> c_int;
6066 pub fn link(__from: *const c_char,
6067 __to: *const c_char) -> c_int;
6068 pub fn linkat(__fromfd: c_int,
6069 __from: *const c_char,
6070 __tofd: c_int,
6071 __to: *const c_char,
6072 __flags: c_int) -> c_int;
6073 pub fn symlink(__from: *const c_char,
6074 __to: *const c_char)
6075 -> c_int;
6076 pub fn readlink(__path: *const c_char,
6077 __buf: *mut c_char, __len: size_t)
6078 -> ssize_t;
6079 pub fn symlinkat(__from: *const c_char,
6080 __tofd: c_int,
6081 __to: *const c_char)
6082 -> c_int;
6083 pub fn readlinkat(__fd: c_int,
6084 __path: *const c_char,
6085 __buf: *mut c_char, __len: size_t)
6086 -> ssize_t;
6087 pub fn unlink(__name: *const c_char)
6088 -> c_int;
6089 pub fn unlinkat(__fd: c_int,
6090 __name: *const c_char,
6091 __flag: c_int) -> c_int;
6092 pub fn rmdir(__path: *const c_char)
6093 -> c_int;
6094 pub fn tcgetpgrp(__fd: c_int) -> __pid_t;
6095 pub fn tcsetpgrp(__fd: c_int, __pgrp_id: __pid_t)
6096 -> c_int;
6097 pub fn getlogin() -> *mut c_char;
6098 pub fn getlogin_r(__name: *mut c_char, __name_len: size_t)
6099 -> c_int;
6100 pub fn setlogin(__name: *const c_char)
6101 -> c_int;
6102 pub fn getopt(___argc: c_int,
6103 ___argv: *const *mut c_char,
6104 __shortopts: *const c_char)
6105 -> c_int;
6106 pub fn gethostname(__name: *mut c_char, __len: size_t)
6107 -> c_int;
6108 pub fn sethostname(__name: *const c_char, __len: size_t)
6109 -> c_int;
6110 pub fn sethostid(__id: c_long) -> c_int;
6111 pub fn getdomainname(__name: *mut c_char, __len: size_t)
6112 -> c_int;
6113 pub fn setdomainname(__name: *const c_char, __len: size_t)
6114 -> c_int;
6115 pub fn vhangup() -> c_int;
6116 pub fn revoke(__file: *const c_char)
6117 -> c_int;
6118 pub fn profil(__sample_buffer: *mut c_ushort,
6119 __size: size_t, __offset: size_t,
6120 __scale: c_uint) -> c_int;
6121 pub fn acct(__name: *const c_char)
6122 -> c_int;
6123 pub fn getusershell() -> *mut c_char;
6124 pub fn endusershell();
6125 pub fn setusershell();
6126 pub fn daemon(__nochdir: c_int,
6127 __noclose: c_int) -> c_int;
6128 pub fn chroot(__path: *const c_char)
6129 -> c_int;
6130 pub fn getpass(__prompt: *const c_char)
6131 -> *mut c_char;
6132 pub fn fsync(__fd: c_int) -> c_int;
6133 pub fn gethostid() -> c_long;
6134 pub fn sync();
6135 pub fn getpagesize() -> c_int;
6136 pub fn getdtablesize() -> c_int;
6137 pub fn truncate(__file: *const c_char, __length: __off_t)
6138 -> c_int;
6139 pub fn ftruncate(__fd: c_int, __length: __off_t)
6140 -> c_int;
6141 pub fn brk(__addr: *mut c_void) -> c_int;
6142 pub fn sbrk(__delta: intptr_t) -> *mut c_void;
6143 pub fn syscall(__sysno: c_long, ...)
6144 -> c_long;
6145 pub fn lockf(__fd: c_int, __cmd: c_int,
6146 __len: __off_t) -> c_int;
6147 pub fn fdatasync(__fildes: c_int)
6148 -> c_int;
6149 pub fn scm_string_p(x: SCM) -> SCM;
6150 pub fn scm_string(chrs: SCM) -> SCM;
6151 pub fn scm_make_string(k: SCM, chr: SCM) -> SCM;
6152 pub fn scm_string_length(str: SCM) -> SCM;
6153 pub fn scm_string_bytes_per_char(str: SCM) -> SCM;
6154 pub fn scm_string_ref(str: SCM, k: SCM) -> SCM;
6155 pub fn scm_string_set_x(str: SCM, k: SCM, chr: SCM) -> SCM;
6156 pub fn scm_substring(str: SCM, start: SCM, end: SCM) -> SCM;
6157 pub fn scm_substring_read_only(str: SCM, start: SCM, end: SCM) -> SCM;
6158 pub fn scm_substring_shared(str: SCM, start: SCM, end: SCM) -> SCM;
6159 pub fn scm_substring_copy(str: SCM, start: SCM, end: SCM) -> SCM;
6160 pub fn scm_string_append(args: SCM) -> SCM;
6161 pub fn scm_from_stringn(str: *const c_char, len: size_t,
6162 encoding: *const c_char,
6163 handler: scm_t_string_failed_conversion_handler)
6164 -> SCM;
6165 pub fn scm_c_make_string(len: size_t, chr: SCM) -> SCM;
6166 pub fn scm_c_string_length(str: SCM) -> size_t;
6167 pub fn scm_c_symbol_length(sym: SCM) -> size_t;
6168 pub fn scm_c_string_ref(str: SCM, pos: size_t) -> SCM;
6169 pub fn scm_c_string_set_x(str: SCM, pos: size_t, chr: SCM);
6170 pub fn scm_c_substring(str: SCM, start: size_t, end: size_t) -> SCM;
6171 pub fn scm_c_substring_read_only(str: SCM, start: size_t, end: size_t)
6172 -> SCM;
6173 pub fn scm_c_substring_shared(str: SCM, start: size_t, end: size_t)
6174 -> SCM;
6175 pub fn scm_c_substring_copy(str: SCM, start: size_t, end: size_t) -> SCM;
6176 pub fn scm_from_locale_string(str: *const c_char) -> SCM;
6177 pub fn scm_from_locale_stringn(str: *const c_char,
6178 len: size_t) -> SCM;
6179 pub fn scm_take_locale_string(str: *mut c_char) -> SCM;
6180 pub fn scm_take_locale_stringn(str: *mut c_char,
6181 len: size_t) -> SCM;
6182 pub fn scm_to_locale_string(str: SCM) -> *mut c_char;
6183 pub fn scm_to_locale_stringn(str: SCM, lenp: *mut size_t)
6184 -> *mut c_char;
6185 pub fn scm_from_latin1_string(str: *const c_char) -> SCM;
6186 pub fn scm_from_latin1_stringn(str: *const c_char,
6187 len: size_t) -> SCM;
6188 pub fn scm_to_latin1_string(str: SCM) -> *mut c_char;
6189 pub fn scm_to_latin1_stringn(str: SCM, lenp: *mut size_t)
6190 -> *mut c_char;
6191 pub fn scm_to_utf8_string(str: SCM) -> *mut c_char;
6192 pub fn scm_to_utf8_stringn(str: SCM, lenp: *mut size_t)
6193 -> *mut c_char;
6194 pub fn scm_from_utf8_string(str: *const c_char) -> SCM;
6195 pub fn scm_from_utf8_stringn(str: *const c_char,
6196 len: size_t) -> SCM;
6197 pub fn scm_to_utf32_string(str: SCM) -> *mut scm_t_wchar;
6198 pub fn scm_to_utf32_stringn(str: SCM, lenp: *mut size_t)
6199 -> *mut scm_t_wchar;
6200 pub fn scm_from_utf32_string(str: *const scm_t_wchar) -> SCM;
6201 pub fn scm_from_utf32_stringn(str: *const scm_t_wchar, len: size_t)
6202 -> SCM;
6203 pub fn scm_to_stringn(str: SCM, lenp: *mut size_t,
6204 encoding: *const c_char,
6205 handler: scm_t_string_failed_conversion_handler)
6206 -> *mut c_char;
6207 pub fn scm_to_locale_stringbuf(str: SCM, buf: *mut c_char,
6208 max_len: size_t) -> size_t;
6209 pub fn scm_string_normalize_nfd(str: SCM) -> SCM;
6210 pub fn scm_string_normalize_nfkd(str: SCM) -> SCM;
6211 pub fn scm_string_normalize_nfc(str: SCM) -> SCM;
6212 pub fn scm_string_normalize_nfkc(str: SCM) -> SCM;
6213 pub fn scm_makfromstrs(argc: c_int,
6214 argv: *mut *mut c_char) -> SCM;
6215 pub fn scm_i_make_string(len: size_t,
6216 datap: *mut *mut c_char,
6217 read_only_p: c_int) -> SCM;
6218 pub fn scm_i_make_wide_string(len: size_t, datap: *mut *mut scm_t_wchar,
6219 read_only_p: c_int) -> SCM;
6220 pub fn scm_i_set_string_read_only_x(str: SCM) -> SCM;
6221 pub fn scm_i_substring(str: SCM, start: size_t, end: size_t) -> SCM;
6222 pub fn scm_i_substring_read_only(str: SCM, start: size_t, end: size_t)
6223 -> SCM;
6224 pub fn scm_i_substring_shared(str: SCM, start: size_t, end: size_t)
6225 -> SCM;
6226 pub fn scm_i_substring_copy(str: SCM, start: size_t, end: size_t) -> SCM;
6227 pub fn scm_i_string_length(str: SCM) -> size_t;
6228 pub fn scm_i_string_chars(str: SCM) -> *const c_char;
6229 pub fn scm_i_string_writable_chars(str: SCM)
6230 -> *mut c_char;
6231 pub fn scm_i_string_wide_chars(str: SCM) -> *const scm_t_wchar;
6232 pub fn scm_i_string_data(str: SCM) -> *const c_void;
6233 pub fn scm_i_string_start_writing(str: SCM) -> SCM;
6234 pub fn scm_i_string_stop_writing();
6235 pub fn scm_i_is_narrow_string(str: SCM) -> c_int;
6236 pub fn scm_i_string_ref(str: SCM, x: size_t) -> scm_t_wchar;
6237 pub fn scm_i_string_contains_char(str: SCM, c: c_char)
6238 -> c_int;
6239 pub fn scm_i_string_strcmp(sstr: SCM, start_x: size_t,
6240 cstr: *const c_char)
6241 -> c_int;
6242 pub fn scm_i_string_set_x(str: SCM, p: size_t, chr: scm_t_wchar);
6243 pub fn scm_i_make_symbol(name: SCM, flags: scm_t_bits,
6244 hash: c_ulong, props: SCM)
6245 -> SCM;
6246 pub fn scm_i_c_make_symbol(name: *const c_char,
6247 len: size_t, flags: scm_t_bits,
6248 hash: c_ulong, props: SCM)
6249 -> SCM;
6250 pub fn scm_i_symbol_chars(sym: SCM) -> *const c_char;
6251 pub fn scm_i_symbol_wide_chars(sym: SCM) -> *const scm_t_wchar;
6252 pub fn scm_i_symbol_length(sym: SCM) -> size_t;
6253 pub fn scm_i_is_narrow_symbol(str: SCM) -> c_int;
6254 pub fn scm_i_try_narrow_string(str: SCM) -> c_int;
6255 pub fn scm_i_symbol_substring(sym: SCM, start: size_t, end: size_t)
6256 -> SCM;
6257 pub fn scm_i_symbol_ref(sym: SCM, x: size_t) -> scm_t_wchar;
6258 pub fn scm_encoding_error(subr: *const c_char,
6259 err: c_int,
6260 message: *const c_char,
6261 port: SCM, chr: SCM);
6262 pub fn scm_decoding_error(subr: *const c_char,
6263 err: c_int,
6264 message: *const c_char,
6265 port: SCM);
6266 pub fn scm_i_allocate_string_pointers(list: SCM)
6267 -> *mut *mut c_char;
6268 pub fn scm_i_get_substring_spec(len: size_t, start: SCM,
6269 cstart: *mut size_t, end: SCM,
6270 cend: *mut size_t);
6271 pub fn scm_sys_string_dump(arg1: SCM) -> SCM;
6272 pub fn scm_sys_symbol_dump(arg1: SCM) -> SCM;
6273 pub fn scm_i_deprecated_stringp(obj: SCM) -> c_int;
6274 pub fn scm_i_deprecated_string_chars(str: SCM)
6275 -> *mut c_char;
6276 pub fn scm_i_deprecated_string_length(str: SCM) -> size_t;
6277 pub fn scm_init_strings();
6278 pub fn scm_markstream(ptr: SCM) -> SCM;
6279 pub fn scm_make_port_type(name: *mut c_char,
6280 fill_input:
6281 ::std::option::Option<extern "C" fn(port:
6282 SCM)
6283 ->
6284 c_int>,
6285 write:
6286 ::std::option::Option<unsafe extern "C" fn(port:
6287 SCM,
6288 data:
6289 *const c_void,
6290 size:
6291 size_t)>)
6292 -> scm_t_bits;
6293 pub fn scm_set_port_mark(tc: scm_t_bits,
6294 mark:
6295 ::std::option::Option<extern "C" fn(arg1:
6296 SCM)
6297 -> SCM>);
6298 pub fn scm_set_port_free(tc: scm_t_bits,
6299 free:
6300 ::std::option::Option<extern "C" fn(arg1:
6301 SCM)
6302 -> size_t>);
6303 pub fn scm_set_port_print(tc: scm_t_bits,
6304 print:
6305 ::std::option::Option<unsafe extern "C" fn(exp:
6306 SCM,
6307 port:
6308 SCM,
6309 pstate:
6310 *mut scm_print_state)
6311 ->
6312 c_int>);
6313 pub fn scm_set_port_equalp(tc: scm_t_bits,
6314 equalp:
6315 ::std::option::Option<extern "C" fn(arg1:
6316 SCM,
6317 arg2:
6318 SCM)
6319 -> SCM>);
6320 pub fn scm_set_port_close(tc: scm_t_bits,
6321 close:
6322 ::std::option::Option<extern "C" fn(arg1:
6323 SCM)
6324 ->
6325 c_int>);
6326 pub fn scm_set_port_flush(tc: scm_t_bits,
6327 flush:
6328 ::std::option::Option<extern "C" fn(port:
6329 SCM)>);
6330 pub fn scm_set_port_end_input(tc: scm_t_bits,
6331 end_input:
6332 ::std::option::Option<extern "C" fn(port:
6333 SCM,
6334 offset:
6335 c_int)>);
6336 pub fn scm_set_port_seek(tc: scm_t_bits,
6337 seek:
6338 ::std::option::Option<extern "C" fn(port:
6339 SCM,
6340 OFFSET:
6341 scm_t_off,
6342 WHENCE:
6343 c_int)
6344 -> scm_t_off>);
6345 pub fn scm_set_port_truncate(tc: scm_t_bits,
6346 truncate:
6347 ::std::option::Option<extern "C" fn(port:
6348 SCM,
6349 length:
6350 scm_t_off)>);
6351 pub fn scm_set_port_input_waiting(tc: scm_t_bits,
6352 input_waiting:
6353 ::std::option::Option<extern "C" fn(arg1:
6354 SCM)
6355 ->
6356 c_int>);
6357 pub fn scm_char_ready_p(port: SCM) -> SCM;
6358 pub fn scm_take_from_input_buffers(port: SCM,
6359 dest: *mut c_char,
6360 read_len: size_t) -> size_t;
6361 pub fn scm_drain_input(port: SCM) -> SCM;
6362 pub fn scm_current_input_port() -> SCM;
6363 pub fn scm_current_output_port() -> SCM;
6364 pub fn scm_current_error_port() -> SCM;
6365 pub fn scm_current_warning_port() -> SCM;
6366 pub fn scm_current_load_port() -> SCM;
6367 pub fn scm_set_current_input_port(port: SCM) -> SCM;
6368 pub fn scm_set_current_output_port(port: SCM) -> SCM;
6369 pub fn scm_set_current_error_port(port: SCM) -> SCM;
6370 pub fn scm_set_current_warning_port(port: SCM) -> SCM;
6371 pub fn scm_dynwind_current_input_port(port: SCM);
6372 pub fn scm_dynwind_current_output_port(port: SCM);
6373 pub fn scm_dynwind_current_error_port(port: SCM);
6374 pub fn scm_new_port_table_entry(tag: scm_t_bits) -> SCM;
6375 pub fn scm_grow_port_cbuf(port: SCM, requested: size_t);
6376 pub fn scm_pt_size() -> SCM;
6377 pub fn scm_pt_member(member: SCM) -> SCM;
6378 pub fn scm_port_non_buffer(pt: *mut scm_t_port);
6379 pub fn scm_revealed_count(port: SCM) -> c_int;
6380 pub fn scm_port_revealed(port: SCM) -> SCM;
6381 pub fn scm_set_port_revealed_x(port: SCM, rcount: SCM) -> SCM;
6382 pub fn scm_mode_bits(modes: *mut c_char)
6383 -> c_long;
6384 pub fn scm_port_mode(port: SCM) -> SCM;
6385 pub fn scm_close_input_port(port: SCM) -> SCM;
6386 pub fn scm_close_output_port(port: SCM) -> SCM;
6387 pub fn scm_close_port(port: SCM) -> SCM;
6388 pub fn scm_port_for_each(_proc: SCM) -> SCM;
6389 pub fn scm_c_port_for_each(_proc:
6390 ::std::option::Option<unsafe extern "C" fn(data:
6391 *mut c_void,
6392 p:
6393 SCM)>,
6394 data: *mut c_void);
6395 pub fn scm_input_port_p(x: SCM) -> SCM;
6396 pub fn scm_output_port_p(x: SCM) -> SCM;
6397 pub fn scm_port_p(x: SCM) -> SCM;
6398 pub fn scm_port_closed_p(port: SCM) -> SCM;
6399 pub fn scm_eof_object_p(x: SCM) -> SCM;
6400 pub fn scm_force_output(port: SCM) -> SCM;
6401 pub fn scm_flush_all_ports() -> SCM;
6402 pub fn scm_read_char(port: SCM) -> SCM;
6403 pub fn scm_getc(port: SCM) -> scm_t_wchar;
6404 pub fn scm_c_read(port: SCM, buffer: *mut c_void,
6405 size: size_t) -> size_t;
6406 pub fn scm_c_write(port: SCM, buffer: *const c_void,
6407 size: size_t);
6408 pub fn scm_lfwrite(ptr: *const c_char, size: size_t,
6409 port: SCM);
6410 pub fn scm_lfwrite_substr(str: SCM, start: size_t, end: size_t,
6411 port: SCM);
6412 pub fn scm_flush(port: SCM);
6413 pub fn scm_end_input(port: SCM);
6414 pub fn scm_fill_input(port: SCM) -> c_int;
6415 pub fn scm_unget_bytes(buf: *const c_uchar, len: size_t,
6416 port: SCM);
6417 pub fn scm_unget_byte(c: c_int, port: SCM);
6418 pub fn scm_ungetc(c: scm_t_wchar, port: SCM);
6419 pub fn scm_ungets(s: *const c_char,
6420 n: c_int, port: SCM);
6421 pub fn scm_peek_char(port: SCM) -> SCM;
6422 pub fn scm_unread_char(cobj: SCM, port: SCM) -> SCM;
6423 pub fn scm_unread_string(str: SCM, port: SCM) -> SCM;
6424 pub fn scm_seek(object: SCM, offset: SCM, whence: SCM) -> SCM;
6425 pub fn scm_truncate_file(object: SCM, length: SCM) -> SCM;
6426 pub fn scm_port_line(port: SCM) -> SCM;
6427 pub fn scm_set_port_line_x(port: SCM, line: SCM) -> SCM;
6428 pub fn scm_port_column(port: SCM) -> SCM;
6429 pub fn scm_set_port_column_x(port: SCM, line: SCM) -> SCM;
6430 pub fn scm_port_filename(port: SCM) -> SCM;
6431 pub fn scm_set_port_filename_x(port: SCM, filename: SCM) -> SCM;
6432 pub fn scm_i_port_property(port: SCM, key: SCM) -> SCM;
6433 pub fn scm_i_set_port_property_x(port: SCM, key: SCM, value: SCM) -> SCM;
6434 pub fn scm_i_default_port_encoding() -> *const c_char;
6435 pub fn scm_i_set_default_port_encoding(arg1:
6436 *const c_char);
6437 pub fn scm_i_set_port_encoding_x(port: SCM,
6438 str: *const c_char);
6439 pub fn scm_port_encoding(port: SCM) -> SCM;
6440 pub fn scm_set_port_encoding_x(port: SCM, encoding: SCM) -> SCM;
6441 pub fn scm_i_default_port_conversion_handler()
6442 -> scm_t_string_failed_conversion_handler;
6443 pub fn scm_i_set_default_port_conversion_handler(arg1:
6444 scm_t_string_failed_conversion_handler);
6445 pub fn scm_slow_get_byte_or_eof(port: SCM) -> c_int;
6446 pub fn scm_slow_peek_byte_or_eof(port: SCM) -> c_int;
6447 pub fn scm_port_conversion_strategy(port: SCM) -> SCM;
6448 pub fn scm_set_port_conversion_strategy_x(port: SCM, behavior: SCM)
6449 -> SCM;
6450 pub fn scm_port_print(exp: SCM, port: SCM, arg1: *mut scm_print_state)
6451 -> c_int;
6452 pub fn scm_print_port_mode(exp: SCM, port: SCM);
6453 pub fn scm_void_port(mode_str: *mut c_char) -> SCM;
6454 pub fn scm_sys_make_void_port(mode: SCM) -> SCM;
6455 pub fn scm_init_ports();
6456 pub fn scm_add_to_port_table(port: SCM) -> *mut scm_t_port;
6457 pub fn scm_i_mode_bits(modes: SCM) -> c_long;
6458 pub fn scm_i_dynwind_current_load_port(port: SCM);
6459 pub fn scm_setbuf0(port: SCM) -> SCM;
6460 pub fn scm_setvbuf(port: SCM, mode: SCM, size: SCM) -> SCM;
6461 pub fn scm_evict_ports(fd: c_int);
6462 pub fn scm_open_file_with_encoding(filename: SCM, modes: SCM,
6463 guess_encoding: SCM, encoding: SCM)
6464 -> SCM;
6465 pub fn scm_open_file(filename: SCM, modes: SCM) -> SCM;
6466 pub fn scm_fdes_to_port(fdes: c_int,
6467 mode: *mut c_char, name: SCM)
6468 -> SCM;
6469 pub fn scm_file_port_p(obj: SCM) -> SCM;
6470 pub fn scm_init_fports_keywords();
6471 pub fn scm_init_fports();
6472 pub fn scm_i_fdes_to_port(fdes: c_int,
6473 mode_bits: c_long, name: SCM)
6474 -> SCM;
6475 pub fn scm_c_hook_init(hook: *mut scm_t_c_hook,
6476 hook_data: *mut c_void,
6477 _type: scm_t_c_hook_type);
6478 pub fn scm_c_hook_add(hook: *mut scm_t_c_hook,
6479 func: scm_t_c_hook_function,
6480 fn_data: *mut c_void,
6481 appendp: c_int);
6482 pub fn scm_c_hook_remove(hook: *mut scm_t_c_hook,
6483 func: scm_t_c_hook_function,
6484 fn_data: *mut c_void);
6485 pub fn scm_c_hook_run(hook: *mut scm_t_c_hook,
6486 data: *mut c_void)
6487 -> *mut c_void;
6488 pub fn scm_make_hook(n_args: SCM) -> SCM;
6489 pub fn scm_hook_p(x: SCM) -> SCM;
6490 pub fn scm_hook_empty_p(hook: SCM) -> SCM;
6491 pub fn scm_add_hook_x(hook: SCM, thunk: SCM, appendp: SCM) -> SCM;
6492 pub fn scm_remove_hook_x(hook: SCM, thunk: SCM) -> SCM;
6493 pub fn scm_reset_hook_x(hook: SCM) -> SCM;
6494 pub fn scm_run_hook(hook: SCM, args: SCM) -> SCM;
6495 pub fn scm_c_run_hook(hook: SCM, args: SCM);
6496 pub fn scm_c_run_hookn(hook: SCM, argv: *mut SCM, nargs: size_t);
6497 pub fn scm_hook_to_list(hook: SCM) -> SCM;
6498 pub fn scm_init_hooks();
6499 pub fn scm_set_debug_cell_accesses_x(flag: SCM) -> SCM;
6500 pub fn scm_object_address(obj: SCM) -> SCM;
6501 pub fn scm_gc_enable() -> SCM;
6502 pub fn scm_gc_disable() -> SCM;
6503 pub fn scm_gc_dump() -> SCM;
6504 pub fn scm_gc_stats() -> SCM;
6505 pub fn scm_gc() -> SCM;
6506 pub fn scm_i_gc(what: *const c_char);
6507 pub fn scm_gc_mark(p: SCM);
6508 pub fn scm_gc_sweep();
6509 pub fn scm_gc_register_allocation(size: size_t);
6510 pub fn scm_malloc(size: size_t) -> *mut c_void;
6511 pub fn scm_calloc(size: size_t) -> *mut c_void;
6512 pub fn scm_realloc(mem: *mut c_void, size: size_t)
6513 -> *mut c_void;
6514 pub fn scm_strdup(str: *const c_char)
6515 -> *mut c_char;
6516 pub fn scm_strndup(str: *const c_char, n: size_t)
6517 -> *mut c_char;
6518 pub fn scm_gc_register_collectable_memory(mem:
6519 *mut c_void,
6520 size: size_t,
6521 what:
6522 *const c_char);
6523 pub fn scm_gc_unregister_collectable_memory(mem:
6524 *mut c_void,
6525 size: size_t,
6526 what:
6527 *const c_char);
6528 pub fn scm_gc_malloc_pointerless(size: size_t,
6529 what: *const c_char)
6530 -> *mut c_void;
6531 pub fn scm_gc_calloc(size: size_t, what: *const c_char)
6532 -> *mut c_void;
6533 pub fn scm_gc_malloc(size: size_t, what: *const c_char)
6534 -> *mut c_void;
6535 pub fn scm_gc_realloc(mem: *mut c_void, old_size: size_t,
6536 new_size: size_t,
6537 what: *const c_char)
6538 -> *mut c_void;
6539 pub fn scm_gc_free(mem: *mut c_void, size: size_t,
6540 what: *const c_char);
6541 pub fn scm_gc_strdup(str: *const c_char,
6542 what: *const c_char)
6543 -> *mut c_char;
6544 pub fn scm_gc_strndup(str: *const c_char, n: size_t,
6545 what: *const c_char)
6546 -> *mut c_char;
6547 pub fn scm_cell(car: scm_t_bits, cdr: scm_t_bits) -> SCM;
6548 pub fn scm_double_cell(car: scm_t_bits, cbr: scm_t_bits, ccr: scm_t_bits,
6549 cdr: scm_t_bits) -> SCM;
6550 pub fn scm_words(car: scm_t_bits, n_words: scm_t_uint16) -> SCM;
6551 pub fn scm_remember_upto_here_1(obj: SCM);
6552 pub fn scm_remember_upto_here_2(obj1: SCM, obj2: SCM);
6553 pub fn scm_remember_upto_here(obj1: SCM, ...);
6554 pub fn scm_return_first(elt: SCM, ...) -> SCM;
6555 pub fn scm_return_first_int(x: c_int, ...)
6556 -> c_int;
6557 pub fn scm_permanent_object(obj: SCM) -> SCM;
6558 pub fn scm_gc_protect_object(obj: SCM) -> SCM;
6559 pub fn scm_gc_unprotect_object(obj: SCM) -> SCM;
6560 pub fn scm_gc_register_root(p: *mut SCM);
6561 pub fn scm_gc_unregister_root(p: *mut SCM);
6562 pub fn scm_gc_register_roots(b: *mut SCM, n: c_ulong);
6563 pub fn scm_gc_unregister_roots(b: *mut SCM, n: c_ulong);
6564 pub fn scm_storage_prehistory();
6565 pub fn scm_init_gc_protect_object();
6566 pub fn scm_init_gc();
6567 pub fn scm_deprecated_newcell() -> SCM;
6568 pub fn scm_deprecated_newcell2() -> SCM;
6569 pub fn scm_must_malloc(len: size_t, what: *const c_char)
6570 -> *mut c_void;
6571 pub fn scm_must_realloc(_where: *mut c_void, olen: size_t,
6572 len: size_t, what: *const c_char)
6573 -> *mut c_void;
6574 pub fn scm_must_strdup(str: *const c_char)
6575 -> *mut c_char;
6576 pub fn scm_must_strndup(str: *const c_char, n: size_t)
6577 -> *mut c_char;
6578 pub fn scm_done_malloc(size: c_long);
6579 pub fn scm_done_free(size: c_long);
6580 pub fn scm_must_free(obj: *mut c_void);
6581 pub fn scm_init_gdbint();
6582 pub fn scm_is_array(obj: SCM) -> c_int;
6583 pub fn scm_array_p(v: SCM, unused: SCM) -> SCM;
6584 pub fn scm_array_p_2(arg1: SCM) -> SCM;
6585 pub fn scm_is_typed_array(obj: SCM, _type: SCM) -> c_int;
6586 pub fn scm_typed_array_p(v: SCM, _type: SCM) -> SCM;
6587 pub fn scm_c_array_rank(ra: SCM) -> size_t;
6588 pub fn scm_array_rank(ra: SCM) -> SCM;
6589 pub fn scm_c_array_length(ra: SCM) -> size_t;
6590 pub fn scm_array_length(ra: SCM) -> SCM;
6591 pub fn scm_array_dimensions(ra: SCM) -> SCM;
6592 pub fn scm_array_type(ra: SCM) -> SCM;
6593 pub fn scm_array_in_bounds_p(v: SCM, args: SCM) -> SCM;
6594 pub fn scm_c_array_ref_1(v: SCM, idx0: ssize_t) -> SCM;
6595 pub fn scm_c_array_ref_2(v: SCM, idx0: ssize_t, idx1: ssize_t) -> SCM;
6596 pub fn scm_c_array_set_1_x(v: SCM, obj: SCM, idx0: ssize_t);
6597 pub fn scm_c_array_set_2_x(v: SCM, obj: SCM, idx0: ssize_t,
6598 idx1: ssize_t);
6599 pub fn scm_array_ref(v: SCM, args: SCM) -> SCM;
6600 pub fn scm_array_set_x(v: SCM, obj: SCM, args: SCM) -> SCM;
6601 pub fn scm_array_to_list(v: SCM) -> SCM;
6602 pub fn scm_init_generalized_arrays();
6603 pub fn scm_is_generalized_vector(obj: SCM) -> c_int;
6604 pub fn scm_c_generalized_vector_length(v: SCM) -> size_t;
6605 pub fn scm_c_generalized_vector_ref(v: SCM, idx: size_t) -> SCM;
6606 pub fn scm_c_generalized_vector_set_x(v: SCM, idx: size_t, val: SCM);
6607 pub fn scm_generalized_vector_get_handle(vec: SCM,
6608 h: *mut scm_t_array_handle);
6609 pub fn scm_make_generalized_vector(_type: SCM, len: SCM, fill: SCM)
6610 -> SCM;
6611 pub fn scm_i_register_vector_constructor(_type: SCM,
6612 ctor:
6613 ::std::option::Option<extern "C" fn(arg1:
6614 SCM,
6615 arg2:
6616 SCM)
6617 ->
6618 SCM>);
6619 pub fn scm_init_generalized_vectors();
6620 pub fn scm_goops_version() -> SCM;
6621 pub fn scm_oldfmt(arg1: SCM) -> SCM;
6622 pub fn scm_c_oldfmt0(arg1: *mut c_char)
6623 -> *mut c_char;
6624 pub fn scm_c_oldfmt(arg1: *mut c_char,
6625 n: c_int)
6626 -> *mut c_char;
6627 pub fn scm_load_goops();
6628 pub fn scm_make_extended_class(type_name: *const c_char,
6629 applicablep: c_int) -> SCM;
6630 pub fn scm_make_port_classes(ptobnum: c_long,
6631 type_name: *mut c_char);
6632 pub fn scm_ensure_accessor(name: SCM) -> SCM;
6633 pub fn scm_class_of(obj: SCM) -> SCM;
6634 pub fn scm_make_next_method(methods: SCM, args: SCM, gf: SCM) -> SCM;
6635 pub fn scm_basic_basic_make_class(c: SCM, name: SCM, dsupers: SCM,
6636 dslots: SCM) -> SCM;
6637 pub fn scm_basic_make_class(c: SCM, name: SCM, dsupers: SCM, dslots: SCM)
6638 -> SCM;
6639 pub fn scm_sys_allocate_instance(c: SCM, initargs: SCM) -> SCM;
6640 pub fn scm_sys_set_object_setter_x(obj: SCM, setter: SCM) -> SCM;
6641 pub fn scm_slot_ref(obj: SCM, slot_name: SCM) -> SCM;
6642 pub fn scm_slot_set_x(obj: SCM, slot_name: SCM, value: SCM) -> SCM;
6643 pub fn scm_compute_applicable_methods(gf: SCM, args: SCM,
6644 len: c_long,
6645 scm_find_method:
6646 c_int) -> SCM;
6647 pub fn scm_sys_compute_applicable_methods(gf: SCM, args: SCM) -> SCM;
6648 pub fn scm_sys_compute_slots(c: SCM) -> SCM;
6649 pub fn scm_i_inherit_applicable(c: SCM);
6650 pub fn scm_i_get_keyword(key: SCM, l: SCM, len: c_long,
6651 default_value: SCM,
6652 subr: *const c_char) -> SCM;
6653 pub fn scm_get_keyword(key: SCM, l: SCM, default_value: SCM) -> SCM;
6654 pub fn scm_sys_initialize_object(obj: SCM, initargs: SCM) -> SCM;
6655 pub fn scm_sys_prep_layout_x(c: SCM) -> SCM;
6656 pub fn scm_sys_inherit_magic_x(c: SCM, dsupers: SCM) -> SCM;
6657 pub fn scm_instance_p(obj: SCM) -> SCM;
6658 pub fn scm_class_name(obj: SCM) -> SCM;
6659 pub fn scm_class_direct_supers(obj: SCM) -> SCM;
6660 pub fn scm_class_direct_slots(obj: SCM) -> SCM;
6661 pub fn scm_class_direct_subclasses(obj: SCM) -> SCM;
6662 pub fn scm_class_direct_methods(obj: SCM) -> SCM;
6663 pub fn scm_class_precedence_list(obj: SCM) -> SCM;
6664 pub fn scm_class_slots(obj: SCM) -> SCM;
6665 pub fn scm_generic_function_name(obj: SCM) -> SCM;
6666 pub fn scm_generic_function_methods(obj: SCM) -> SCM;
6667 pub fn scm_method_generic_function(obj: SCM) -> SCM;
6668 pub fn scm_method_specializers(obj: SCM) -> SCM;
6669 pub fn scm_method_procedure(obj: SCM) -> SCM;
6670 pub fn scm_sys_fast_slot_ref(obj: SCM, index: SCM) -> SCM;
6671 pub fn scm_sys_fast_slot_set_x(obj: SCM, index: SCM, value: SCM) -> SCM;
6672 pub fn scm_slot_ref_using_class(cls: SCM, obj: SCM, slot_name: SCM)
6673 -> SCM;
6674 pub fn scm_slot_set_using_class_x(cls: SCM, obj: SCM, slot_name: SCM,
6675 value: SCM) -> SCM;
6676 pub fn scm_slot_bound_using_class_p(cls: SCM, obj: SCM, slot_name: SCM)
6677 -> SCM;
6678 pub fn scm_slot_exists_using_class_p(cls: SCM, obj: SCM, slot_name: SCM)
6679 -> SCM;
6680 pub fn scm_slot_bound_p(obj: SCM, slot_name: SCM) -> SCM;
6681 pub fn scm_slot_exists_p(obj: SCM, slot_name: SCM) -> SCM;
6682 pub fn scm_sys_modify_instance(old: SCM, newinst: SCM) -> SCM;
6683 pub fn scm_sys_modify_class(old: SCM, newcls: SCM) -> SCM;
6684 pub fn scm_sys_invalidate_class(cls: SCM) -> SCM;
6685 pub fn scm_sys_invalidate_method_cache_x(gf: SCM) -> SCM;
6686 pub fn scm_generic_capability_p(_proc: SCM) -> SCM;
6687 pub fn scm_enable_primitive_generic_x(subrs: SCM) -> SCM;
6688 pub fn scm_set_primitive_generic_x(subr: SCM, generic: SCM) -> SCM;
6689 pub fn scm_primitive_generic_generic(subr: SCM) -> SCM;
6690 pub fn scm_c_extend_primitive_generic(subr: SCM, extension: SCM);
6691 pub fn stklos_version() -> SCM;
6692 pub fn scm_make(args: SCM) -> SCM;
6693 pub fn scm_find_method(args: SCM) -> SCM;
6694 pub fn scm_sys_method_more_specific_p(m1: SCM, m2: SCM, targs: SCM)
6695 -> SCM;
6696 pub fn scm_change_object_class(arg1: SCM, arg2: SCM, arg3: SCM);
6697 pub fn scm_call_generic_3(gf: SCM, a1: SCM, a2: SCM, a3: SCM) -> SCM;
6698 pub fn scm_i_define_class_for_vtable(vtable: SCM) -> SCM;
6699 pub fn scm_init_goops_builtins() -> SCM;
6700 pub fn scm_init_goops();
6701 pub fn scm_subr_objcode_trampoline(nreq: c_uint,
6702 nopt: c_uint,
6703 rest: c_uint) -> SCM;
6704 pub fn scm_c_make_gsubr(name: *const c_char,
6705 req: c_int,
6706 opt: c_int,
6707 rst: c_int, fcn: scm_t_subr)
6708 -> SCM;
6709 pub fn scm_c_make_gsubr_with_generic(name: *const c_char,
6710 req: c_int,
6711 opt: c_int,
6712 rst: c_int,
6713 fcn: scm_t_subr, gf: *mut SCM)
6714 -> SCM;
6715 pub fn scm_c_define_gsubr(name: *const c_char,
6716 req: c_int,
6717 opt: c_int,
6718 rst: c_int, fcn: scm_t_subr)
6719 -> SCM;
6720 pub fn scm_c_define_gsubr_with_generic(name:
6721 *const c_char,
6722 req: c_int,
6723 opt: c_int,
6724 rst: c_int,
6725 fcn: scm_t_subr, gf: *mut SCM)
6726 -> SCM;
6727 pub fn scm_init_gsubr();
6728 pub fn scm_make_guardian() -> SCM;
6729 pub fn scm_i_init_guardians_for_gc();
6730 pub fn scm_i_identify_inaccessible_guardeds();
6731 pub fn scm_i_mark_inaccessible_guardeds() -> c_int;
6732 pub fn scm_init_guardians();
6733 pub fn scm_string_hash(str: *const c_uchar, len: size_t)
6734 -> c_ulong;
6735 pub fn scm_i_locale_string_hash(str: *const c_char,
6736 len: size_t) -> c_ulong;
6737 pub fn scm_i_latin1_string_hash(str: *const c_char,
6738 len: size_t) -> c_ulong;
6739 pub fn scm_i_utf8_string_hash(str: *const c_char,
6740 len: size_t) -> c_ulong;
6741 pub fn scm_i_string_hash(str: SCM) -> c_ulong;
6742 pub fn scm_hasher(obj: SCM, n: c_ulong, d: size_t)
6743 -> c_ulong;
6744 pub fn scm_ihashq(obj: SCM, n: c_ulong)
6745 -> c_ulong;
6746 pub fn scm_hashq(obj: SCM, n: SCM) -> SCM;
6747 pub fn scm_ihashv(obj: SCM, n: c_ulong)
6748 -> c_ulong;
6749 pub fn scm_hashv(obj: SCM, n: SCM) -> SCM;
6750 pub fn scm_ihash(obj: SCM, n: c_ulong)
6751 -> c_ulong;
6752 pub fn scm_hash(obj: SCM, n: SCM) -> SCM;
6753 pub fn scm_init_hash();
6754 pub fn scm_weak_car_pair(car: SCM, cdr: SCM) -> SCM;
6755 pub fn scm_weak_cdr_pair(car: SCM, cdr: SCM) -> SCM;
6756 pub fn scm_doubly_weak_pair(car: SCM, cdr: SCM) -> SCM;
6757 pub fn scm_make_weak_vector(k: SCM, fill: SCM) -> SCM;
6758 pub fn scm_weak_vector(l: SCM) -> SCM;
6759 pub fn scm_weak_vector_p(x: SCM) -> SCM;
6760 pub fn scm_weak_vector_length(v: SCM) -> SCM;
6761 pub fn scm_weak_vector_ref(v: SCM, k: SCM) -> SCM;
6762 pub fn scm_weak_vector_set_x(v: SCM, k: SCM, x: SCM) -> SCM;
6763 pub fn scm_c_make_weak_vector(k: size_t, fill: SCM) -> SCM;
6764 pub fn scm_is_weak_vector(obj: SCM) -> c_int;
6765 pub fn scm_c_weak_vector_length(vec: SCM) -> size_t;
6766 pub fn scm_c_weak_vector_ref(v: SCM, k: size_t) -> SCM;
6767 pub fn scm_c_weak_vector_set_x(v: SCM, k: size_t, x: SCM);
6768 pub fn scm_make_weak_key_alist_vector(k: SCM) -> SCM;
6769 pub fn scm_make_weak_value_alist_vector(k: SCM) -> SCM;
6770 pub fn scm_make_doubly_weak_alist_vector(k: SCM) -> SCM;
6771 pub fn scm_weak_key_alist_vector_p(x: SCM) -> SCM;
6772 pub fn scm_weak_value_alist_vector_p(x: SCM) -> SCM;
6773 pub fn scm_doubly_weak_alist_vector_p(x: SCM) -> SCM;
6774 pub fn scm_init_weaks_builtins() -> SCM;
6775 pub fn scm_weaks_prehistory();
6776 pub fn scm_init_weaks();
6777 pub fn scm_i_init_weak_vectors_for_gc();
6778 pub fn scm_i_mark_weak_vector(w: SCM);
6779 pub fn scm_i_mark_weak_vectors_non_weaks() -> c_int;
6780 pub fn scm_i_remove_weaks_from_weak_vectors();
6781 pub fn scm_vector_to_hash_table(vector: SCM) -> SCM;
6782 pub fn scm_c_make_hash_table(k: c_ulong) -> SCM;
6783 pub fn scm_make_hash_table(n: SCM) -> SCM;
6784 pub fn scm_make_weak_key_hash_table(k: SCM) -> SCM;
6785 pub fn scm_make_weak_value_hash_table(k: SCM) -> SCM;
6786 pub fn scm_make_doubly_weak_hash_table(k: SCM) -> SCM;
6787 pub fn scm_hash_table_p(h: SCM) -> SCM;
6788 pub fn scm_weak_key_hash_table_p(h: SCM) -> SCM;
6789 pub fn scm_weak_value_hash_table_p(h: SCM) -> SCM;
6790 pub fn scm_doubly_weak_hash_table_p(h: SCM) -> SCM;
6791 pub fn scm_i_rehash(table: SCM, hash_fn: scm_t_hash_fn,
6792 closure: *mut c_void,
6793 func_name: *const c_char);
6794 pub fn scm_hash_fn_get_handle(table: SCM, obj: SCM,
6795 hash_fn: scm_t_hash_fn,
6796 assoc_fn: scm_t_assoc_fn,
6797 closure: *mut c_void)
6798 -> SCM;
6799 pub fn scm_hash_fn_get_handle_by_hash(table: SCM,
6800 raw_hash: c_ulong,
6801 predicate_fn:
6802 scm_t_hash_predicate_fn,
6803 closure:
6804 *mut c_void)
6805 -> SCM;
6806 pub fn scm_hash_fn_create_handle_x(table: SCM, obj: SCM, init: SCM,
6807 hash_fn: scm_t_hash_fn,
6808 assoc_fn: scm_t_assoc_fn,
6809 closure: *mut c_void)
6810 -> SCM;
6811 pub fn scm_hash_fn_ref(table: SCM, obj: SCM, dflt: SCM,
6812 hash_fn: scm_t_hash_fn, assoc_fn: scm_t_assoc_fn,
6813 closure: *mut c_void) -> SCM;
6814 pub fn scm_hash_fn_set_x(table: SCM, obj: SCM, val: SCM,
6815 hash_fn: scm_t_hash_fn, assoc_fn: scm_t_assoc_fn,
6816 closure: *mut c_void) -> SCM;
6817 pub fn scm_hash_fn_remove_x(table: SCM, obj: SCM, hash_fn: scm_t_hash_fn,
6818 assoc_fn: scm_t_assoc_fn,
6819 closure: *mut c_void) -> SCM;
6820 pub fn scm_internal_hash_fold(_fn: scm_t_hash_fold_fn,
6821 closure: *mut c_void,
6822 init: SCM, table: SCM) -> SCM;
6823 pub fn scm_internal_hash_for_each_handle(_fn: scm_t_hash_handle_fn,
6824 closure:
6825 *mut c_void,
6826 table: SCM);
6827 pub fn scm_hash_clear_x(table: SCM) -> SCM;
6828 pub fn scm_hashq_get_handle(table: SCM, obj: SCM) -> SCM;
6829 pub fn scm_hashq_create_handle_x(table: SCM, obj: SCM, init: SCM) -> SCM;
6830 pub fn scm_hashq_ref(table: SCM, obj: SCM, dflt: SCM) -> SCM;
6831 pub fn scm_hashq_set_x(table: SCM, obj: SCM, val: SCM) -> SCM;
6832 pub fn scm_hashq_remove_x(table: SCM, obj: SCM) -> SCM;
6833 pub fn scm_hashv_get_handle(table: SCM, obj: SCM) -> SCM;
6834 pub fn scm_hashv_create_handle_x(table: SCM, obj: SCM, init: SCM) -> SCM;
6835 pub fn scm_hashv_ref(table: SCM, obj: SCM, dflt: SCM) -> SCM;
6836 pub fn scm_hashv_set_x(table: SCM, obj: SCM, val: SCM) -> SCM;
6837 pub fn scm_hashv_remove_x(table: SCM, obj: SCM) -> SCM;
6838 pub fn scm_hash_get_handle(table: SCM, obj: SCM) -> SCM;
6839 pub fn scm_hash_create_handle_x(table: SCM, obj: SCM, init: SCM) -> SCM;
6840 pub fn scm_hash_ref(table: SCM, obj: SCM, dflt: SCM) -> SCM;
6841 pub fn scm_hash_set_x(table: SCM, obj: SCM, val: SCM) -> SCM;
6842 pub fn scm_hash_remove_x(table: SCM, obj: SCM) -> SCM;
6843 pub fn scm_hashx_get_handle(hash: SCM, assoc: SCM, table: SCM, obj: SCM)
6844 -> SCM;
6845 pub fn scm_hashx_create_handle_x(hash: SCM, assoc: SCM, table: SCM,
6846 obj: SCM, init: SCM) -> SCM;
6847 pub fn scm_hashx_ref(hash: SCM, assoc: SCM, table: SCM, obj: SCM,
6848 dflt: SCM) -> SCM;
6849 pub fn scm_hashx_set_x(hash: SCM, assoc: SCM, table: SCM, obj: SCM,
6850 val: SCM) -> SCM;
6851 pub fn scm_hashx_remove_x(hash: SCM, assoc: SCM, table: SCM, obj: SCM)
6852 -> SCM;
6853 pub fn scm_hash_fold(_proc: SCM, init: SCM, hash: SCM) -> SCM;
6854 pub fn scm_hash_for_each(_proc: SCM, hash: SCM) -> SCM;
6855 pub fn scm_hash_for_each_handle(_proc: SCM, hash: SCM) -> SCM;
6856 pub fn scm_hash_map_to_list(_proc: SCM, hash: SCM) -> SCM;
6857 pub fn scm_hash_count(hash: SCM, pred: SCM) -> SCM;
6858 pub fn scm_i_hashtable_print(exp: SCM, port: SCM,
6859 pstate: *mut scm_print_state);
6860 pub fn scm_init_hashtab();
6861 pub fn scm_make_locale(category_mask: SCM, locale_name: SCM,
6862 base_locale: SCM) -> SCM;
6863 pub fn scm_locale_p(obj: SCM) -> SCM;
6864 pub fn scm_string_locale_lt(s1: SCM, s2: SCM, locale: SCM) -> SCM;
6865 pub fn scm_string_locale_gt(s1: SCM, s2: SCM, locale: SCM) -> SCM;
6866 pub fn scm_string_locale_ci_lt(s1: SCM, s2: SCM, locale: SCM) -> SCM;
6867 pub fn scm_string_locale_ci_gt(s1: SCM, s2: SCM, locale: SCM) -> SCM;
6868 pub fn scm_string_locale_ci_eq(s1: SCM, s2: SCM, locale: SCM) -> SCM;
6869 pub fn scm_char_locale_lt(c1: SCM, c2: SCM, locale: SCM) -> SCM;
6870 pub fn scm_char_locale_gt(c1: SCM, c2: SCM, locale: SCM) -> SCM;
6871 pub fn scm_char_locale_ci_lt(c1: SCM, c2: SCM, locale: SCM) -> SCM;
6872 pub fn scm_char_locale_ci_gt(c1: SCM, c2: SCM, locale: SCM) -> SCM;
6873 pub fn scm_char_locale_ci_eq(c1: SCM, c2: SCM, locale: SCM) -> SCM;
6874 pub fn scm_char_locale_upcase(chr: SCM, locale: SCM) -> SCM;
6875 pub fn scm_char_locale_downcase(chr: SCM, locale: SCM) -> SCM;
6876 pub fn scm_char_locale_titlecase(chr: SCM, locale: SCM) -> SCM;
6877 pub fn scm_string_locale_upcase(chr: SCM, locale: SCM) -> SCM;
6878 pub fn scm_string_locale_downcase(chr: SCM, locale: SCM) -> SCM;
6879 pub fn scm_string_locale_titlecase(chr: SCM, locale: SCM) -> SCM;
6880 pub fn scm_locale_string_to_integer(str: SCM, base: SCM, locale: SCM)
6881 -> SCM;
6882 pub fn scm_locale_string_to_inexact(str: SCM, locale: SCM) -> SCM;
6883 pub fn scm_nl_langinfo(item: SCM, locale: SCM) -> SCM;
6884 pub fn scm_init_i18n();
6885 pub fn scm_bootstrap_i18n();
6886 pub fn scm_init_guile();
6887 pub fn scm_boot_guile(argc: c_int,
6888 argv: *mut *mut c_char,
6889 main_func:
6890 ::std::option::Option<unsafe extern "C" fn(closure:
6891 *mut c_void,
6892 argc:
6893 c_int,
6894 argv:
6895 *mut *mut c_char)>,
6896 closure: *mut c_void);
6897 pub fn scm_i_init_guile(base: *mut c_void);
6898 pub fn scm_load_startup_files();
6899 pub fn scm_ftell(object: SCM) -> SCM;
6900 pub fn scm_redirect_port(into_pt: SCM, from_pt: SCM) -> SCM;
6901 pub fn scm_dup_to_fdes(fd_or_port: SCM, newfd: SCM) -> SCM;
6902 pub fn scm_dup2(oldfd: SCM, newfd: SCM) -> SCM;
6903 pub fn scm_fileno(port: SCM) -> SCM;
6904 pub fn scm_isatty_p(port: SCM) -> SCM;
6905 pub fn scm_fdopen(fdes: SCM, modes: SCM) -> SCM;
6906 pub fn scm_primitive_move_to_fdes(port: SCM, fd: SCM) -> SCM;
6907 pub fn scm_fdes_to_ports(fd: SCM) -> SCM;
6908 pub fn scm_init_ioext();
6909 pub fn scm_read_delimited_x(delims: SCM, buf: SCM, gobble: SCM, port: SCM,
6910 offset: SCM, length: SCM) -> SCM;
6911 pub fn scm_read_line(port: SCM) -> SCM;
6912 pub fn scm_write_line(obj: SCM, port: SCM) -> SCM;
6913 pub fn scm_init_rdelim_builtins() -> SCM;
6914 pub fn scm_init_rdelim();
6915 pub fn scm_read_string_x_partial(str: SCM, port_or_fdes: SCM, start: SCM,
6916 end: SCM) -> SCM;
6917 pub fn scm_write_string_partial(str: SCM, port_or_fdes: SCM, start: SCM,
6918 end: SCM) -> SCM;
6919 pub fn scm_init_rw_builtins() -> SCM;
6920 pub fn scm_init_rw();
6921 pub fn scm_keyword_p(obj: SCM) -> SCM;
6922 pub fn scm_symbol_to_keyword(symbol: SCM) -> SCM;
6923 pub fn scm_keyword_to_symbol(keyword: SCM) -> SCM;
6924 pub fn scm_is_keyword(val: SCM) -> c_int;
6925 pub fn scm_from_locale_keyword(name: *const c_char)
6926 -> SCM;
6927 pub fn scm_from_locale_keywordn(name: *const c_char,
6928 len: size_t) -> SCM;
6929 pub fn scm_from_latin1_keyword(name: *const c_char)
6930 -> SCM;
6931 pub fn scm_from_utf8_keyword(name: *const c_char) -> SCM;
6932 pub fn scm_c_bind_keyword_arguments(subr: *const c_char,
6933 rest: SCM,
6934 flags:
6935 scm_t_keyword_arguments_flags, ...);
6936 pub fn scm_init_keywords();
6937 pub fn scm_list_1(e1: SCM) -> SCM;
6938 pub fn scm_list_2(e1: SCM, e2: SCM) -> SCM;
6939 pub fn scm_list_3(e1: SCM, e2: SCM, e3: SCM) -> SCM;
6940 pub fn scm_list_4(e1: SCM, e2: SCM, e3: SCM, e4: SCM) -> SCM;
6941 pub fn scm_list_5(e1: SCM, e2: SCM, e3: SCM, e4: SCM, e5: SCM) -> SCM;
6942 pub fn scm_list_n(elt: SCM, ...) -> SCM;
6943 pub fn scm_list(objs: SCM) -> SCM;
6944 pub fn scm_list_head(lst: SCM, k: SCM) -> SCM;
6945 pub fn scm_make_list(n: SCM, init: SCM) -> SCM;
6946 pub fn scm_cons_star(arg: SCM, objs: SCM) -> SCM;
6947 pub fn scm_null_p(x: SCM) -> SCM;
6948 pub fn scm_list_p(x: SCM) -> SCM;
6949 pub fn scm_ilength(sx: SCM) -> c_long;
6950 pub fn scm_length(x: SCM) -> SCM;
6951 pub fn scm_append(args: SCM) -> SCM;
6952 pub fn scm_append_x(args: SCM) -> SCM;
6953 pub fn scm_reverse(lst: SCM) -> SCM;
6954 pub fn scm_reverse_x(lst: SCM, newtail: SCM) -> SCM;
6955 pub fn scm_list_ref(lst: SCM, k: SCM) -> SCM;
6956 pub fn scm_list_set_x(lst: SCM, k: SCM, val: SCM) -> SCM;
6957 pub fn scm_list_cdr_set_x(lst: SCM, k: SCM, val: SCM) -> SCM;
6958 pub fn scm_last_pair(sx: SCM) -> SCM;
6959 pub fn scm_list_tail(lst: SCM, k: SCM) -> SCM;
6960 pub fn scm_c_memq(x: SCM, lst: SCM) -> SCM;
6961 pub fn scm_memq(x: SCM, lst: SCM) -> SCM;
6962 pub fn scm_memv(x: SCM, lst: SCM) -> SCM;
6963 pub fn scm_member(x: SCM, lst: SCM) -> SCM;
6964 pub fn scm_delq_x(item: SCM, lst: SCM) -> SCM;
6965 pub fn scm_delv_x(item: SCM, lst: SCM) -> SCM;
6966 pub fn scm_delete_x(item: SCM, lst: SCM) -> SCM;
6967 pub fn scm_list_copy(lst: SCM) -> SCM;
6968 pub fn scm_delq(item: SCM, lst: SCM) -> SCM;
6969 pub fn scm_delv(item: SCM, lst: SCM) -> SCM;
6970 pub fn scm_delete(item: SCM, lst: SCM) -> SCM;
6971 pub fn scm_delq1_x(item: SCM, lst: SCM) -> SCM;
6972 pub fn scm_delv1_x(item: SCM, lst: SCM) -> SCM;
6973 pub fn scm_delete1_x(item: SCM, lst: SCM) -> SCM;
6974 pub fn scm_filter(pred: SCM, list: SCM) -> SCM;
6975 pub fn scm_filter_x(pred: SCM, list: SCM) -> SCM;
6976 pub fn scm_copy_tree(obj: SCM) -> SCM;
6977 pub fn scm_i_finite_list_copy(arg1: SCM) -> SCM;
6978 pub fn scm_init_list();
6979 pub fn scm_parse_path(path: SCM, tail: SCM) -> SCM;
6980 pub fn scm_parse_path_with_ellipsis(path: SCM, base: SCM) -> SCM;
6981 pub fn scm_primitive_load(filename: SCM) -> SCM;
6982 pub fn scm_c_primitive_load(filename: *const c_char)
6983 -> SCM;
6984 pub fn scm_sys_package_data_dir() -> SCM;
6985 pub fn scm_sys_library_dir() -> SCM;
6986 pub fn scm_sys_site_dir() -> SCM;
6987 pub fn scm_sys_global_site_dir() -> SCM;
6988 pub fn scm_sys_site_ccache_dir() -> SCM;
6989 pub fn scm_search_path(path: SCM, filename: SCM, rest: SCM) -> SCM;
6990 pub fn scm_sys_search_load_path(filename: SCM) -> SCM;
6991 pub fn scm_primitive_load_path(filename_and_exception_on_not_found: SCM)
6992 -> SCM;
6993 pub fn scm_c_primitive_load_path(filename: *const c_char)
6994 -> SCM;
6995 pub fn scm_sys_warn_auto_compilation_enabled() -> SCM;
6996 pub fn scm_init_load_path();
6997 pub fn scm_init_load();
6998 pub fn scm_init_load_should_auto_compile();
6999 pub fn scm_init_eval_in_scheme();
7000 pub fn scm_make_syntax_transformer(name_or_existing_definition: SCM,
7001 _type: SCM, binding: SCM) -> SCM;
7002 pub fn scm_macro_p(obj: SCM) -> SCM;
7003 pub fn scm_macro_type(m: SCM) -> SCM;
7004 pub fn scm_macro_name(m: SCM) -> SCM;
7005 pub fn scm_macro_binding(m: SCM) -> SCM;
7006 pub fn scm_macro_transformer(m: SCM) -> SCM;
7007 pub fn scm_i_make_primitive_macro(name: *const c_char,
7008 _fn: scm_t_macro_primitive) -> SCM;
7009 pub fn scm_i_macro_primitive(m: SCM) -> scm_t_macro_primitive;
7010 pub fn scm_init_macros();
7011 pub fn scm_malloc_obj(n: size_t) -> SCM;
7012 pub fn scm_init_mallocs();
7013 pub fn scm_current_module() -> SCM;
7014 pub fn scm_the_root_module() -> SCM;
7015 pub fn scm_interaction_environment() -> SCM;
7016 pub fn scm_set_current_module(module: SCM) -> SCM;
7017 pub fn scm_c_call_with_current_module(module: SCM,
7018 func:
7019 ::std::option::Option<unsafe extern "C" fn(arg1:
7020 *mut c_void)
7021 ->
7022 SCM>,
7023 data: *mut c_void)
7024 -> SCM;
7025 pub fn scm_dynwind_current_module(module: SCM);
7026 pub fn scm_module_variable(module: SCM, sym: SCM) -> SCM;
7027 pub fn scm_module_local_variable(module: SCM, sym: SCM) -> SCM;
7028 pub fn scm_module_ensure_local_variable(module: SCM, sym: SCM) -> SCM;
7029 pub fn scm_c_lookup(name: *const c_char) -> SCM;
7030 pub fn scm_c_define(name: *const c_char, val: SCM) -> SCM;
7031 pub fn scm_lookup(symbol: SCM) -> SCM;
7032 pub fn scm_define(symbol: SCM, val: SCM) -> SCM;
7033 pub fn scm_c_module_lookup(module: SCM,
7034 name: *const c_char) -> SCM;
7035 pub fn scm_c_module_define(module: SCM,
7036 name: *const c_char, val: SCM)
7037 -> SCM;
7038 pub fn scm_module_lookup(module: SCM, symbol: SCM) -> SCM;
7039 pub fn scm_module_define(module: SCM, symbol: SCM, val: SCM) -> SCM;
7040 pub fn scm_module_export(module: SCM, symbol_list: SCM) -> SCM;
7041 pub fn scm_module_reverse_lookup(module: SCM, variable: SCM) -> SCM;
7042 pub fn scm_public_variable(module_name: SCM, name: SCM) -> SCM;
7043 pub fn scm_private_variable(module_name: SCM, name: SCM) -> SCM;
7044 pub fn scm_c_public_variable(module_name: *const c_char,
7045 name: *const c_char) -> SCM;
7046 pub fn scm_c_private_variable(module_name: *const c_char,
7047 name: *const c_char) -> SCM;
7048 pub fn scm_public_lookup(module_name: SCM, name: SCM) -> SCM;
7049 pub fn scm_private_lookup(module_name: SCM, name: SCM) -> SCM;
7050 pub fn scm_c_public_lookup(module_name: *const c_char,
7051 name: *const c_char) -> SCM;
7052 pub fn scm_c_private_lookup(module_name: *const c_char,
7053 name: *const c_char) -> SCM;
7054 pub fn scm_public_ref(module_name: SCM, name: SCM) -> SCM;
7055 pub fn scm_private_ref(module_name: SCM, name: SCM) -> SCM;
7056 pub fn scm_c_public_ref(module_name: *const c_char,
7057 name: *const c_char) -> SCM;
7058 pub fn scm_c_private_ref(module_name: *const c_char,
7059 name: *const c_char) -> SCM;
7060 pub fn scm_c_resolve_module(name: *const c_char) -> SCM;
7061 pub fn scm_resolve_module(name: SCM) -> SCM;
7062 pub fn scm_c_define_module(name: *const c_char,
7063 init:
7064 ::std::option::Option<unsafe extern "C" fn(arg1:
7065 *mut c_void)>,
7066 data: *mut c_void) -> SCM;
7067 pub fn scm_c_use_module(name: *const c_char);
7068 pub fn scm_c_export(name: *const c_char, ...);
7069 pub fn scm_module_public_interface(module: SCM) -> SCM;
7070 pub fn scm_module_import_interface(module: SCM, sym: SCM) -> SCM;
7071 pub fn scm_module_transformer(module: SCM) -> SCM;
7072 pub fn scm_current_module_transformer() -> SCM;
7073 pub fn scm_get_pre_modules_obarray() -> SCM;
7074 pub fn scm_modules_prehistory();
7075 pub fn scm_init_modules();
7076 pub fn scm_gethost(host: SCM) -> SCM;
7077 pub fn scm_getnet(name: SCM) -> SCM;
7078 pub fn scm_getproto(name: SCM) -> SCM;
7079 pub fn scm_getserv(name: SCM, proto: SCM) -> SCM;
7080 pub fn scm_sethost(arg: SCM) -> SCM;
7081 pub fn scm_setnet(arg: SCM) -> SCM;
7082 pub fn scm_setproto(arg: SCM) -> SCM;
7083 pub fn scm_setserv(arg: SCM) -> SCM;
7084 pub fn scm_getaddrinfo(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
7085 arg5: SCM, arg6: SCM) -> SCM;
7086 pub fn scm_gai_strerror(arg1: SCM) -> SCM;
7087 pub fn scm_init_net_db();
7088 pub fn scm_object_properties(obj: SCM) -> SCM;
7089 pub fn scm_set_object_properties_x(obj: SCM, plist: SCM) -> SCM;
7090 pub fn scm_object_property(obj: SCM, key: SCM) -> SCM;
7091 pub fn scm_set_object_property_x(obj: SCM, key: SCM, val: SCM) -> SCM;
7092 pub fn scm_init_objprop();
7093 pub fn scm_cons(x: SCM, y: SCM) -> SCM;
7094 pub fn scm_cons2(w: SCM, x: SCM, y: SCM) -> SCM;
7095 pub fn scm_pair_p(x: SCM) -> SCM;
7096 pub fn scm_car(x: SCM) -> SCM;
7097 pub fn scm_cdr(x: SCM) -> SCM;
7098 pub fn scm_set_car_x(pair: SCM, value: SCM) -> SCM;
7099 pub fn scm_set_cdr_x(pair: SCM, value: SCM) -> SCM;
7100 pub fn scm_cddr(x: SCM) -> SCM;
7101 pub fn scm_cdar(x: SCM) -> SCM;
7102 pub fn scm_cadr(x: SCM) -> SCM;
7103 pub fn scm_caar(x: SCM) -> SCM;
7104 pub fn scm_cdddr(x: SCM) -> SCM;
7105 pub fn scm_cddar(x: SCM) -> SCM;
7106 pub fn scm_cdadr(x: SCM) -> SCM;
7107 pub fn scm_cdaar(x: SCM) -> SCM;
7108 pub fn scm_caddr(x: SCM) -> SCM;
7109 pub fn scm_cadar(x: SCM) -> SCM;
7110 pub fn scm_caadr(x: SCM) -> SCM;
7111 pub fn scm_caaar(x: SCM) -> SCM;
7112 pub fn scm_cddddr(x: SCM) -> SCM;
7113 pub fn scm_cdddar(x: SCM) -> SCM;
7114 pub fn scm_cddadr(x: SCM) -> SCM;
7115 pub fn scm_cddaar(x: SCM) -> SCM;
7116 pub fn scm_cdaddr(x: SCM) -> SCM;
7117 pub fn scm_cdadar(x: SCM) -> SCM;
7118 pub fn scm_cdaadr(x: SCM) -> SCM;
7119 pub fn scm_cdaaar(x: SCM) -> SCM;
7120 pub fn scm_cadddr(x: SCM) -> SCM;
7121 pub fn scm_caddar(x: SCM) -> SCM;
7122 pub fn scm_cadadr(x: SCM) -> SCM;
7123 pub fn scm_cadaar(x: SCM) -> SCM;
7124 pub fn scm_caaddr(x: SCM) -> SCM;
7125 pub fn scm_caadar(x: SCM) -> SCM;
7126 pub fn scm_caaadr(x: SCM) -> SCM;
7127 pub fn scm_caaaar(x: SCM) -> SCM;
7128 pub fn scm_init_pairs();
7129 pub fn scm_tcsetpgrp(port: SCM, pgid: SCM) -> SCM;
7130 pub fn scm_tcgetpgrp(port: SCM) -> SCM;
7131 pub fn scm_ctermid() -> SCM;
7132 pub fn scm_setsid() -> SCM;
7133 pub fn scm_getsid(pid: SCM) -> SCM;
7134 pub fn scm_setpgid(pid: SCM, pgid: SCM) -> SCM;
7135 pub fn scm_pipe() -> SCM;
7136 pub fn scm_getgroups() -> SCM;
7137 pub fn scm_setgroups(groups: SCM) -> SCM;
7138 pub fn scm_getpgrp() -> SCM;
7139 pub fn scm_getpwuid(user: SCM) -> SCM;
7140 pub fn scm_setpwent(arg: SCM) -> SCM;
7141 pub fn scm_getgrgid(name: SCM) -> SCM;
7142 pub fn scm_setgrent(arg: SCM) -> SCM;
7143 pub fn scm_getrlimit(resource: SCM) -> SCM;
7144 pub fn scm_setrlimit(resource: SCM, soft: SCM, hard: SCM) -> SCM;
7145 pub fn scm_kill(pid: SCM, sig: SCM) -> SCM;
7146 pub fn scm_waitpid(pid: SCM, options: SCM) -> SCM;
7147 pub fn scm_status_exit_val(status: SCM) -> SCM;
7148 pub fn scm_status_term_sig(status: SCM) -> SCM;
7149 pub fn scm_status_stop_sig(status: SCM) -> SCM;
7150 pub fn scm_getppid() -> SCM;
7151 pub fn scm_getuid() -> SCM;
7152 pub fn scm_getgid() -> SCM;
7153 pub fn scm_geteuid() -> SCM;
7154 pub fn scm_getegid() -> SCM;
7155 pub fn scm_setuid(uid: SCM) -> SCM;
7156 pub fn scm_setgid(gid: SCM) -> SCM;
7157 pub fn scm_seteuid(euid: SCM) -> SCM;
7158 pub fn scm_setegid(egid: SCM) -> SCM;
7159 pub fn scm_ttyname(port: SCM) -> SCM;
7160 pub fn scm_execl(filename: SCM, args: SCM) -> SCM;
7161 pub fn scm_execlp(filename: SCM, args: SCM) -> SCM;
7162 pub fn scm_execle(filename: SCM, env: SCM, args: SCM) -> SCM;
7163 pub fn scm_fork() -> SCM;
7164 pub fn scm_uname() -> SCM;
7165 pub fn scm_environ(env: SCM) -> SCM;
7166 pub fn scm_tmpnam() -> SCM;
7167 pub fn scm_mkstemp(tmpl: SCM) -> SCM;
7168 pub fn scm_tmpfile() -> SCM;
7169 pub fn scm_open_pipe(pipestr: SCM, modes: SCM) -> SCM;
7170 pub fn scm_close_pipe(port: SCM) -> SCM;
7171 pub fn scm_utime(pathname: SCM, actime: SCM, modtime: SCM, actimens: SCM,
7172 modtimens: SCM, flags: SCM) -> SCM;
7173 pub fn scm_access(path: SCM, how: SCM) -> SCM;
7174 pub fn scm_getpid() -> SCM;
7175 pub fn scm_putenv(str: SCM) -> SCM;
7176 pub fn scm_setlocale(category: SCM, locale: SCM) -> SCM;
7177 pub fn scm_mknod(path: SCM, _type: SCM, perms: SCM, dev: SCM) -> SCM;
7178 pub fn scm_nice(incr: SCM) -> SCM;
7179 pub fn scm_sync() -> SCM;
7180 pub fn scm_crypt(key: SCM, salt: SCM) -> SCM;
7181 pub fn scm_chroot(path: SCM) -> SCM;
7182 pub fn scm_getlogin() -> SCM;
7183 pub fn scm_getpriority(which: SCM, who: SCM) -> SCM;
7184 pub fn scm_setpriority(which: SCM, who: SCM, prio: SCM) -> SCM;
7185 pub fn scm_getpass(prompt: SCM) -> SCM;
7186 pub fn scm_flock(file: SCM, operation: SCM) -> SCM;
7187 pub fn scm_sethostname(name: SCM) -> SCM;
7188 pub fn scm_gethostname() -> SCM;
7189 pub fn scm_getaffinity(pid: SCM) -> SCM;
7190 pub fn scm_setaffinity(pid: SCM, cpu_set: SCM) -> SCM;
7191 pub fn scm_init_posix();
7192 pub fn scm_i_procedure_arity(_proc: SCM, req: *mut c_int,
7193 opt: *mut c_int,
7194 rest: *mut c_int)
7195 -> c_int;
7196 pub fn scm_set_procedure_minimum_arity_x(_proc: SCM, req: SCM, opt: SCM,
7197 rest: SCM) -> SCM;
7198 pub fn scm_procedure_minimum_arity(_proc: SCM) -> SCM;
7199 pub fn scm_procedure_properties(_proc: SCM) -> SCM;
7200 pub fn scm_set_procedure_properties_x(_proc: SCM, alist: SCM) -> SCM;
7201 pub fn scm_procedure_property(_proc: SCM, key: SCM) -> SCM;
7202 pub fn scm_set_procedure_property_x(_proc: SCM, key: SCM, val: SCM)
7203 -> SCM;
7204 pub fn scm_init_procprop();
7205 pub fn scm_make_promise(thunk: SCM) -> SCM;
7206 pub fn scm_force(x: SCM) -> SCM;
7207 pub fn scm_promise_p(x: SCM) -> SCM;
7208 pub fn scm_init_promises();
7209 pub fn scm_eof_object() -> SCM;
7210 pub fn scm_open_bytevector_input_port(arg1: SCM, arg2: SCM) -> SCM;
7211 pub fn scm_make_custom_binary_input_port(arg1: SCM, arg2: SCM, arg3: SCM,
7212 arg4: SCM, arg5: SCM) -> SCM;
7213 pub fn scm_get_u8(arg1: SCM) -> SCM;
7214 pub fn scm_lookahead_u8(arg1: SCM) -> SCM;
7215 pub fn scm_get_bytevector_n(arg1: SCM, arg2: SCM) -> SCM;
7216 pub fn scm_get_bytevector_n_x(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
7217 -> SCM;
7218 pub fn scm_get_bytevector_some(arg1: SCM) -> SCM;
7219 pub fn scm_get_bytevector_all(arg1: SCM) -> SCM;
7220 pub fn scm_put_u8(arg1: SCM, arg2: SCM) -> SCM;
7221 pub fn scm_put_bytevector(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
7222 -> SCM;
7223 pub fn scm_open_bytevector_output_port(arg1: SCM) -> SCM;
7224 pub fn scm_make_custom_binary_output_port(arg1: SCM, arg2: SCM, arg3: SCM,
7225 arg4: SCM, arg5: SCM) -> SCM;
7226 pub fn scm_get_string_n_x(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
7227 -> SCM;
7228 pub fn scm_init_r6rs_ports();
7229 pub fn scm_register_r6rs_ports();
7230 pub fn scm_c_make_rstate(arg1: *const c_char,
7231 arg2: c_int)
7232 -> *mut scm_t_rstate;
7233 pub fn scm_c_rstate_from_datum(datum: SCM) -> *mut scm_t_rstate;
7234 pub fn scm_c_default_rstate() -> *mut scm_t_rstate;
7235 pub fn scm_c_uniform01(arg1: *mut scm_t_rstate)
7236 -> c_double;
7237 pub fn scm_c_normal01(arg1: *mut scm_t_rstate)
7238 -> c_double;
7239 pub fn scm_c_exp1(arg1: *mut scm_t_rstate) -> c_double;
7240 pub fn scm_c_random(arg1: *mut scm_t_rstate, m: scm_t_uint32)
7241 -> scm_t_uint32;
7242 pub fn scm_c_random64(state: *mut scm_t_rstate, m: scm_t_uint64)
7243 -> scm_t_uint64;
7244 pub fn scm_c_random_bignum(arg1: *mut scm_t_rstate, m: SCM) -> SCM;
7245 pub fn scm_random(n: SCM, state: SCM) -> SCM;
7246 pub fn scm_copy_random_state(state: SCM) -> SCM;
7247 pub fn scm_seed_to_random_state(seed: SCM) -> SCM;
7248 pub fn scm_datum_to_random_state(datum: SCM) -> SCM;
7249 pub fn scm_random_state_to_datum(state: SCM) -> SCM;
7250 pub fn scm_random_state_from_platform() -> SCM;
7251 pub fn scm_random_uniform(state: SCM) -> SCM;
7252 pub fn scm_random_solid_sphere_x(v: SCM, state: SCM) -> SCM;
7253 pub fn scm_random_hollow_sphere_x(v: SCM, state: SCM) -> SCM;
7254 pub fn scm_random_normal(state: SCM) -> SCM;
7255 pub fn scm_random_normal_vector_x(v: SCM, state: SCM) -> SCM;
7256 pub fn scm_random_exp(state: SCM) -> SCM;
7257 pub fn scm_init_random();
7258 pub fn scm_i_random_bytes_from_platform(buf: *mut c_uchar,
7259 len: size_t);
7260 pub fn scm_read_options(setting: SCM) -> SCM;
7261 pub fn scm_read(port: SCM) -> SCM;
7262 pub fn scm_read_hash_extend(chr: SCM, _proc: SCM) -> SCM;
7263 pub fn scm_i_scan_for_encoding(port: SCM) -> *mut c_char;
7264 pub fn scm_file_encoding(port: SCM) -> SCM;
7265 pub fn scm_i_input_error(func: *const c_char, port: SCM,
7266 message: *const c_char,
7267 arg: SCM);
7268 pub fn scm_init_read();
7269 pub fn scm_sigaction(signum: SCM, handler: SCM, flags: SCM) -> SCM;
7270 pub fn scm_sigaction_for_thread(signum: SCM, handler: SCM, flags: SCM,
7271 thread: SCM) -> SCM;
7272 pub fn scm_restore_signals() -> SCM;
7273 pub fn scm_alarm(i: SCM) -> SCM;
7274 pub fn scm_setitimer(which_timer: SCM, interval_seconds: SCM,
7275 interval_microseconds: SCM, value_seconds: SCM,
7276 value_microseconds: SCM) -> SCM;
7277 pub fn scm_getitimer(which_timer: SCM) -> SCM;
7278 pub fn scm_pause() -> SCM;
7279 pub fn scm_sleep(i: SCM) -> SCM;
7280 pub fn scm_usleep(i: SCM) -> SCM;
7281 pub fn scm_raise(sig: SCM) -> SCM;
7282 pub fn scm_init_scmsigs();
7283 pub fn scm_i_close_signal_pipe();
7284 pub fn scm_i_ensure_signal_delivery_thread();
7285 pub fn scm_find_executable(name: *const c_char)
7286 -> *mut c_char;
7287 pub fn scm_find_impl_file(exec_path: *mut c_char,
7288 generic_name: *const c_char,
7289 initname: *const c_char,
7290 sep: *const c_char)
7291 -> *mut c_char;
7292 pub fn scm_get_meta_args(argc: c_int,
7293 argv: *mut *mut c_char)
7294 -> *mut *mut c_char;
7295 pub fn scm_count_argv(argv: *mut *mut c_char)
7296 -> c_int;
7297 pub fn scm_shell_usage(fatal: c_int,
7298 message: *mut c_char);
7299 pub fn scm_compile_shell_switches(argc: c_int,
7300 argv: *mut *mut c_char)
7301 -> SCM;
7302 pub fn scm_shell(argc: c_int,
7303 argv: *mut *mut c_char);
7304 pub fn scm_i_set_boot_program_arguments(argc: c_int,
7305 argv:
7306 *mut *mut c_char);
7307 pub fn scm_init_script();
7308 pub fn scm_system(cmd: SCM) -> SCM;
7309 pub fn scm_system_star(cmds: SCM) -> SCM;
7310 pub fn scm_getenv(nam: SCM) -> SCM;
7311 pub fn scm_primitive_exit(status: SCM) -> SCM;
7312 pub fn scm_primitive__exit(status: SCM) -> SCM;
7313 pub fn scm_init_simpos();
7314 pub fn scm_i_new_smob(tc: scm_t_bits, arg1: scm_t_bits) -> SCM;
7315 pub fn scm_i_new_double_smob(tc: scm_t_bits, arg1: scm_t_bits,
7316 arg2: scm_t_bits, arg3: scm_t_bits) -> SCM;
7317 pub fn scm_new_smob(tc: scm_t_bits, data: scm_t_bits) -> SCM;
7318 pub fn scm_new_double_smob(tc: scm_t_bits, data1: scm_t_bits,
7319 data2: scm_t_bits, data3: scm_t_bits) -> SCM;
7320 pub fn scm_i_finalize_smob(ptr: *mut c_void,
7321 data: *mut c_void);
7322 pub fn scm_i_new_smob_with_mark_proc(tc: scm_t_bits, arg1: scm_t_bits,
7323 arg2: scm_t_bits, arg3: scm_t_bits)
7324 -> SCM;
7325 pub fn scm_mark0(ptr: SCM) -> SCM;
7326 pub fn scm_markcdr(ptr: SCM) -> SCM;
7327 pub fn scm_free0(ptr: SCM) -> size_t;
7328 pub fn scm_smob_print(exp: SCM, port: SCM, pstate: *mut scm_print_state)
7329 -> c_int;
7330 pub fn scm_make_smob_type(name: *const c_char,
7331 size: size_t) -> scm_t_bits;
7332 pub fn scm_set_smob_mark(tc: scm_t_bits,
7333 mark:
7334 ::std::option::Option<extern "C" fn(arg1:
7335 SCM)
7336 -> SCM>);
7337 pub fn scm_set_smob_free(tc: scm_t_bits,
7338 free:
7339 ::std::option::Option<extern "C" fn(arg1:
7340 SCM)
7341 -> size_t>);
7342 pub fn scm_set_smob_print(tc: scm_t_bits,
7343 print:
7344 ::std::option::Option<unsafe extern "C" fn(arg1:
7345 SCM,
7346 arg2:
7347 SCM,
7348 arg3:
7349 *mut scm_print_state)
7350 ->
7351 c_int>);
7352 pub fn scm_set_smob_equalp(tc: scm_t_bits,
7353 equalp:
7354 ::std::option::Option<extern "C" fn(arg1:
7355 SCM,
7356 arg2:
7357 SCM)
7358 -> SCM>);
7359 pub fn scm_set_smob_apply(tc: scm_t_bits, apply: scm_t_subr,
7360 req: c_uint,
7361 opt: c_uint,
7362 rst: c_uint);
7363 pub fn scm_assert_smob_type(tag: scm_t_bits, val: SCM);
7364 pub fn scm_make_smob(tc: scm_t_bits) -> SCM;
7365 pub fn scm_smob_prehistory();
7366 pub fn scm_inet_aton(address: SCM) -> SCM;
7367 pub fn scm_inet_ntoa(inetid: SCM) -> SCM;
7368 pub fn scm_inet_netof(address: SCM) -> SCM;
7369 pub fn scm_lnaof(address: SCM) -> SCM;
7370 pub fn scm_inet_makeaddr(net: SCM, lna: SCM) -> SCM;
7371 pub fn scm_inet_pton(family: SCM, address: SCM) -> SCM;
7372 pub fn scm_inet_ntop(family: SCM, address: SCM) -> SCM;
7373 pub fn scm_socket(family: SCM, style: SCM, proto: SCM) -> SCM;
7374 pub fn scm_socketpair(family: SCM, style: SCM, proto: SCM) -> SCM;
7375 pub fn scm_getsockopt(sfd: SCM, level: SCM, optname: SCM) -> SCM;
7376 pub fn scm_setsockopt(sfd: SCM, level: SCM, optname: SCM, value: SCM)
7377 -> SCM;
7378 pub fn scm_shutdown(sfd: SCM, how: SCM) -> SCM;
7379 pub fn scm_connect(sockfd: SCM, fam: SCM, address: SCM, args: SCM) -> SCM;
7380 pub fn scm_bind(sockfd: SCM, fam: SCM, address: SCM, args: SCM) -> SCM;
7381 pub fn scm_listen(sfd: SCM, backlog: SCM) -> SCM;
7382 pub fn scm_accept(sockfd: SCM) -> SCM;
7383 pub fn scm_getsockname(sockfd: SCM) -> SCM;
7384 pub fn scm_getpeername(sockfd: SCM) -> SCM;
7385 pub fn scm_recv(sockfd: SCM, buff_or_size: SCM, flags: SCM) -> SCM;
7386 pub fn scm_send(sockfd: SCM, message: SCM, flags: SCM) -> SCM;
7387 pub fn scm_recvfrom(sockfd: SCM, buff_or_size: SCM, flags: SCM,
7388 offset: SCM, length: SCM) -> SCM;
7389 pub fn scm_sendto(sockfd: SCM, message: SCM, fam: SCM, address: SCM,
7390 args_and_flags: SCM) -> SCM;
7391 pub fn scm_init_socket();
7392 pub fn scm_from_sockaddr(address: *const Struct_sockaddr,
7393 addr_size: c_uint) -> SCM;
7394 pub fn scm_to_sockaddr(address: SCM, adress_size: *mut size_t)
7395 -> *mut Struct_sockaddr;
7396 pub fn scm_c_make_socket_address(family: SCM, address: SCM, args: SCM,
7397 address_size: *mut size_t)
7398 -> *mut Struct_sockaddr;
7399 pub fn scm_make_socket_address(family: SCM, address: SCM, args: SCM)
7400 -> SCM;
7401 pub fn scm_restricted_vector_sort_x(vec: SCM, less: SCM, startpos: SCM,
7402 endpos: SCM) -> SCM;
7403 pub fn scm_sorted_p(ls: SCM, less: SCM) -> SCM;
7404 pub fn scm_merge(ls1: SCM, ls2: SCM, less: SCM) -> SCM;
7405 pub fn scm_merge_x(ls1: SCM, ls2: SCM, less: SCM) -> SCM;
7406 pub fn scm_sort(ls: SCM, less: SCM) -> SCM;
7407 pub fn scm_sort_x(ls: SCM, less: SCM) -> SCM;
7408 pub fn scm_stable_sort(ls: SCM, less: SCM) -> SCM;
7409 pub fn scm_stable_sort_x(ls: SCM, less: SCM) -> SCM;
7410 pub fn scm_sort_list(ls: SCM, less: SCM) -> SCM;
7411 pub fn scm_sort_list_x(ls: SCM, less: SCM) -> SCM;
7412 pub fn scm_init_sort();
7413 pub fn scm_supports_source_properties_p(obj: SCM) -> SCM;
7414 pub fn scm_make_srcprops(line: c_long,
7415 col: c_int, fname: SCM,
7416 copy: SCM, plist: SCM) -> SCM;
7417 pub fn scm_source_property(obj: SCM, key: SCM) -> SCM;
7418 pub fn scm_set_source_property_x(obj: SCM, key: SCM, datum: SCM) -> SCM;
7419 pub fn scm_source_properties(obj: SCM) -> SCM;
7420 pub fn scm_set_source_properties_x(obj: SCM, props: SCM) -> SCM;
7421 pub fn scm_i_has_source_properties(obj: SCM) -> c_int;
7422 pub fn scm_i_set_source_properties_x(obj: SCM,
7423 line: c_long,
7424 col: c_int,
7425 fname: SCM);
7426 pub fn scm_cons_source(xorig: SCM, x: SCM, y: SCM) -> SCM;
7427 pub fn scm_init_srcprop();
7428 pub fn scm_report_stack_overflow();
7429 pub fn scm_stack_size(start: *mut SCM_STACKITEM)
7430 -> c_long;
7431 pub fn scm_stack_report();
7432 pub fn scm_sys_get_stack_size() -> SCM;
7433 pub fn scm_init_stackchk();
7434 pub fn scm_c_get_internal_run_time() -> c_long;
7435 pub fn scm_get_internal_real_time() -> SCM;
7436 pub fn scm_get_internal_run_time() -> SCM;
7437 pub fn scm_current_time() -> SCM;
7438 pub fn scm_gettimeofday() -> SCM;
7439 pub fn scm_localtime(time: SCM, zone: SCM) -> SCM;
7440 pub fn scm_gmtime(time: SCM) -> SCM;
7441 pub fn scm_mktime(sbd_time: SCM, zone: SCM) -> SCM;
7442 pub fn scm_tzset() -> SCM;
7443 pub fn scm_times() -> SCM;
7444 pub fn scm_strftime(format: SCM, stime: SCM) -> SCM;
7445 pub fn scm_strptime(format: SCM, string: SCM) -> SCM;
7446 pub fn scm_init_stime();
7447 pub fn scm_string_null_p(s: SCM) -> SCM;
7448 pub fn scm_string_any(pred: SCM, s: SCM, start: SCM, end: SCM) -> SCM;
7449 pub fn scm_string_every(pred: SCM, s: SCM, start: SCM, end: SCM) -> SCM;
7450 pub fn scm_string_tabulate(_proc: SCM, len: SCM) -> SCM;
7451 pub fn scm_string_to_list(str: SCM) -> SCM;
7452 pub fn scm_substring_to_list(str: SCM, start: SCM, end: SCM) -> SCM;
7453 pub fn scm_reverse_list_to_string(chrs: SCM) -> SCM;
7454 pub fn scm_string_join(ls: SCM, delimiter: SCM, grammar: SCM) -> SCM;
7455 pub fn scm_string_copy(str: SCM) -> SCM;
7456 pub fn scm_string_copy_x(target: SCM, tstart: SCM, s: SCM, start: SCM,
7457 end: SCM) -> SCM;
7458 pub fn scm_substring_move_x(str1: SCM, start1: SCM, end1: SCM, str2: SCM,
7459 start2: SCM) -> SCM;
7460 pub fn scm_string_take(s: SCM, n: SCM) -> SCM;
7461 pub fn scm_string_drop(s: SCM, n: SCM) -> SCM;
7462 pub fn scm_string_take_right(s: SCM, n: SCM) -> SCM;
7463 pub fn scm_string_drop_right(s: SCM, n: SCM) -> SCM;
7464 pub fn scm_string_pad(s: SCM, len: SCM, chr: SCM, start: SCM, end: SCM)
7465 -> SCM;
7466 pub fn scm_string_pad_right(s: SCM, len: SCM, chr: SCM, start: SCM,
7467 end: SCM) -> SCM;
7468 pub fn scm_string_trim(s: SCM, char_pred: SCM, start: SCM, end: SCM)
7469 -> SCM;
7470 pub fn scm_string_trim_right(s: SCM, char_pred: SCM, start: SCM, end: SCM)
7471 -> SCM;
7472 pub fn scm_string_trim_both(s: SCM, char_pred: SCM, start: SCM, end: SCM)
7473 -> SCM;
7474 pub fn scm_substring_fill_x(str: SCM, chr: SCM, start: SCM, end: SCM)
7475 -> SCM;
7476 pub fn scm_string_fill_x(str: SCM, chr: SCM) -> SCM;
7477 pub fn scm_string_compare(s1: SCM, s2: SCM, proc_lt: SCM, proc_eq: SCM,
7478 proc_gt: SCM, start1: SCM, end1: SCM,
7479 start2: SCM, end2: SCM) -> SCM;
7480 pub fn scm_string_compare_ci(s1: SCM, s2: SCM, proc_lt: SCM, proc_eq: SCM,
7481 proc_gt: SCM, start1: SCM, end1: SCM,
7482 start2: SCM, end2: SCM) -> SCM;
7483 pub fn scm_string_eq(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7484 start2: SCM, end2: SCM) -> SCM;
7485 pub fn scm_string_neq(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7486 start2: SCM, end2: SCM) -> SCM;
7487 pub fn scm_string_lt(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7488 start2: SCM, end2: SCM) -> SCM;
7489 pub fn scm_string_gt(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7490 start2: SCM, end2: SCM) -> SCM;
7491 pub fn scm_string_le(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7492 start2: SCM, end2: SCM) -> SCM;
7493 pub fn scm_string_ge(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7494 start2: SCM, end2: SCM) -> SCM;
7495 pub fn scm_string_ci_eq(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7496 start2: SCM, end2: SCM) -> SCM;
7497 pub fn scm_string_ci_neq(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7498 start2: SCM, end2: SCM) -> SCM;
7499 pub fn scm_string_ci_lt(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7500 start2: SCM, end2: SCM) -> SCM;
7501 pub fn scm_string_ci_gt(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7502 start2: SCM, end2: SCM) -> SCM;
7503 pub fn scm_string_ci_le(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7504 start2: SCM, end2: SCM) -> SCM;
7505 pub fn scm_string_ci_ge(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7506 start2: SCM, end2: SCM) -> SCM;
7507 pub fn scm_substring_hash(s: SCM, bound: SCM, start: SCM, end: SCM)
7508 -> SCM;
7509 pub fn scm_substring_hash_ci(s: SCM, bound: SCM, start: SCM, end: SCM)
7510 -> SCM;
7511 pub fn scm_string_prefix_length(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7512 start2: SCM, end2: SCM) -> SCM;
7513 pub fn scm_string_prefix_length_ci(s1: SCM, s2: SCM, start1: SCM,
7514 end1: SCM, start2: SCM, end2: SCM)
7515 -> SCM;
7516 pub fn scm_string_suffix_length(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7517 start2: SCM, end2: SCM) -> SCM;
7518 pub fn scm_string_suffix_length_ci(s1: SCM, s2: SCM, start1: SCM,
7519 end1: SCM, start2: SCM, end2: SCM)
7520 -> SCM;
7521 pub fn scm_string_prefix_p(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7522 start2: SCM, end2: SCM) -> SCM;
7523 pub fn scm_string_prefix_ci_p(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7524 start2: SCM, end2: SCM) -> SCM;
7525 pub fn scm_string_suffix_p(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7526 start2: SCM, end2: SCM) -> SCM;
7527 pub fn scm_string_suffix_ci_p(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7528 start2: SCM, end2: SCM) -> SCM;
7529 pub fn scm_string_index(s: SCM, char_pred: SCM, start: SCM, end: SCM)
7530 -> SCM;
7531 pub fn scm_string_index_right(s: SCM, char_pred: SCM, start: SCM,
7532 end: SCM) -> SCM;
7533 pub fn scm_string_rindex(s: SCM, char_pred: SCM, start: SCM, end: SCM)
7534 -> SCM;
7535 pub fn scm_string_skip(s: SCM, char_pred: SCM, start: SCM, end: SCM)
7536 -> SCM;
7537 pub fn scm_string_skip_right(s: SCM, char_pred: SCM, start: SCM, end: SCM)
7538 -> SCM;
7539 pub fn scm_string_count(s: SCM, char_pred: SCM, start: SCM, end: SCM)
7540 -> SCM;
7541 pub fn scm_string_contains(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7542 start2: SCM, end2: SCM) -> SCM;
7543 pub fn scm_string_contains_ci(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7544 start2: SCM, end2: SCM) -> SCM;
7545 pub fn scm_substring_upcase_x(str: SCM, start: SCM, end: SCM) -> SCM;
7546 pub fn scm_substring_upcase(str: SCM, start: SCM, end: SCM) -> SCM;
7547 pub fn scm_string_upcase_x(str: SCM) -> SCM;
7548 pub fn scm_string_upcase(str: SCM) -> SCM;
7549 pub fn scm_substring_downcase_x(str: SCM, start: SCM, end: SCM) -> SCM;
7550 pub fn scm_substring_downcase(str: SCM, start: SCM, end: SCM) -> SCM;
7551 pub fn scm_string_downcase_x(str: SCM) -> SCM;
7552 pub fn scm_string_downcase(str: SCM) -> SCM;
7553 pub fn scm_string_titlecase_x(str: SCM, start: SCM, end: SCM) -> SCM;
7554 pub fn scm_string_titlecase(str: SCM, start: SCM, end: SCM) -> SCM;
7555 pub fn scm_string_capitalize_x(str: SCM) -> SCM;
7556 pub fn scm_string_capitalize(str: SCM) -> SCM;
7557 pub fn scm_string_reverse(str: SCM, start: SCM, end: SCM) -> SCM;
7558 pub fn scm_string_reverse_x(str: SCM, start: SCM, end: SCM) -> SCM;
7559 pub fn scm_string_append_shared(ls: SCM) -> SCM;
7560 pub fn scm_string_concatenate(ls: SCM) -> SCM;
7561 pub fn scm_string_concatenate_shared(ls: SCM) -> SCM;
7562 pub fn scm_string_concatenate_reverse(ls: SCM, final_string: SCM,
7563 end: SCM) -> SCM;
7564 pub fn scm_string_concatenate_reverse_shared(ls: SCM, final_string: SCM,
7565 end: SCM) -> SCM;
7566 pub fn scm_string_map(_proc: SCM, s: SCM, start: SCM, end: SCM) -> SCM;
7567 pub fn scm_string_map_x(_proc: SCM, s: SCM, start: SCM, end: SCM) -> SCM;
7568 pub fn scm_string_fold(kons: SCM, knil: SCM, s: SCM, start: SCM, end: SCM)
7569 -> SCM;
7570 pub fn scm_string_fold_right(kons: SCM, knil: SCM, s: SCM, start: SCM,
7571 end: SCM) -> SCM;
7572 pub fn scm_string_unfold(p: SCM, f: SCM, g: SCM, seed: SCM, base: SCM,
7573 make_final: SCM) -> SCM;
7574 pub fn scm_string_unfold_right(p: SCM, f: SCM, g: SCM, seed: SCM,
7575 base: SCM, make_final: SCM) -> SCM;
7576 pub fn scm_string_for_each(_proc: SCM, s: SCM, start: SCM, end: SCM)
7577 -> SCM;
7578 pub fn scm_string_for_each_index(_proc: SCM, s: SCM, start: SCM, end: SCM)
7579 -> SCM;
7580 pub fn scm_xsubstring(s: SCM, from: SCM, to: SCM, start: SCM, end: SCM)
7581 -> SCM;
7582 pub fn scm_string_xcopy_x(target: SCM, tstart: SCM, s: SCM, sfrom: SCM,
7583 sto: SCM, start: SCM, end: SCM) -> SCM;
7584 pub fn scm_string_replace(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
7585 start2: SCM, end2: SCM) -> SCM;
7586 pub fn scm_string_tokenize(s: SCM, token_char: SCM, start: SCM, end: SCM)
7587 -> SCM;
7588 pub fn scm_string_split(s: SCM, char_pred: SCM) -> SCM;
7589 pub fn scm_string_filter(char_pred: SCM, s: SCM, start: SCM, end: SCM)
7590 -> SCM;
7591 pub fn scm_string_delete(char_pred: SCM, s: SCM, start: SCM, end: SCM)
7592 -> SCM;
7593 pub fn scm_init_srfi_13();
7594 pub fn scm_init_srfi_13_14();
7595 pub fn scm_i_charset_get(cs: *mut scm_t_char_set, n: scm_t_wchar)
7596 -> c_int;
7597 pub fn scm_i_charset_set(cs: *mut scm_t_char_set, n: scm_t_wchar);
7598 pub fn scm_i_charset_unset(cs: *mut scm_t_char_set, n: scm_t_wchar);
7599 pub fn scm_char_set_p(obj: SCM) -> SCM;
7600 pub fn scm_char_set_eq(char_sets: SCM) -> SCM;
7601 pub fn scm_char_set_leq(char_sets: SCM) -> SCM;
7602 pub fn scm_char_set_hash(cs: SCM, bound: SCM) -> SCM;
7603 pub fn scm_char_set_cursor(cs: SCM) -> SCM;
7604 pub fn scm_char_set_ref(cs: SCM, cursor: SCM) -> SCM;
7605 pub fn scm_char_set_cursor_next(cs: SCM, cursor: SCM) -> SCM;
7606 pub fn scm_end_of_char_set_p(cursor: SCM) -> SCM;
7607 pub fn scm_char_set_fold(kons: SCM, knil: SCM, cs: SCM) -> SCM;
7608 pub fn scm_char_set_unfold(p: SCM, f: SCM, g: SCM, seed: SCM,
7609 base_cs: SCM) -> SCM;
7610 pub fn scm_char_set_unfold_x(p: SCM, f: SCM, g: SCM, seed: SCM,
7611 base_cs: SCM) -> SCM;
7612 pub fn scm_char_set_for_each(_proc: SCM, cs: SCM) -> SCM;
7613 pub fn scm_char_set_map(_proc: SCM, cs: SCM) -> SCM;
7614 pub fn scm_char_set_copy(cs: SCM) -> SCM;
7615 pub fn scm_char_set(rest: SCM) -> SCM;
7616 pub fn scm_list_to_char_set(list: SCM, base_cs: SCM) -> SCM;
7617 pub fn scm_list_to_char_set_x(list: SCM, base_cs: SCM) -> SCM;
7618 pub fn scm_string_to_char_set(str: SCM, base_cs: SCM) -> SCM;
7619 pub fn scm_string_to_char_set_x(str: SCM, base_cs: SCM) -> SCM;
7620 pub fn scm_char_set_filter(pred: SCM, cs: SCM, base_cs: SCM) -> SCM;
7621 pub fn scm_char_set_filter_x(pred: SCM, cs: SCM, base_cs: SCM) -> SCM;
7622 pub fn scm_ucs_range_to_char_set(lower: SCM, upper: SCM, error: SCM,
7623 base_cs: SCM) -> SCM;
7624 pub fn scm_ucs_range_to_char_set_x(lower: SCM, upper: SCM, error: SCM,
7625 base_cs: SCM) -> SCM;
7626 pub fn scm_to_char_set(x: SCM) -> SCM;
7627 pub fn scm_char_set_size(cs: SCM) -> SCM;
7628 pub fn scm_char_set_count(pred: SCM, cs: SCM) -> SCM;
7629 pub fn scm_char_set_to_list(cs: SCM) -> SCM;
7630 pub fn scm_char_set_to_string(cs: SCM) -> SCM;
7631 pub fn scm_char_set_contains_p(cs: SCM, ch: SCM) -> SCM;
7632 pub fn scm_char_set_every(pred: SCM, cs: SCM) -> SCM;
7633 pub fn scm_char_set_any(pred: SCM, cs: SCM) -> SCM;
7634 pub fn scm_char_set_adjoin(cs: SCM, rest: SCM) -> SCM;
7635 pub fn scm_char_set_delete(cs: SCM, rest: SCM) -> SCM;
7636 pub fn scm_char_set_adjoin_x(cs: SCM, rest: SCM) -> SCM;
7637 pub fn scm_char_set_delete_x(cs: SCM, rest: SCM) -> SCM;
7638 pub fn scm_char_set_complement(cs: SCM) -> SCM;
7639 pub fn scm_char_set_union(rest: SCM) -> SCM;
7640 pub fn scm_char_set_intersection(rest: SCM) -> SCM;
7641 pub fn scm_char_set_difference(cs1: SCM, rest: SCM) -> SCM;
7642 pub fn scm_char_set_xor(rest: SCM) -> SCM;
7643 pub fn scm_char_set_diff_plus_intersection(cs1: SCM, rest: SCM) -> SCM;
7644 pub fn scm_char_set_complement_x(cs: SCM) -> SCM;
7645 pub fn scm_char_set_union_x(cs1: SCM, rest: SCM) -> SCM;
7646 pub fn scm_char_set_intersection_x(cs1: SCM, rest: SCM) -> SCM;
7647 pub fn scm_char_set_difference_x(cs1: SCM, rest: SCM) -> SCM;
7648 pub fn scm_char_set_xor_x(cs1: SCM, rest: SCM) -> SCM;
7649 pub fn scm_char_set_diff_plus_intersection_x(cs1: SCM, cs2: SCM,
7650 rest: SCM) -> SCM;
7651 pub fn scm_sys_char_set_dump(charset: SCM) -> SCM;
7652 pub fn scm_init_srfi_14();
7653 pub fn scm_string_equal_p(s1: SCM, s2: SCM) -> SCM;
7654 pub fn scm_string_ci_equal_p(s1: SCM, s2: SCM) -> SCM;
7655 pub fn scm_string_less_p(s1: SCM, s2: SCM) -> SCM;
7656 pub fn scm_string_leq_p(s1: SCM, s2: SCM) -> SCM;
7657 pub fn scm_string_gr_p(s1: SCM, s2: SCM) -> SCM;
7658 pub fn scm_string_geq_p(s1: SCM, s2: SCM) -> SCM;
7659 pub fn scm_string_ci_less_p(s1: SCM, s2: SCM) -> SCM;
7660 pub fn scm_string_ci_leq_p(s1: SCM, s2: SCM) -> SCM;
7661 pub fn scm_string_ci_gr_p(s1: SCM, s2: SCM) -> SCM;
7662 pub fn scm_string_ci_geq_p(s1: SCM, s2: SCM) -> SCM;
7663 pub fn scm_init_strorder();
7664 pub fn scm_mkstrport(pos: SCM, str: SCM, modes: c_long,
7665 caller: *const c_char) -> SCM;
7666 pub fn scm_strport_to_string(port: SCM) -> SCM;
7667 pub fn scm_object_to_string(obj: SCM, printer: SCM) -> SCM;
7668 pub fn scm_call_with_output_string(_proc: SCM) -> SCM;
7669 pub fn scm_call_with_input_string(str: SCM, _proc: SCM) -> SCM;
7670 pub fn scm_open_input_string(str: SCM) -> SCM;
7671 pub fn scm_open_output_string() -> SCM;
7672 pub fn scm_get_output_string(port: SCM) -> SCM;
7673 pub fn scm_c_read_string(expr: *const c_char) -> SCM;
7674 pub fn scm_c_eval_string(expr: *const c_char) -> SCM;
7675 pub fn scm_c_eval_string_in_module(expr: *const c_char,
7676 module: SCM) -> SCM;
7677 pub fn scm_eval_string(string: SCM) -> SCM;
7678 pub fn scm_eval_string_in_module(string: SCM, module: SCM) -> SCM;
7679 pub fn scm_init_strports();
7680 pub fn scm_symbol_p(x: SCM) -> SCM;
7681 pub fn scm_symbol_interned_p(sym: SCM) -> SCM;
7682 pub fn scm_make_symbol(name: SCM) -> SCM;
7683 pub fn scm_symbol_to_string(s: SCM) -> SCM;
7684 pub fn scm_string_to_symbol(s: SCM) -> SCM;
7685 pub fn scm_string_ci_to_symbol(s: SCM) -> SCM;
7686 pub fn scm_symbol_fref(s: SCM) -> SCM;
7687 pub fn scm_symbol_pref(s: SCM) -> SCM;
7688 pub fn scm_symbol_fset_x(s: SCM, val: SCM) -> SCM;
7689 pub fn scm_symbol_pset_x(s: SCM, val: SCM) -> SCM;
7690 pub fn scm_symbol_hash(s: SCM) -> SCM;
7691 pub fn scm_gensym(prefix: SCM) -> SCM;
7692 pub fn scm_from_locale_symbol(str: *const c_char) -> SCM;
7693 pub fn scm_from_locale_symboln(str: *const c_char,
7694 len: size_t) -> SCM;
7695 pub fn scm_take_locale_symbol(sym: *mut c_char) -> SCM;
7696 pub fn scm_take_locale_symboln(sym: *mut c_char,
7697 len: size_t) -> SCM;
7698 pub fn scm_from_latin1_symbol(str: *const c_char) -> SCM;
7699 pub fn scm_from_latin1_symboln(str: *const c_char,
7700 len: size_t) -> SCM;
7701 pub fn scm_take_latin1_symbol(sym: *mut c_char) -> SCM;
7702 pub fn scm_take_latin1_symboln(sym: *mut c_char,
7703 len: size_t) -> SCM;
7704 pub fn scm_from_utf8_symbol(str: *const c_char) -> SCM;
7705 pub fn scm_from_utf8_symboln(str: *const c_char,
7706 len: size_t) -> SCM;
7707 pub fn scm_take_utf8_symbol(sym: *mut c_char) -> SCM;
7708 pub fn scm_take_utf8_symboln(sym: *mut c_char,
7709 len: size_t) -> SCM;
7710 pub fn scm_i_hash_symbol(obj: SCM, n: c_ulong,
7711 closure: *mut c_void)
7712 -> c_ulong;
7713 pub fn scm_symbols_prehistory();
7714 pub fn scm_init_symbols();
7715 pub fn scm_init_trees();
7716 pub fn scm_array_handle_uniform_element_size(h: *mut scm_t_array_handle)
7717 -> size_t;
7718 pub fn scm_array_handle_uniform_element_bit_size(h:
7719 *mut scm_t_array_handle)
7720 -> size_t;
7721 pub fn scm_array_handle_uniform_elements(h: *mut scm_t_array_handle)
7722 -> *const c_void;
7723 pub fn scm_array_handle_uniform_writable_elements(h:
7724 *mut scm_t_array_handle)
7725 -> *mut c_void;
7726 pub fn scm_uniform_vector_p(v: SCM) -> SCM;
7727 pub fn scm_uniform_vector_length(v: SCM) -> SCM;
7728 pub fn scm_uniform_vector_element_type(v: SCM) -> SCM;
7729 pub fn scm_uniform_vector_element_size(v: SCM) -> SCM;
7730 pub fn scm_uniform_vector_ref(v: SCM, idx: SCM) -> SCM;
7731 pub fn scm_uniform_vector_set_x(v: SCM, idx: SCM, val: SCM) -> SCM;
7732 pub fn scm_uniform_vector_to_list(v: SCM) -> SCM;
7733 pub fn scm_uniform_vector_read_x(v: SCM, port_or_fd: SCM, start: SCM,
7734 end: SCM) -> SCM;
7735 pub fn scm_uniform_vector_write(v: SCM, port_or_fd: SCM, start: SCM,
7736 end: SCM) -> SCM;
7737 pub fn scm_is_uniform_vector(obj: SCM) -> c_int;
7738 pub fn scm_c_uniform_vector_length(v: SCM) -> size_t;
7739 pub fn scm_c_uniform_vector_ref(v: SCM, idx: size_t) -> SCM;
7740 pub fn scm_c_uniform_vector_set_x(v: SCM, idx: size_t, val: SCM);
7741 pub fn scm_uniform_vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
7742 lenp: *mut size_t, incp: *mut ssize_t)
7743 -> *const c_void;
7744 pub fn scm_uniform_vector_writable_elements(uvec: SCM,
7745 h: *mut scm_t_array_handle,
7746 lenp: *mut size_t,
7747 incp: *mut ssize_t)
7748 -> *mut c_void;
7749 pub fn scm_init_uniform();
7750 pub fn scm_i_extract_values_2(obj: SCM, p1: *mut SCM, p2: *mut SCM);
7751 pub fn scm_values(args: SCM) -> SCM;
7752 pub fn scm_c_values(base: *mut SCM, n: size_t) -> SCM;
7753 pub fn scm_c_nvalues(obj: SCM) -> size_t;
7754 pub fn scm_c_value_ref(obj: SCM, idx: size_t) -> SCM;
7755 pub fn scm_init_values();
7756 pub fn scm_make_variable(init: SCM) -> SCM;
7757 pub fn scm_make_undefined_variable() -> SCM;
7758 pub fn scm_variable_p(obj: SCM) -> SCM;
7759 pub fn scm_variable_ref(var: SCM) -> SCM;
7760 pub fn scm_variable_set_x(var: SCM, val: SCM) -> SCM;
7761 pub fn scm_variable_unset_x(var: SCM) -> SCM;
7762 pub fn scm_variable_bound_p(var: SCM) -> SCM;
7763 pub fn scm_i_variable_print(var: SCM, port: SCM,
7764 pstate: *mut scm_print_state);
7765 pub fn scm_init_variable();
7766 pub fn scm_make_srfi_4_vector(_type: SCM, len: SCM, fill: SCM) -> SCM;
7767 pub fn scm_u8vector_p(obj: SCM) -> SCM;
7768 pub fn scm_make_u8vector(n: SCM, fill: SCM) -> SCM;
7769 pub fn scm_take_u8vector(data: *mut scm_t_uint8, n: size_t) -> SCM;
7770 pub fn scm_u8vector(l: SCM) -> SCM;
7771 pub fn scm_u8vector_length(uvec: SCM) -> SCM;
7772 pub fn scm_u8vector_ref(uvec: SCM, index: SCM) -> SCM;
7773 pub fn scm_u8vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
7774 pub fn scm_u8vector_to_list(uvec: SCM) -> SCM;
7775 pub fn scm_list_to_u8vector(l: SCM) -> SCM;
7776 pub fn scm_any_to_u8vector(obj: SCM) -> SCM;
7777 pub fn scm_array_handle_u8_elements(h: *mut scm_t_array_handle)
7778 -> *const scm_t_uint8;
7779 pub fn scm_array_handle_u8_writable_elements(h: *mut scm_t_array_handle)
7780 -> *mut scm_t_uint8;
7781 pub fn scm_u8vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
7782 lenp: *mut size_t, incp: *mut ssize_t)
7783 -> *const scm_t_uint8;
7784 pub fn scm_u8vector_writable_elements(uvec: SCM,
7785 h: *mut scm_t_array_handle,
7786 lenp: *mut size_t,
7787 incp: *mut ssize_t)
7788 -> *mut scm_t_uint8;
7789 pub fn scm_s8vector_p(obj: SCM) -> SCM;
7790 pub fn scm_make_s8vector(n: SCM, fill: SCM) -> SCM;
7791 pub fn scm_take_s8vector(data: *mut scm_t_int8, n: size_t) -> SCM;
7792 pub fn scm_s8vector(l: SCM) -> SCM;
7793 pub fn scm_s8vector_length(uvec: SCM) -> SCM;
7794 pub fn scm_s8vector_ref(uvec: SCM, index: SCM) -> SCM;
7795 pub fn scm_s8vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
7796 pub fn scm_s8vector_to_list(uvec: SCM) -> SCM;
7797 pub fn scm_list_to_s8vector(l: SCM) -> SCM;
7798 pub fn scm_any_to_s8vector(obj: SCM) -> SCM;
7799 pub fn scm_array_handle_s8_elements(h: *mut scm_t_array_handle)
7800 -> *const scm_t_int8;
7801 pub fn scm_array_handle_s8_writable_elements(h: *mut scm_t_array_handle)
7802 -> *mut scm_t_int8;
7803 pub fn scm_s8vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
7804 lenp: *mut size_t, incp: *mut ssize_t)
7805 -> *const scm_t_int8;
7806 pub fn scm_s8vector_writable_elements(uvec: SCM,
7807 h: *mut scm_t_array_handle,
7808 lenp: *mut size_t,
7809 incp: *mut ssize_t)
7810 -> *mut scm_t_int8;
7811 pub fn scm_u16vector_p(obj: SCM) -> SCM;
7812 pub fn scm_make_u16vector(n: SCM, fill: SCM) -> SCM;
7813 pub fn scm_take_u16vector(data: *mut scm_t_uint16, n: size_t) -> SCM;
7814 pub fn scm_u16vector(l: SCM) -> SCM;
7815 pub fn scm_u16vector_length(uvec: SCM) -> SCM;
7816 pub fn scm_u16vector_ref(uvec: SCM, index: SCM) -> SCM;
7817 pub fn scm_u16vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
7818 pub fn scm_u16vector_to_list(uvec: SCM) -> SCM;
7819 pub fn scm_list_to_u16vector(l: SCM) -> SCM;
7820 pub fn scm_any_to_u16vector(obj: SCM) -> SCM;
7821 pub fn scm_array_handle_u16_elements(h: *mut scm_t_array_handle)
7822 -> *const scm_t_uint16;
7823 pub fn scm_array_handle_u16_writable_elements(h: *mut scm_t_array_handle)
7824 -> *mut scm_t_uint16;
7825 pub fn scm_u16vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
7826 lenp: *mut size_t, incp: *mut ssize_t)
7827 -> *const scm_t_uint16;
7828 pub fn scm_u16vector_writable_elements(uvec: SCM,
7829 h: *mut scm_t_array_handle,
7830 lenp: *mut size_t,
7831 incp: *mut ssize_t)
7832 -> *mut scm_t_uint16;
7833 pub fn scm_s16vector_p(obj: SCM) -> SCM;
7834 pub fn scm_make_s16vector(n: SCM, fill: SCM) -> SCM;
7835 pub fn scm_take_s16vector(data: *mut scm_t_int16, n: size_t) -> SCM;
7836 pub fn scm_s16vector(l: SCM) -> SCM;
7837 pub fn scm_s16vector_length(uvec: SCM) -> SCM;
7838 pub fn scm_s16vector_ref(uvec: SCM, index: SCM) -> SCM;
7839 pub fn scm_s16vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
7840 pub fn scm_s16vector_to_list(uvec: SCM) -> SCM;
7841 pub fn scm_list_to_s16vector(l: SCM) -> SCM;
7842 pub fn scm_any_to_s16vector(obj: SCM) -> SCM;
7843 pub fn scm_array_handle_s16_elements(h: *mut scm_t_array_handle)
7844 -> *const scm_t_int16;
7845 pub fn scm_array_handle_s16_writable_elements(h: *mut scm_t_array_handle)
7846 -> *mut scm_t_int16;
7847 pub fn scm_s16vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
7848 lenp: *mut size_t, incp: *mut ssize_t)
7849 -> *const scm_t_int16;
7850 pub fn scm_s16vector_writable_elements(uvec: SCM,
7851 h: *mut scm_t_array_handle,
7852 lenp: *mut size_t,
7853 incp: *mut ssize_t)
7854 -> *mut scm_t_int16;
7855 pub fn scm_u32vector_p(obj: SCM) -> SCM;
7856 pub fn scm_make_u32vector(n: SCM, fill: SCM) -> SCM;
7857 pub fn scm_take_u32vector(data: *mut scm_t_uint32, n: size_t) -> SCM;
7858 pub fn scm_u32vector(l: SCM) -> SCM;
7859 pub fn scm_u32vector_length(uvec: SCM) -> SCM;
7860 pub fn scm_u32vector_ref(uvec: SCM, index: SCM) -> SCM;
7861 pub fn scm_u32vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
7862 pub fn scm_u32vector_to_list(uvec: SCM) -> SCM;
7863 pub fn scm_list_to_u32vector(l: SCM) -> SCM;
7864 pub fn scm_any_to_u32vector(obj: SCM) -> SCM;
7865 pub fn scm_array_handle_u32_elements(h: *mut scm_t_array_handle)
7866 -> *const scm_t_uint32;
7867 pub fn scm_array_handle_u32_writable_elements(h: *mut scm_t_array_handle)
7868 -> *mut scm_t_uint32;
7869 pub fn scm_u32vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
7870 lenp: *mut size_t, incp: *mut ssize_t)
7871 -> *const scm_t_uint32;
7872 pub fn scm_u32vector_writable_elements(uvec: SCM,
7873 h: *mut scm_t_array_handle,
7874 lenp: *mut size_t,
7875 incp: *mut ssize_t)
7876 -> *mut scm_t_uint32;
7877 pub fn scm_s32vector_p(obj: SCM) -> SCM;
7878 pub fn scm_make_s32vector(n: SCM, fill: SCM) -> SCM;
7879 pub fn scm_take_s32vector(data: *mut scm_t_int32, n: size_t) -> SCM;
7880 pub fn scm_s32vector(l: SCM) -> SCM;
7881 pub fn scm_s32vector_length(uvec: SCM) -> SCM;
7882 pub fn scm_s32vector_ref(uvec: SCM, index: SCM) -> SCM;
7883 pub fn scm_s32vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
7884 pub fn scm_s32vector_to_list(uvec: SCM) -> SCM;
7885 pub fn scm_list_to_s32vector(l: SCM) -> SCM;
7886 pub fn scm_any_to_s32vector(obj: SCM) -> SCM;
7887 pub fn scm_array_handle_s32_elements(h: *mut scm_t_array_handle)
7888 -> *const scm_t_int32;
7889 pub fn scm_array_handle_s32_writable_elements(h: *mut scm_t_array_handle)
7890 -> *mut scm_t_int32;
7891 pub fn scm_s32vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
7892 lenp: *mut size_t, incp: *mut ssize_t)
7893 -> *const scm_t_int32;
7894 pub fn scm_s32vector_writable_elements(uvec: SCM,
7895 h: *mut scm_t_array_handle,
7896 lenp: *mut size_t,
7897 incp: *mut ssize_t)
7898 -> *mut scm_t_int32;
7899 pub fn scm_u64vector_p(obj: SCM) -> SCM;
7900 pub fn scm_make_u64vector(n: SCM, fill: SCM) -> SCM;
7901 pub fn scm_u64vector(l: SCM) -> SCM;
7902 pub fn scm_u64vector_length(uvec: SCM) -> SCM;
7903 pub fn scm_u64vector_ref(uvec: SCM, index: SCM) -> SCM;
7904 pub fn scm_u64vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
7905 pub fn scm_u64vector_to_list(uvec: SCM) -> SCM;
7906 pub fn scm_list_to_u64vector(l: SCM) -> SCM;
7907 pub fn scm_any_to_u64vector(obj: SCM) -> SCM;
7908 pub fn scm_take_u64vector(data: *mut scm_t_uint64, n: size_t) -> SCM;
7909 pub fn scm_array_handle_u64_elements(h: *mut scm_t_array_handle)
7910 -> *const scm_t_uint64;
7911 pub fn scm_array_handle_u64_writable_elements(h: *mut scm_t_array_handle)
7912 -> *mut scm_t_uint64;
7913 pub fn scm_u64vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
7914 lenp: *mut size_t, incp: *mut ssize_t)
7915 -> *const scm_t_uint64;
7916 pub fn scm_u64vector_writable_elements(uvec: SCM,
7917 h: *mut scm_t_array_handle,
7918 lenp: *mut size_t,
7919 incp: *mut ssize_t)
7920 -> *mut scm_t_uint64;
7921 pub fn scm_s64vector_p(obj: SCM) -> SCM;
7922 pub fn scm_make_s64vector(n: SCM, fill: SCM) -> SCM;
7923 pub fn scm_s64vector(l: SCM) -> SCM;
7924 pub fn scm_s64vector_length(uvec: SCM) -> SCM;
7925 pub fn scm_s64vector_ref(uvec: SCM, index: SCM) -> SCM;
7926 pub fn scm_s64vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
7927 pub fn scm_s64vector_to_list(uvec: SCM) -> SCM;
7928 pub fn scm_list_to_s64vector(l: SCM) -> SCM;
7929 pub fn scm_any_to_s64vector(obj: SCM) -> SCM;
7930 pub fn scm_take_s64vector(data: *mut scm_t_int64, n: size_t) -> SCM;
7931 pub fn scm_array_handle_s64_elements(h: *mut scm_t_array_handle)
7932 -> *const scm_t_int64;
7933 pub fn scm_array_handle_s64_writable_elements(h: *mut scm_t_array_handle)
7934 -> *mut scm_t_int64;
7935 pub fn scm_s64vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
7936 lenp: *mut size_t, incp: *mut ssize_t)
7937 -> *const scm_t_int64;
7938 pub fn scm_s64vector_writable_elements(uvec: SCM,
7939 h: *mut scm_t_array_handle,
7940 lenp: *mut size_t,
7941 incp: *mut ssize_t)
7942 -> *mut scm_t_int64;
7943 pub fn scm_f32vector_p(obj: SCM) -> SCM;
7944 pub fn scm_make_f32vector(n: SCM, fill: SCM) -> SCM;
7945 pub fn scm_take_f32vector(data: *mut c_float, n: size_t)
7946 -> SCM;
7947 pub fn scm_f32vector(l: SCM) -> SCM;
7948 pub fn scm_f32vector_length(uvec: SCM) -> SCM;
7949 pub fn scm_f32vector_ref(uvec: SCM, index: SCM) -> SCM;
7950 pub fn scm_f32vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
7951 pub fn scm_f32vector_to_list(uvec: SCM) -> SCM;
7952 pub fn scm_list_to_f32vector(l: SCM) -> SCM;
7953 pub fn scm_any_to_f32vector(obj: SCM) -> SCM;
7954 pub fn scm_array_handle_f32_elements(h: *mut scm_t_array_handle)
7955 -> *const c_float;
7956 pub fn scm_array_handle_f32_writable_elements(h: *mut scm_t_array_handle)
7957 -> *mut c_float;
7958 pub fn scm_f32vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
7959 lenp: *mut size_t, incp: *mut ssize_t)
7960 -> *const c_float;
7961 pub fn scm_f32vector_writable_elements(uvec: SCM,
7962 h: *mut scm_t_array_handle,
7963 lenp: *mut size_t,
7964 incp: *mut ssize_t)
7965 -> *mut c_float;
7966 pub fn scm_f64vector_p(obj: SCM) -> SCM;
7967 pub fn scm_make_f64vector(n: SCM, fill: SCM) -> SCM;
7968 pub fn scm_take_f64vector(data: *mut c_double, n: size_t)
7969 -> SCM;
7970 pub fn scm_f64vector(l: SCM) -> SCM;
7971 pub fn scm_f64vector_length(uvec: SCM) -> SCM;
7972 pub fn scm_f64vector_ref(uvec: SCM, index: SCM) -> SCM;
7973 pub fn scm_f64vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
7974 pub fn scm_f64vector_to_list(uvec: SCM) -> SCM;
7975 pub fn scm_list_to_f64vector(l: SCM) -> SCM;
7976 pub fn scm_any_to_f64vector(obj: SCM) -> SCM;
7977 pub fn scm_array_handle_f64_elements(h: *mut scm_t_array_handle)
7978 -> *const c_double;
7979 pub fn scm_array_handle_f64_writable_elements(h: *mut scm_t_array_handle)
7980 -> *mut c_double;
7981 pub fn scm_f64vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
7982 lenp: *mut size_t, incp: *mut ssize_t)
7983 -> *const c_double;
7984 pub fn scm_f64vector_writable_elements(uvec: SCM,
7985 h: *mut scm_t_array_handle,
7986 lenp: *mut size_t,
7987 incp: *mut ssize_t)
7988 -> *mut c_double;
7989 pub fn scm_c32vector_p(obj: SCM) -> SCM;
7990 pub fn scm_make_c32vector(n: SCM, fill: SCM) -> SCM;
7991 pub fn scm_take_c32vector(data: *mut c_float, n: size_t)
7992 -> SCM;
7993 pub fn scm_c32vector(l: SCM) -> SCM;
7994 pub fn scm_c32vector_length(uvec: SCM) -> SCM;
7995 pub fn scm_c32vector_ref(uvec: SCM, index: SCM) -> SCM;
7996 pub fn scm_c32vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
7997 pub fn scm_c32vector_to_list(uvec: SCM) -> SCM;
7998 pub fn scm_list_to_c32vector(l: SCM) -> SCM;
7999 pub fn scm_any_to_c32vector(obj: SCM) -> SCM;
8000 pub fn scm_array_handle_c32_elements(h: *mut scm_t_array_handle)
8001 -> *const c_float;
8002 pub fn scm_array_handle_c32_writable_elements(h: *mut scm_t_array_handle)
8003 -> *mut c_float;
8004 pub fn scm_c32vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
8005 lenp: *mut size_t, incp: *mut ssize_t)
8006 -> *const c_float;
8007 pub fn scm_c32vector_writable_elements(uvec: SCM,
8008 h: *mut scm_t_array_handle,
8009 lenp: *mut size_t,
8010 incp: *mut ssize_t)
8011 -> *mut c_float;
8012 pub fn scm_c64vector_p(obj: SCM) -> SCM;
8013 pub fn scm_make_c64vector(n: SCM, fill: SCM) -> SCM;
8014 pub fn scm_take_c64vector(data: *mut c_double, n: size_t)
8015 -> SCM;
8016 pub fn scm_c64vector(l: SCM) -> SCM;
8017 pub fn scm_c64vector_length(uvec: SCM) -> SCM;
8018 pub fn scm_c64vector_ref(uvec: SCM, index: SCM) -> SCM;
8019 pub fn scm_c64vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
8020 pub fn scm_c64vector_to_list(uvec: SCM) -> SCM;
8021 pub fn scm_list_to_c64vector(l: SCM) -> SCM;
8022 pub fn scm_any_to_c64vector(obj: SCM) -> SCM;
8023 pub fn scm_array_handle_c64_elements(h: *mut scm_t_array_handle)
8024 -> *const c_double;
8025 pub fn scm_array_handle_c64_writable_elements(h: *mut scm_t_array_handle)
8026 -> *mut c_double;
8027 pub fn scm_c64vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
8028 lenp: *mut size_t, incp: *mut ssize_t)
8029 -> *const c_double;
8030 pub fn scm_c64vector_writable_elements(uvec: SCM,
8031 h: *mut scm_t_array_handle,
8032 lenp: *mut size_t,
8033 incp: *mut ssize_t)
8034 -> *mut c_double;
8035 pub fn scm_i_generalized_vector_type(vec: SCM) -> SCM;
8036 pub fn scm_i_uniform_vector_tag(uvec: SCM)
8037 -> *const c_char;
8038 pub fn scm_i_uniform_vector_ref_proc(uvec: SCM) -> scm_i_t_array_ref;
8039 pub fn scm_i_uniform_vector_set_proc(uvec: SCM) -> scm_i_t_array_set;
8040 pub fn scm_uniform_element_size(obj: SCM) -> size_t;
8041 pub fn scm_init_srfi_4();
8042 pub fn scm_major_version() -> SCM;
8043 pub fn scm_minor_version() -> SCM;
8044 pub fn scm_micro_version() -> SCM;
8045 pub fn scm_effective_version() -> SCM;
8046 pub fn scm_version() -> SCM;
8047 pub fn scm_init_version();
8048 pub fn scm_make_soft_port(pv: SCM, modes: SCM) -> SCM;
8049 pub fn scm_init_vports();
8050 pub fn scm_print_exception(port: SCM, frame: SCM, key: SCM, args: SCM)
8051 -> SCM;
8052 pub fn scm_display_error_message(message: SCM, args: SCM, port: SCM);
8053 pub fn scm_i_display_error(frame: SCM, port: SCM, subr: SCM, message: SCM,
8054 args: SCM, rest: SCM);
8055 pub fn scm_display_error(frame: SCM, port: SCM, subr: SCM, message: SCM,
8056 args: SCM, rest: SCM) -> SCM;
8057 pub fn scm_display_application(frame: SCM, port: SCM, indent: SCM) -> SCM;
8058 pub fn scm_display_backtrace(stack: SCM, port: SCM, first: SCM,
8059 depth: SCM) -> SCM;
8060 pub fn scm_display_backtrace_with_highlights(stack: SCM, port: SCM,
8061 first: SCM, depth: SCM,
8062 highlights: SCM) -> SCM;
8063 pub fn scm_backtrace() -> SCM;
8064 pub fn scm_backtrace_with_highlights(highlights: SCM) -> SCM;
8065 pub fn scm_init_backtrace();
8066 pub fn scm_c_make_objcode_slice(parent: SCM, ptr: *const scm_t_uint8)
8067 -> SCM;
8068 pub fn scm_load_objcode(file: SCM) -> SCM;
8069 pub fn scm_objcode_p(obj: SCM) -> SCM;
8070 pub fn scm_objcode_meta(objcode: SCM) -> SCM;
8071 pub fn scm_bytecode_to_objcode(bytecode: SCM) -> SCM;
8072 pub fn scm_bytecode_to_native_objcode(bytecode: SCM) -> SCM;
8073 pub fn scm_objcode_to_bytecode(objcode: SCM) -> SCM;
8074 pub fn scm_write_objcode(objcode: SCM, port: SCM) -> SCM;
8075 pub fn scm_i_objcode_print(objcode: SCM, port: SCM,
8076 pstate: *mut scm_print_state);
8077 pub fn scm_bootstrap_objcodes();
8078 pub fn scm_init_objcodes();
8079 pub fn scm_make_program(objcode: SCM, objtable: SCM, free_variables: SCM)
8080 -> SCM;
8081 pub fn scm_program_p(obj: SCM) -> SCM;
8082 pub fn scm_program_base(program: SCM) -> SCM;
8083 pub fn scm_program_meta(program: SCM) -> SCM;
8084 pub fn scm_program_bindings(program: SCM) -> SCM;
8085 pub fn scm_program_sources(program: SCM) -> SCM;
8086 pub fn scm_program_source(program: SCM, ip: SCM, sources: SCM) -> SCM;
8087 pub fn scm_program_arities(program: SCM) -> SCM;
8088 pub fn scm_program_objects(program: SCM) -> SCM;
8089 pub fn scm_program_module(program: SCM) -> SCM;
8090 pub fn scm_program_num_free_variables(program: SCM) -> SCM;
8091 pub fn scm_program_free_variable_ref(program: SCM, i: SCM) -> SCM;
8092 pub fn scm_program_free_variable_set_x(program: SCM, i: SCM, x: SCM)
8093 -> SCM;
8094 pub fn scm_program_objcode(program: SCM) -> SCM;
8095 pub fn scm_i_program_properties(program: SCM) -> SCM;
8096 pub fn scm_i_program_arity(program: SCM, req: *mut c_int,
8097 opt: *mut c_int,
8098 rest: *mut c_int)
8099 -> c_int;
8100 pub fn scm_i_program_print(program: SCM, port: SCM,
8101 pstate: *mut scm_print_state);
8102 pub fn scm_bootstrap_programs();
8103 pub fn scm_init_programs();
8104 pub fn scm_c_make_frame(stack_holder: SCM, fp: *mut SCM, sp: *mut SCM,
8105 ip: *mut scm_t_uint8, offset: scm_t_ptrdiff)
8106 -> SCM;
8107 pub fn scm_frame_p(obj: SCM) -> SCM;
8108 pub fn scm_frame_procedure(frame: SCM) -> SCM;
8109 pub fn scm_frame_arguments(frame: SCM) -> SCM;
8110 pub fn scm_frame_source(frame: SCM) -> SCM;
8111 pub fn scm_frame_num_locals(frame: SCM) -> SCM;
8112 pub fn scm_frame_local_ref(frame: SCM, index: SCM) -> SCM;
8113 pub fn scm_frame_local_set_x(frame: SCM, index: SCM, val: SCM) -> SCM;
8114 pub fn scm_frame_address(frame: SCM) -> SCM;
8115 pub fn scm_frame_stack_pointer(frame: SCM) -> SCM;
8116 pub fn scm_frame_instruction_pointer(frame: SCM) -> SCM;
8117 pub fn scm_frame_return_address(frame: SCM) -> SCM;
8118 pub fn scm_frame_mv_return_address(frame: SCM) -> SCM;
8119 pub fn scm_frame_dynamic_link(frame: SCM) -> SCM;
8120 pub fn scm_frame_previous(frame: SCM) -> SCM;
8121 pub fn scm_i_frame_print(frame: SCM, port: SCM,
8122 pstate: *mut scm_print_state);
8123 pub fn scm_init_frames();
8124 pub fn scm_stack_p(obj: SCM) -> SCM;
8125 pub fn scm_make_stack(obj: SCM, args: SCM) -> SCM;
8126 pub fn scm_stack_id(stack: SCM) -> SCM;
8127 pub fn scm_stack_ref(stack: SCM, i: SCM) -> SCM;
8128 pub fn scm_stack_length(stack: SCM) -> SCM;
8129 pub fn scm_init_stacks();
8130 pub fn __underflow(arg1: *mut _IO_FILE) -> c_int;
8131 pub fn __uflow(arg1: *mut _IO_FILE) -> c_int;
8132 pub fn __overflow(arg1: *mut _IO_FILE, arg2: c_int)
8133 -> c_int;
8134 pub fn _IO_getc(__fp: *mut _IO_FILE) -> c_int;
8135 pub fn _IO_putc(__c: c_int, __fp: *mut _IO_FILE)
8136 -> c_int;
8137 pub fn _IO_feof(__fp: *mut _IO_FILE) -> c_int;
8138 pub fn _IO_ferror(__fp: *mut _IO_FILE) -> c_int;
8139 pub fn _IO_peekc_locked(__fp: *mut _IO_FILE) -> c_int;
8140 pub fn _IO_flockfile(arg1: *mut _IO_FILE);
8141 pub fn _IO_funlockfile(arg1: *mut _IO_FILE);
8142 pub fn _IO_ftrylockfile(arg1: *mut _IO_FILE) -> c_int;
8143 pub fn _IO_vfscanf(arg1: *mut _IO_FILE,
8144 arg2: *const c_char,
8145 arg3: __gnuc_va_list, arg4: *mut c_int)
8146 -> c_int;
8147 pub fn _IO_vfprintf(arg1: *mut _IO_FILE,
8148 arg2: *const c_char,
8149 arg3: __gnuc_va_list) -> c_int;
8150 pub fn _IO_padn(arg1: *mut _IO_FILE, arg2: c_int,
8151 arg3: __ssize_t) -> __ssize_t;
8152 pub fn _IO_sgetn(arg1: *mut _IO_FILE, arg2: *mut c_void,
8153 arg3: size_t) -> size_t;
8154 pub fn _IO_seekoff(arg1: *mut _IO_FILE, arg2: __off64_t,
8155 arg3: c_int,
8156 arg4: c_int) -> __off64_t;
8157 pub fn _IO_seekpos(arg1: *mut _IO_FILE, arg2: __off64_t,
8158 arg3: c_int) -> __off64_t;
8159 pub fn _IO_free_backup_area(arg1: *mut _IO_FILE);
8160 pub fn remove(__filename: *const c_char)
8161 -> c_int;
8162 pub fn rename(__old: *const c_char,
8163 __new: *const c_char)
8164 -> c_int;
8165 pub fn renameat(__oldfd: c_int,
8166 __old: *const c_char,
8167 __newfd: c_int,
8168 __new: *const c_char)
8169 -> c_int;
8170 pub fn tmpfile() -> *mut FILE;
8171 pub fn tmpnam(__s: *mut c_char)
8172 -> *mut c_char;
8173 pub fn tmpnam_r(__s: *mut c_char)
8174 -> *mut c_char;
8175 pub fn tempnam(__dir: *const c_char,
8176 __pfx: *const c_char)
8177 -> *mut c_char;
8178 pub fn fclose(__stream: *mut FILE) -> c_int;
8179 pub fn fflush(__stream: *mut FILE) -> c_int;
8180 pub fn fflush_unlocked(__stream: *mut FILE) -> c_int;
8181 pub fn fopen(__filename: *const c_char,
8182 __modes: *const c_char) -> *mut FILE;
8183 pub fn freopen(__filename: *const c_char,
8184 __modes: *const c_char,
8185 __stream: *mut FILE) -> *mut FILE;
8186 pub fn fdopen(__fd: c_int,
8187 __modes: *const c_char) -> *mut FILE;
8188 pub fn fmemopen(__s: *mut c_void, __len: size_t,
8189 __modes: *const c_char) -> *mut FILE;
8190 pub fn open_memstream(__bufloc: *mut *mut c_char,
8191 __sizeloc: *mut size_t) -> *mut FILE;
8192 pub fn setbuf(__stream: *mut FILE, __buf: *mut c_char);
8193 pub fn setvbuf(__stream: *mut FILE, __buf: *mut c_char,
8194 __modes: c_int, __n: size_t)
8195 -> c_int;
8196 pub fn setbuffer(__stream: *mut FILE, __buf: *mut c_char,
8197 __size: size_t);
8198 pub fn setlinebuf(__stream: *mut FILE);
8199 pub fn fprintf(__stream: *mut FILE,
8200 __format: *const c_char, ...)
8201 -> c_int;
8202 pub fn printf(__format: *const c_char, ...)
8203 -> c_int;
8204 pub fn sprintf(__s: *mut c_char,
8205 __format: *const c_char, ...)
8206 -> c_int;
8207 pub fn vfprintf(__s: *mut FILE, __format: *const c_char,
8208 __arg: __gnuc_va_list) -> c_int;
8209 pub fn vprintf(__format: *const c_char,
8210 __arg: __gnuc_va_list) -> c_int;
8211 pub fn vsprintf(__s: *mut c_char,
8212 __format: *const c_char,
8213 __arg: __gnuc_va_list) -> c_int;
8214 pub fn snprintf(__s: *mut c_char, __maxlen: size_t,
8215 __format: *const c_char, ...)
8216 -> c_int;
8217 pub fn vsnprintf(__s: *mut c_char, __maxlen: size_t,
8218 __format: *const c_char,
8219 __arg: __gnuc_va_list) -> c_int;
8220 pub fn vdprintf(__fd: c_int,
8221 __fmt: *const c_char,
8222 __arg: __gnuc_va_list) -> c_int;
8223 pub fn dprintf(__fd: c_int,
8224 __fmt: *const c_char, ...)
8225 -> c_int;
8226 pub fn fscanf(__stream: *mut FILE,
8227 __format: *const c_char, ...)
8228 -> c_int;
8229 pub fn scanf(__format: *const c_char, ...)
8230 -> c_int;
8231 pub fn sscanf(__s: *const c_char,
8232 __format: *const c_char, ...)
8233 -> c_int;
8234 pub fn vfscanf(__s: *mut FILE, __format: *const c_char,
8235 __arg: __gnuc_va_list) -> c_int;
8236 pub fn vscanf(__format: *const c_char,
8237 __arg: __gnuc_va_list) -> c_int;
8238 pub fn vsscanf(__s: *const c_char,
8239 __format: *const c_char,
8240 __arg: __gnuc_va_list) -> c_int;
8241 pub fn fgetc(__stream: *mut FILE) -> c_int;
8242 pub fn getc(__stream: *mut FILE) -> c_int;
8243 pub fn getchar() -> c_int;
8244 pub fn getc_unlocked(__stream: *mut FILE) -> c_int;
8245 pub fn getchar_unlocked() -> c_int;
8246 pub fn fgetc_unlocked(__stream: *mut FILE) -> c_int;
8247 pub fn fputc(__c: c_int, __stream: *mut FILE)
8248 -> c_int;
8249 pub fn putc(__c: c_int, __stream: *mut FILE)
8250 -> c_int;
8251 pub fn putchar(__c: c_int) -> c_int;
8252 pub fn fputc_unlocked(__c: c_int, __stream: *mut FILE)
8253 -> c_int;
8254 pub fn putc_unlocked(__c: c_int, __stream: *mut FILE)
8255 -> c_int;
8256 pub fn putchar_unlocked(__c: c_int)
8257 -> c_int;
8258 pub fn getw(__stream: *mut FILE) -> c_int;
8259 pub fn putw(__w: c_int, __stream: *mut FILE)
8260 -> c_int;
8261 pub fn fgets(__s: *mut c_char, __n: c_int,
8262 __stream: *mut FILE) -> *mut c_char;
8263 pub fn __getdelim(__lineptr: *mut *mut c_char,
8264 __n: *mut size_t, __delimiter: c_int,
8265 __stream: *mut FILE) -> __ssize_t;
8266 pub fn getdelim(__lineptr: *mut *mut c_char,
8267 __n: *mut size_t, __delimiter: c_int,
8268 __stream: *mut FILE) -> __ssize_t;
8269 pub fn getline(__lineptr: *mut *mut c_char,
8270 __n: *mut size_t, __stream: *mut FILE) -> __ssize_t;
8271 pub fn fputs(__s: *const c_char, __stream: *mut FILE)
8272 -> c_int;
8273 pub fn puts(__s: *const c_char) -> c_int;
8274 pub fn ungetc(__c: c_int, __stream: *mut FILE)
8275 -> c_int;
8276 pub fn fread(__ptr: *mut c_void, __size: size_t,
8277 __n: size_t, __stream: *mut FILE) -> size_t;
8278 pub fn fwrite(__ptr: *const c_void, __size: size_t,
8279 __n: size_t, __s: *mut FILE) -> size_t;
8280 pub fn fread_unlocked(__ptr: *mut c_void, __size: size_t,
8281 __n: size_t, __stream: *mut FILE) -> size_t;
8282 pub fn fwrite_unlocked(__ptr: *const c_void,
8283 __size: size_t, __n: size_t, __stream: *mut FILE)
8284 -> size_t;
8285 pub fn fseek(__stream: *mut FILE, __off: c_long,
8286 __whence: c_int) -> c_int;
8287 pub fn ftell(__stream: *mut FILE) -> c_long;
8288 pub fn rewind(__stream: *mut FILE);
8289 pub fn fseeko(__stream: *mut FILE, __off: __off_t,
8290 __whence: c_int) -> c_int;
8291 pub fn ftello(__stream: *mut FILE) -> __off_t;
8292 pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t)
8293 -> c_int;
8294 pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t)
8295 -> c_int;
8296 pub fn clearerr(__stream: *mut FILE);
8297 pub fn feof(__stream: *mut FILE) -> c_int;
8298 pub fn ferror(__stream: *mut FILE) -> c_int;
8299 pub fn clearerr_unlocked(__stream: *mut FILE);
8300 pub fn feof_unlocked(__stream: *mut FILE) -> c_int;
8301 pub fn ferror_unlocked(__stream: *mut FILE) -> c_int;
8302 pub fn perror(__s: *const c_char);
8303 pub fn fileno(__stream: *mut FILE) -> c_int;
8304 pub fn fileno_unlocked(__stream: *mut FILE) -> c_int;
8305 pub fn popen(__command: *const c_char,
8306 __modes: *const c_char) -> *mut FILE;
8307 pub fn pclose(__stream: *mut FILE) -> c_int;
8308 pub fn ctermid(__s: *mut c_char)
8309 -> *mut c_char;
8310 pub fn flockfile(__stream: *mut FILE);
8311 pub fn ftrylockfile(__stream: *mut FILE) -> c_int;
8312 pub fn funlockfile(__stream: *mut FILE);
8313 pub fn memcpy(__dest: *mut c_void,
8314 __src: *const c_void, __n: size_t)
8315 -> *mut c_void;
8316 pub fn memmove(__dest: *mut c_void,
8317 __src: *const c_void, __n: size_t)
8318 -> *mut c_void;
8319 pub fn memccpy(__dest: *mut c_void,
8320 __src: *const c_void,
8321 __c: c_int, __n: size_t)
8322 -> *mut c_void;
8323 pub fn memset(__s: *mut c_void,
8324 __c: c_int, __n: size_t)
8325 -> *mut c_void;
8326 pub fn memcmp(__s1: *const c_void,
8327 __s2: *const c_void, __n: size_t)
8328 -> c_int;
8329 pub fn memchr(__s: *const c_void,
8330 __c: c_int, __n: size_t)
8331 -> *mut c_void;
8332 pub fn strcpy(__dest: *mut c_char,
8333 __src: *const c_char)
8334 -> *mut c_char;
8335 pub fn strncpy(__dest: *mut c_char,
8336 __src: *const c_char, __n: size_t)
8337 -> *mut c_char;
8338 pub fn strcat(__dest: *mut c_char,
8339 __src: *const c_char)
8340 -> *mut c_char;
8341 pub fn strncat(__dest: *mut c_char,
8342 __src: *const c_char, __n: size_t)
8343 -> *mut c_char;
8344 pub fn strcmp(__s1: *const c_char,
8345 __s2: *const c_char)
8346 -> c_int;
8347 pub fn strncmp(__s1: *const c_char,
8348 __s2: *const c_char, __n: size_t)
8349 -> c_int;
8350 pub fn strcoll(__s1: *const c_char,
8351 __s2: *const c_char)
8352 -> c_int;
8353 pub fn strxfrm(__dest: *mut c_char,
8354 __src: *const c_char, __n: size_t)
8355 -> size_t;
8356 pub fn strcoll_l(__s1: *const c_char,
8357 __s2: *const c_char, __l: __locale_t)
8358 -> c_int;
8359 pub fn strxfrm_l(__dest: *mut c_char,
8360 __src: *const c_char, __n: size_t,
8361 __l: __locale_t) -> size_t;
8362 pub fn strdup(__s: *const c_char)
8363 -> *mut c_char;
8364 pub fn strndup(__string: *const c_char, __n: size_t)
8365 -> *mut c_char;
8366 pub fn strchr(__s: *const c_char,
8367 __c: c_int) -> *mut c_char;
8368 pub fn strrchr(__s: *const c_char,
8369 __c: c_int) -> *mut c_char;
8370 pub fn strcspn(__s: *const c_char,
8371 __reject: *const c_char) -> size_t;
8372 pub fn strspn(__s: *const c_char,
8373 __accept: *const c_char) -> size_t;
8374 pub fn strpbrk(__s: *const c_char,
8375 __accept: *const c_char)
8376 -> *mut c_char;
8377 pub fn strstr(__haystack: *const c_char,
8378 __needle: *const c_char)
8379 -> *mut c_char;
8380 pub fn strtok(__s: *mut c_char,
8381 __delim: *const c_char)
8382 -> *mut c_char;
8383 pub fn __strtok_r(__s: *mut c_char,
8384 __delim: *const c_char,
8385 __save_ptr: *mut *mut c_char)
8386 -> *mut c_char;
8387 pub fn strtok_r(__s: *mut c_char,
8388 __delim: *const c_char,
8389 __save_ptr: *mut *mut c_char)
8390 -> *mut c_char;
8391 pub fn strlen(__s: *const c_char) -> size_t;
8392 pub fn strnlen(__string: *const c_char, __maxlen: size_t)
8393 -> size_t;
8394 pub fn strerror(__errnum: c_int)
8395 -> *mut c_char;
8396 pub fn strerror_r(__errnum: c_int,
8397 __buf: *mut c_char, __buflen: size_t)
8398 -> c_int;
8399 pub fn strerror_l(__errnum: c_int, __l: __locale_t)
8400 -> *mut c_char;
8401 pub fn __bzero(__s: *mut c_void, __n: size_t);
8402 pub fn bcopy(__src: *const c_void,
8403 __dest: *mut c_void, __n: size_t);
8404 pub fn bzero(__s: *mut c_void, __n: size_t);
8405 pub fn bcmp(__s1: *const c_void,
8406 __s2: *const c_void, __n: size_t)
8407 -> c_int;
8408 pub fn index(__s: *const c_char,
8409 __c: c_int) -> *mut c_char;
8410 pub fn rindex(__s: *const c_char,
8411 __c: c_int) -> *mut c_char;
8412 pub fn ffs(__i: c_int) -> c_int;
8413 pub fn strcasecmp(__s1: *const c_char,
8414 __s2: *const c_char)
8415 -> c_int;
8416 pub fn strncasecmp(__s1: *const c_char,
8417 __s2: *const c_char, __n: size_t)
8418 -> c_int;
8419 pub fn strsep(__stringp: *mut *mut c_char,
8420 __delim: *const c_char)
8421 -> *mut c_char;
8422 pub fn strsignal(__sig: c_int)
8423 -> *mut c_char;
8424 pub fn __stpcpy(__dest: *mut c_char,
8425 __src: *const c_char)
8426 -> *mut c_char;
8427 pub fn stpcpy(__dest: *mut c_char,
8428 __src: *const c_char)
8429 -> *mut c_char;
8430 pub fn __stpncpy(__dest: *mut c_char,
8431 __src: *const c_char, __n: size_t)
8432 -> *mut c_char;
8433 pub fn stpncpy(__dest: *mut c_char,
8434 __src: *const c_char, __n: size_t)
8435 -> *mut c_char;
8436 pub fn scm_is_pair(x: SCM) -> c_int;
8437 pub fn scm_is_string(x: SCM) -> c_int;
8438 pub fn scm_get_byte_or_eof(port: SCM) -> c_int;
8439 pub fn scm_peek_byte_or_eof(port: SCM) -> c_int;
8440 pub fn scm_putc(c: c_char, port: SCM);
8441 pub fn scm_puts(s: *const c_char, port: SCM);
8442 pub fn scm_wta(arg: SCM, pos: *const c_char,
8443 s_subr: *const c_char) -> SCM;
8444 pub fn scm_register_module_xxx(module_name: *mut c_char,
8445 init_func: *mut c_void);
8446 pub fn scm_registered_modules() -> SCM;
8447 pub fn scm_clear_registered_modules() -> SCM;
8448 pub fn scm_protect_object(obj: SCM) -> SCM;
8449 pub fn scm_unprotect_object(obj: SCM) -> SCM;
8450 pub fn scm_remember(ptr: *mut SCM);
8451 pub fn scm_make_module(name: SCM) -> SCM;
8452 pub fn scm_ensure_user_module(name: SCM) -> SCM;
8453 pub fn scm_load_scheme_module(name: SCM) -> SCM;
8454 pub fn scm_close_all_ports_except(ports: SCM) -> SCM;
8455 pub fn scm_makstr(len: size_t, arg1: c_int) -> SCM;
8456 pub fn scm_makfromstr(src: *const c_char, len: size_t,
8457 arg1: c_int) -> SCM;
8458 pub fn scm_variable_set_name_hint(var: SCM, hint: SCM) -> SCM;
8459 pub fn scm_builtin_variable(name: SCM) -> SCM;
8460 pub fn scm_internal_with_fluids(fluids: SCM, vals: SCM,
8461 cproc:
8462 ::std::option::Option<unsafe extern "C" fn(arg1:
8463 *mut c_void)
8464 -> SCM>,
8465 cdata: *mut c_void)
8466 -> SCM;
8467 pub fn scm_make_gsubr(name: *const c_char,
8468 req: c_int,
8469 opt: c_int,
8470 rst: c_int, fcn: scm_t_subr) -> SCM;
8471 pub fn scm_make_gsubr_with_generic(name: *const c_char,
8472 req: c_int,
8473 opt: c_int,
8474 rst: c_int,
8475 fcn: scm_t_subr, gf: *mut SCM) -> SCM;
8476 pub fn scm_create_hook(name: *const c_char,
8477 n_args: c_int) -> SCM;
8478 pub fn scm_internal_dynamic_wind(before: scm_t_guard, inner: scm_t_inner,
8479 after: scm_t_guard,
8480 inner_data: *mut c_void,
8481 guard_data: *mut c_void)
8482 -> SCM;
8483 pub fn scm_sloppy_memq(x: SCM, lst: SCM) -> SCM;
8484 pub fn scm_sloppy_memv(x: SCM, lst: SCM) -> SCM;
8485 pub fn scm_sloppy_member(x: SCM, lst: SCM) -> SCM;
8486 pub fn scm_read_and_eval_x(port: SCM) -> SCM;
8487 pub fn scm_call_catching_errors(thunk: scm_t_subr, err_filter: scm_t_subr,
8488 closure: *mut c_void)
8489 -> SCM;
8490 pub fn scm_make_smob_type_mfpe(name: *mut c_char,
8491 size: size_t,
8492 mark:
8493 ::std::option::Option<extern "C" fn(arg1:
8494 SCM)
8495 -> SCM>,
8496 free:
8497 ::std::option::Option<extern "C" fn(arg1:
8498 SCM)
8499 -> size_t>,
8500 print:
8501 ::std::option::Option<unsafe extern "C" fn(arg1:
8502 SCM,
8503 arg2:
8504 SCM,
8505 arg3:
8506 *mut scm_print_state)
8507 ->
8508 c_int>,
8509 equalp:
8510 ::std::option::Option<extern "C" fn(arg1:
8511 SCM,
8512 arg2:
8513 SCM)
8514 -> SCM>)
8515 -> c_long;
8516 pub fn scm_set_smob_mfpe(tc: c_long,
8517 mark:
8518 ::std::option::Option<extern "C" fn(arg1:
8519 SCM)
8520 -> SCM>,
8521 free:
8522 ::std::option::Option<extern "C" fn(arg1:
8523 SCM)
8524 -> size_t>,
8525 print:
8526 ::std::option::Option<unsafe extern "C" fn(arg1:
8527 SCM,
8528 arg2:
8529 SCM,
8530 arg3:
8531 *mut scm_print_state)
8532 ->
8533 c_int>,
8534 equalp:
8535 ::std::option::Option<extern "C" fn(arg1:
8536 SCM,
8537 arg2:
8538 SCM)
8539 -> SCM>);
8540 pub fn scm_smob_free(obj: SCM) -> size_t;
8541 pub fn scm_strprint_obj(obj: SCM) -> SCM;
8542 pub fn scm_read_0str(expr: *mut c_char) -> SCM;
8543 pub fn scm_eval_0str(expr: *const c_char) -> SCM;
8544 pub fn scm_i_object_chars(arg1: SCM) -> *mut c_char;
8545 pub fn scm_i_object_length(arg1: SCM) -> c_long;
8546 pub fn scm_sym2ovcell_soft(sym: SCM, obarray: SCM) -> SCM;
8547 pub fn scm_sym2ovcell(sym: SCM, obarray: SCM) -> SCM;
8548 pub fn scm_intern_obarray_soft(name: *const c_char,
8549 len: size_t, obarray: SCM,
8550 softness: c_uint) -> SCM;
8551 pub fn scm_intern_obarray(name: *const c_char,
8552 len: size_t, obarray: SCM) -> SCM;
8553 pub fn scm_symbol_value0(name: *const c_char) -> SCM;
8554 pub fn scm_string_to_obarray_symbol(o: SCM, s: SCM, softp: SCM) -> SCM;
8555 pub fn scm_intern_symbol(o: SCM, s: SCM) -> SCM;
8556 pub fn scm_unintern_symbol(o: SCM, s: SCM) -> SCM;
8557 pub fn scm_symbol_binding(o: SCM, s: SCM) -> SCM;
8558 pub fn scm_symbol_bound_p(o: SCM, s: SCM) -> SCM;
8559 pub fn scm_symbol_set_x(o: SCM, s: SCM, v: SCM) -> SCM;
8560 pub fn scm_gentemp(prefix: SCM, obarray: SCM) -> SCM;
8561 pub fn scm_i_makinum(val: scm_t_signed_bits) -> SCM;
8562 pub fn scm_i_inump(obj: SCM) -> c_int;
8563 pub fn scm_i_inum(obj: SCM) -> scm_t_signed_bits;
8564 pub fn scm_c_string2str(obj: SCM, str: *mut c_char,
8565 lenp: *mut size_t) -> *mut c_char;
8566 pub fn scm_c_substring2str(obj: SCM, str: *mut c_char,
8567 start: size_t, len: size_t)
8568 -> *mut c_char;
8569 pub fn scm_c_symbol2str(obj: SCM, str: *mut c_char,
8570 lenp: *mut size_t) -> *mut c_char;
8571 pub fn scm_truncate(x: c_double)
8572 -> c_double;
8573 pub fn scm_round(x: c_double) -> c_double;
8574 pub fn scm_sys_expt(x: SCM, y: SCM) -> SCM;
8575 pub fn scm_asinh(x: c_double) -> c_double;
8576 pub fn scm_acosh(x: c_double) -> c_double;
8577 pub fn scm_atanh(x: c_double) -> c_double;
8578 pub fn scm_sys_atan2(z1: SCM, z2: SCM) -> SCM;
8579 pub fn scm_i_deprecated_symbol_chars(sym: SCM)
8580 -> *mut c_char;
8581 pub fn scm_i_deprecated_symbol_length(sym: SCM) -> size_t;
8582 pub fn scm_i_keywordp(obj: SCM) -> c_int;
8583 pub fn scm_i_keywordsym(keyword: SCM) -> SCM;
8584 pub fn scm_i_vectorp(x: SCM) -> c_int;
8585 pub fn scm_i_vector_length(x: SCM) -> c_ulong;
8586 pub fn scm_i_velts(x: SCM) -> *const SCM;
8587 pub fn scm_i_writable_velts(x: SCM) -> *mut SCM;
8588 pub fn scm_i_vector_ref(x: SCM, idx: size_t) -> SCM;
8589 pub fn scm_i_vector_set(x: SCM, idx: size_t, val: SCM);
8590 pub fn scm_vector_equal_p(x: SCM, y: SCM) -> SCM;
8591 pub fn scm_i_arrayp(a: SCM) -> c_int;
8592 pub fn scm_i_array_ndim(a: SCM) -> size_t;
8593 pub fn scm_i_array_contp(a: SCM) -> c_int;
8594 pub fn scm_i_array_mem(a: SCM) -> *mut scm_t_array;
8595 pub fn scm_i_array_v(a: SCM) -> SCM;
8596 pub fn scm_i_array_base(a: SCM) -> size_t;
8597 pub fn scm_i_array_dims(a: SCM) -> *mut scm_t_array_dim;
8598 pub fn scm_uniform_array_read_x(ra: SCM, port_or_fd: SCM, start: SCM,
8599 end: SCM) -> SCM;
8600 pub fn scm_uniform_array_write(v: SCM, port_or_fd: SCM, start: SCM,
8601 end: SCM) -> SCM;
8602 pub fn scm_i_cur_inp() -> SCM;
8603 pub fn scm_i_cur_outp() -> SCM;
8604 pub fn scm_i_cur_errp() -> SCM;
8605 pub fn scm_i_cur_loadp() -> SCM;
8606 pub fn scm_i_progargs() -> SCM;
8607 pub fn scm_i_deprecated_dynwinds() -> SCM;
8608 pub fn scm_i_stack_base() -> *mut SCM_STACKITEM;
8609 pub fn scm_i_fluidp(x: SCM) -> c_int;
8610 pub fn scm_i_defer_ints_etc();
8611 pub fn scm_i_mask_ints() -> c_int;
8612 pub fn scm_guard(guardian: SCM, obj: SCM, throw_p: c_int)
8613 -> SCM;
8614 pub fn scm_get_one_zombie(guardian: SCM) -> SCM;
8615 pub fn scm_destroy_guardian_x(guardian: SCM) -> SCM;
8616 pub fn scm_guardian_greedy_p(guardian: SCM) -> SCM;
8617 pub fn scm_guardian_destroyed_p(guardian: SCM) -> SCM;
8618 pub fn scm_trampoline_0(_proc: SCM) -> scm_t_trampoline_0;
8619 pub fn scm_trampoline_1(_proc: SCM) -> scm_t_trampoline_1;
8620 pub fn scm_trampoline_2(_proc: SCM) -> scm_t_trampoline_2;
8621 pub fn scm_i_subr_p(x: SCM) -> c_int;
8622 pub fn scm_lazy_catch(tag: SCM, thunk: SCM, handler: SCM) -> SCM;
8623 pub fn scm_internal_lazy_catch(tag: SCM, body: scm_t_catch_body,
8624 body_data: *mut c_void,
8625 handler: scm_t_catch_handler,
8626 handler_data: *mut c_void)
8627 -> SCM;
8628 pub fn scm_raequal(ra0: SCM, ra1: SCM) -> SCM;
8629 pub fn scm_dynamic_args_call(symb: SCM, dobj: SCM, args: SCM) -> SCM;
8630 pub fn scm_badargsp(formals: SCM, args: SCM) -> c_int;
8631 pub fn scm_internal_stack_catch(tag: SCM, body: scm_t_catch_body,
8632 body_data: *mut c_void,
8633 handler: scm_t_catch_handler,
8634 handler_data: *mut c_void)
8635 -> SCM;
8636 pub fn scm_short2num(n: c_short) -> SCM;
8637 pub fn scm_ushort2num(n: c_ushort) -> SCM;
8638 pub fn scm_int2num(n: c_int) -> SCM;
8639 pub fn scm_uint2num(n: c_uint) -> SCM;
8640 pub fn scm_long2num(n: c_long) -> SCM;
8641 pub fn scm_ulong2num(n: c_ulong) -> SCM;
8642 pub fn scm_size2num(n: size_t) -> SCM;
8643 pub fn scm_ptrdiff2num(n: scm_t_ptrdiff) -> SCM;
8644 pub fn scm_num2short(num: SCM, pos: c_ulong,
8645 s_caller: *const c_char)
8646 -> c_short;
8647 pub fn scm_num2ushort(num: SCM, pos: c_ulong,
8648 s_caller: *const c_char)
8649 -> c_ushort;
8650 pub fn scm_num2int(num: SCM, pos: c_ulong,
8651 s_caller: *const c_char)
8652 -> c_int;
8653 pub fn scm_num2uint(num: SCM, pos: c_ulong,
8654 s_caller: *const c_char)
8655 -> c_uint;
8656 pub fn scm_num2long(num: SCM, pos: c_ulong,
8657 s_caller: *const c_char)
8658 -> c_long;
8659 pub fn scm_num2ulong(num: SCM, pos: c_ulong,
8660 s_caller: *const c_char)
8661 -> c_ulong;
8662 pub fn scm_num2ptrdiff(num: SCM, pos: c_ulong,
8663 s_caller: *const c_char)
8664 -> scm_t_ptrdiff;
8665 pub fn scm_num2size(num: SCM, pos: c_ulong,
8666 s_caller: *const c_char) -> size_t;
8667 pub fn scm_long_long2num(sl: c_longlong) -> SCM;
8668 pub fn scm_ulong_long2num(sl: c_ulonglong) -> SCM;
8669 pub fn scm_num2long_long(num: SCM, pos: c_ulong,
8670 s_caller: *const c_char)
8671 -> c_longlong;
8672 pub fn scm_num2ulong_long(num: SCM, pos: c_ulong,
8673 s_caller: *const c_char)
8674 -> c_ulonglong;
8675 pub fn scm_make_real(x: c_double) -> SCM;
8676 pub fn scm_num2dbl(a: SCM, why: *const c_char)
8677 -> c_double;
8678 pub fn scm_float2num(n: c_float) -> SCM;
8679 pub fn scm_double2num(n: c_double) -> SCM;
8680 pub fn scm_num2float(num: SCM, pos: c_ulong,
8681 s_caller: *const c_char)
8682 -> c_float;
8683 pub fn scm_num2double(num: SCM, pos: c_ulong,
8684 s_caller: *const c_char)
8685 -> c_double;
8686 pub fn scm_make_complex(x: c_double,
8687 y: c_double) -> SCM;
8688 pub fn scm_mem2symbol(mem: *const c_char, len: size_t)
8689 -> SCM;
8690 pub fn scm_mem2uninterned_symbol(mem: *const c_char,
8691 len: size_t) -> SCM;
8692 pub fn scm_str2symbol(str: *const c_char) -> SCM;
8693 pub fn scm_take_str(s: *mut c_char, len: size_t) -> SCM;
8694 pub fn scm_take0str(s: *mut c_char) -> SCM;
8695 pub fn scm_mem2string(src: *const c_char, len: size_t)
8696 -> SCM;
8697 pub fn scm_str2string(src: *const c_char) -> SCM;
8698 pub fn scm_makfrom0str(src: *const c_char) -> SCM;
8699 pub fn scm_makfrom0str_opt(src: *const c_char) -> SCM;
8700 pub fn scm_allocate_string(len: size_t) -> SCM;
8701 pub fn scm_make_keyword_from_dash_symbol(symbol: SCM) -> SCM;
8702 pub fn scm_keyword_dash_symbol(keyword: SCM) -> SCM;
8703 pub fn scm_c_make_keyword(s: *const c_char) -> SCM;
8704 pub fn scm_thread_sleep(arg1: c_uint)
8705 -> c_uint;
8706 pub fn scm_thread_usleep(arg1: c_ulong)
8707 -> c_ulong;
8708 pub fn scm_internal_select(fds: c_int, rfds: *mut fd_set,
8709 wfds: *mut fd_set, efds: *mut fd_set,
8710 timeout: *mut Struct_timeval)
8711 -> c_int;
8712 pub fn scm_cuserid() -> SCM;
8713 pub fn scm_primitive_make_property(not_found_proc: SCM) -> SCM;
8714 pub fn scm_primitive_property_ref(prop: SCM, obj: SCM) -> SCM;
8715 pub fn scm_primitive_property_set_x(prop: SCM, obj: SCM, val: SCM) -> SCM;
8716 pub fn scm_primitive_property_del_x(prop: SCM, obj: SCM) -> SCM;
8717 pub fn scm_whash_get_handle(whash: SCM, key: SCM) -> SCM;
8718 pub fn SCM_WHASHFOUNDP(h: SCM) -> c_int;
8719 pub fn SCM_WHASHREF(whash: SCM, handle: SCM) -> SCM;
8720 pub fn SCM_WHASHSET(whash: SCM, handle: SCM, obj: SCM);
8721 pub fn scm_whash_create_handle(whash: SCM, key: SCM) -> SCM;
8722 pub fn scm_whash_lookup(whash: SCM, obj: SCM) -> SCM;
8723 pub fn scm_whash_insert(whash: SCM, key: SCM, obj: SCM);
8724 pub fn scm_struct_create_handle(obj: SCM) -> SCM;
8725 pub fn scm_immutable_cell(car: scm_t_bits, cdr: scm_t_bits) -> SCM;
8726 pub fn scm_immutable_double_cell(car: scm_t_bits, cbr: scm_t_bits,
8727 ccr: scm_t_bits, cdr: scm_t_bits) -> SCM;
8728 pub fn scm_i_deprecated_asrtgo(condition: scm_t_bits) -> scm_t_bits;
8729 pub fn scm_sym2var(sym: SCM, thunk: SCM, definep: SCM) -> SCM;
8730 pub fn scm_lookup_closure_module(_proc: SCM) -> SCM;
8731 pub fn scm_module_lookup_closure(module: SCM) -> SCM;
8732 pub fn scm_current_module_lookup_closure() -> SCM;
8733 pub fn scm_eval_closure_lookup(eclo: SCM, sym: SCM, definep: SCM) -> SCM;
8734 pub fn scm_standard_eval_closure(module: SCM) -> SCM;
8735 pub fn scm_standard_interface_eval_closure(module: SCM) -> SCM;
8736 pub fn scm_eval_closure_module(eval_closure: SCM) -> SCM;
8737 pub fn scm_struct_vtable_tag(handle: SCM) -> SCM;
8738 pub fn scm_generalized_vector_p(v: SCM) -> SCM;
8739 pub fn scm_generalized_vector_length(v: SCM) -> SCM;
8740 pub fn scm_generalized_vector_ref(v: SCM, idx: SCM) -> SCM;
8741 pub fn scm_generalized_vector_set_x(v: SCM, idx: SCM, val: SCM) -> SCM;
8742 pub fn scm_generalized_vector_to_list(v: SCM) -> SCM;
8743 pub fn scm_c_program_source(program: SCM, ip: size_t) -> SCM;
8744 pub fn scm_gc_live_object_stats() -> SCM;
8745 pub fn scm_htons(_in: SCM) -> SCM;
8746 pub fn scm_ntohs(_in: SCM) -> SCM;
8747 pub fn scm_htonl(_in: SCM) -> SCM;
8748 pub fn scm_ntohl(_in: SCM) -> SCM;
8749 pub fn scm_i_init_deprecated();
8750}