parameter names

aio/lib.rs

@@ -8,50 +8,50 @@ pub struct aiocb {
 }
 
 #[no_mangle]
-pub extern "C" fn aio_read(__aiocbp: *mut aiocb) -> libc::c_int {
+pub extern "C" fn aio_read(aiocbp: *mut aiocb) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn aio_write(__aiocbp: *mut aiocb) -> libc::c_int {
+pub extern "C" fn aio_write(aiocbp: *mut aiocb) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn lio_listio(
-    __mode: libc::c_int,
-    __list: *const *const aiocb,
-    __nent: libc::c_int,
-    __sig: *mut sigevent,
+    mode: libc::c_int,
+    list: *const *const aiocb,
+    nent: libc::c_int,
+    sig: *mut sigevent,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn aio_error(__aiocbp: *const aiocb) -> libc::c_int {
+pub extern "C" fn aio_error(aiocbp: *const aiocb) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn aio_return(__aiocbp: *mut aiocb) -> __ssize_t {
+pub extern "C" fn aio_return(aiocbp: *mut aiocb) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn aio_cancel(__fildes: libc::c_int, __aiocbp: *mut aiocb) -> libc::c_int {
+pub extern "C" fn aio_cancel(fildes: libc::c_int, aiocbp: *mut aiocb) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn aio_suspend(
-    __list: *const *const aiocb,
-    __nent: libc::c_int,
-    __timeout: *const timespec,
+    list: *const *const aiocb,
+    nent: libc::c_int,
+    timeout: *const timespec,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn aio_fsync(__operation: libc::c_int, __aiocbp: *mut aiocb) -> libc::c_int {
+pub extern "C" fn aio_fsync(operation: libc::c_int, aiocbp: *mut aiocb) -> libc::c_int {
     unimplemented!();
 }

bindgen_transform.sh

@@ -1,4 +1,4 @@
 sed -i 's/::std::os::raw::/libc::/g' $1
 perl -i -p0e 's/extern "C" \{\n    pub fn/#[no_mangle]\npub extern "C" fn/g' $1 
 perl -i -p0e 's/;\n\}/ {\n    unimplemented!();\n\}\n/g' $1
-
+rustfmt $1

ctype/lib.rs

@@ -1,76 +1,76 @@
 /* automatically generated by rust-bindgen */
 
 #[no_mangle]
-pub extern "C" fn isalnum(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn isalnum(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn isalpha(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn isalpha(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn isascii(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn isascii(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iscntrl(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn iscntrl(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn isdigit(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn isdigit(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn isgraph(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn isgraph(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn islower(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn islower(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn isprint(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn isprint(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn ispunct(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn ispunct(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn isspace(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn isspace(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn isupper(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn isupper(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn isxdigit(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn isxdigit(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn toascii(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn toascii(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn tolower(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn tolower(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn toupper(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn toupper(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }

grp/lib.rs

@@ -13,33 +13,33 @@ impl Clone for group {
     }
 }
 #[no_mangle]
-pub extern "C" fn getgrgid(arg1: gid_t) -> *mut group {
+pub extern "C" fn getgrgid(gid: gid_t) -> *mut group {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn getgrnam(arg1: *const libc::c_char) -> *mut group {
+pub extern "C" fn getgrnam(name: *const libc::c_char) -> *mut group {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn getgrgid_r(
-    arg1: gid_t,
-    arg2: *mut group,
-    arg3: *mut libc::c_char,
-    arg4: usize,
-    arg5: *mut *mut group,
+    gid: gid_t,
+    grp: *mut group,
+    buffer: *mut libc::c_char,
+    bufsize: usize,
+    result: *mut *mut group,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn getgrnam_r(
-    arg1: *const libc::c_char,
-    arg2: *mut group,
-    arg3: *mut libc::c_char,
-    arg4: usize,
-    arg5: *mut *mut group,
+    name: *const libc::c_char,
+    grp: *mut group,
+    buffer: *mut libc::c_char,
+    bufsize: usize,
+    result: *mut *mut group,
 ) -> libc::c_int {
     unimplemented!();
 }

mman/lib.rs

@@ -1,37 +1,37 @@
 #[no_mangle]
-pub extern "C" fn mlock(arg1: *const libc::c_void, arg2: usize) -> libc::c_int {
+pub extern "C" fn mlock(addr: *const libc::c_void, len: usize) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn mlockall(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn mlockall(flags: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn mmap(
-    arg1: *mut libc::c_void,
-    arg2: usize,
-    arg3: libc::c_int,
-    arg4: libc::c_int,
-    arg5: libc::c_int,
-    arg6: off_t,
+    addr: *mut libc::c_void,
+    len: usize,
+    prot: libc::c_int,
+    flags: libc::c_int,
+    fildes: libc::c_int,
+    off: off_t,
 ) -> *mut libc::c_void {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn mprotect(arg1: *mut libc::c_void, arg2: usize, arg3: libc::c_int) -> libc::c_int {
+pub extern "C" fn mprotect(addr: *mut libc::c_void, len: usize, prot: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn msync(arg1: *mut libc::c_void, arg2: usize, arg3: libc::c_int) -> libc::c_int {
+pub extern "C" fn msync(addr: *mut libc::c_void, len: usize, flags: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn munlock(arg1: *const libc::c_void, arg2: usize) -> libc::c_int {
+pub extern "C" fn munlock(addr: *const libc::c_void, len: usize) -> libc::c_int {
     unimplemented!();
 }
 
@@ -41,20 +41,20 @@ pub extern "C" fn munlockall() -> libc::c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn munmap(arg1: *mut libc::c_void, arg2: usize) -> libc::c_int {
+pub extern "C" fn munmap(addr: *mut libc::c_void, len: usize) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn shm_open(
-    arg1: *const libc::c_char,
-    arg2: libc::c_int,
-    arg3: mode_t,
+    name: *const libc::c_char,
+    oflag: libc::c_int,
+    mode: mode_t,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn shm_unlink(arg1: *const libc::c_char) -> libc::c_int {
+pub extern "C" fn shm_unlink(name: *const libc::c_char) -> libc::c_int {
     unimplemented!();
 }

pthread/lib.rs

@@ -1,68 +1,68 @@
 #[no_mangle]
-pub extern "C" fn pthread_attr_destroy(arg1: *mut pthread_attr_t) -> libc::c_int {
+pub extern "C" fn pthread_attr_destroy(attr: *mut pthread_attr_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_getdetachstate(
-    arg1: *const pthread_attr_t,
-    arg2: *mut libc::c_int,
+    attr: *const pthread_attr_t,
+    detachstate: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_getguardsize(
-    arg1: *const pthread_attr_t,
-    arg2: *mut usize,
+    attr: *const pthread_attr_t,
+    guardsize: *mut usize,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_getinheritsched(
-    arg1: *const pthread_attr_t,
-    arg2: *mut libc::c_int,
+    attr: *const pthread_attr_t,
+    inheritsched: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_getschedparam(
-    arg1: *const pthread_attr_t,
-    arg2: *mut sched_param,
+    attr: *const pthread_attr_t,
+    param: *mut sched_param,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_getschedpolicy(
-    arg1: *const pthread_attr_t,
-    arg2: *mut libc::c_int,
+    attr: *const pthread_attr_t,
+    policy: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_getscope(
-    arg1: *const pthread_attr_t,
-    arg2: *mut libc::c_int,
+    attr: *const pthread_attr_t,
+    contentionscope: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_getstackaddr(
-    arg1: *const pthread_attr_t,
-    arg2: *mut *mut libc::c_void,
+    attr: *const pthread_attr_t,
+    stackaddr: *mut *mut libc::c_void,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_getstacksize(
-    arg1: *const pthread_attr_t,
-    arg2: *mut usize,
+    attr: *const pthread_attr_t,
+    stacksize: *mut usize,
 ) -> libc::c_int {
     unimplemented!();
 }
@@ -74,8 +74,8 @@ pub extern "C" fn pthread_attr_init(arg1: *mut pthread_attr_t) -> libc::c_int {
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_setdetachstate(
-    arg1: *mut pthread_attr_t,
-    arg2: libc::c_int,
+    attr: *mut pthread_attr_t,
+    detachstate: libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
@@ -87,152 +87,152 @@ pub extern "C" fn pthread_attr_setguardsize(arg1: *mut pthread_attr_t, arg2: usi
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_setinheritsched(
-    arg1: *mut pthread_attr_t,
-    arg2: libc::c_int,
+    attr: *mut pthread_attr_t,
+    inheritsched: libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_setschedparam(
-    arg1: *mut pthread_attr_t,
-    arg2: *mut sched_param,
+    attr: *mut pthread_attr_t,
+    param: *mut sched_param,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_setschedpolicy(
-    arg1: *mut pthread_attr_t,
-    arg2: libc::c_int,
+    attr: *mut pthread_attr_t,
+    policy: libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_setscope(
-    arg1: *mut pthread_attr_t,
-    arg2: libc::c_int,
+    attr: *mut pthread_attr_t,
+    contentionscope: libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_attr_setstackaddr(
-    arg1: *mut pthread_attr_t,
-    arg2: *mut libc::c_void,
+    attr: *mut pthread_attr_t,
+    stackaddr: *mut libc::c_void,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_attr_setstacksize(arg1: *mut pthread_attr_t, arg2: usize) -> libc::c_int {
+pub extern "C" fn pthread_attr_setstacksize(attr: *mut pthread_attr_t, stacksize: usize) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_cancel(arg1: pthread_t) -> libc::c_int {
+pub extern "C" fn pthread_cancel(thread: pthread_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_cleanup_push(arg1: *mut libc::c_void, arg2: *mut libc::c_void) {
+pub extern "C" fn pthread_cleanup_push(routine: *mut libc::c_void, arg: *mut libc::c_void) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_cleanup_pop(arg1: libc::c_int) {
+pub extern "C" fn pthread_cleanup_pop(execute: libc::c_int) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_cond_broadcast(arg1: *mut pthread_cond_t) -> libc::c_int {
+pub extern "C" fn pthread_cond_broadcast(cond: *mut pthread_cond_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_cond_destroy(arg1: *mut pthread_cond_t) -> libc::c_int {
+pub extern "C" fn pthread_cond_destroy(cond: *mut pthread_cond_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_cond_init(
-    arg1: *mut pthread_cond_t,
-    arg2: *const pthread_condattr_t,
+    cond: *mut pthread_cond_t,
+    attr: *const pthread_condattr_t,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_cond_signal(arg1: *mut pthread_cond_t) -> libc::c_int {
+pub extern "C" fn pthread_cond_signal(cond: *mut pthread_cond_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_cond_timedwait(
-    arg1: *mut pthread_cond_t,
-    arg2: *mut pthread_mutex_t,
-    arg3: *const timespec,
+    cond: *mut pthread_cond_t,
+    mutex: *mut pthread_mutex_t,
+    abstime: *const timespec,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_cond_wait(
-    arg1: *mut pthread_cond_t,
-    arg2: *mut pthread_mutex_t,
+    cond: *mut pthread_cond_t,
+    mutex: *mut pthread_mutex_t,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_condattr_destroy(arg1: *mut pthread_condattr_t) -> libc::c_int {
+pub extern "C" fn pthread_condattr_destroy(attr: *mut pthread_condattr_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_condattr_getpshared(
-    arg1: *const pthread_condattr_t,
-    arg2: *mut libc::c_int,
+    attr: *const pthread_condattr_t,
+    pshared: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_condattr_init(arg1: *mut pthread_condattr_t) -> libc::c_int {
+pub extern "C" fn pthread_condattr_init(attr: *mut pthread_condattr_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_condattr_setpshared(
-    arg1: *mut pthread_condattr_t,
-    arg2: libc::c_int,
+    attr: *mut pthread_condattr_t,
+    pshared: libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_create(
-    arg1: *mut pthread_t,
-    arg2: *const pthread_attr_t,
-    arg3: ::std::option::Option<unsafe extern "C" fn(arg1: *mut libc::c_void) -> *mut libc::c_void>,
-    arg4: *mut libc::c_void,
+    thread: *mut pthread_t,
+    attr: *const pthread_attr_t,
+    start_routine: ::std::option::Option<unsafe extern "C" fn(arg1: *mut libc::c_void) -> *mut libc::c_void>,
+    arg: *mut libc::c_void,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_detach(arg1: pthread_t) -> libc::c_int {
+pub extern "C" fn pthread_detach(thread: pthread_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_equal(arg1: pthread_t, arg2: pthread_t) -> libc::c_int {
+pub extern "C" fn pthread_equal(t1: pthread_t, t2: pthread_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_exit(arg1: *mut libc::c_void) {
+pub extern "C" fn pthread_exit(value_ptr: *mut libc::c_void) {
     unimplemented!();
 }
 
@@ -243,223 +243,223 @@ pub extern "C" fn pthread_getconcurrency() -> libc::c_int {
 
 #[no_mangle]
 pub extern "C" fn pthread_getschedparam(
-    arg1: pthread_t,
-    arg2: *mut libc::c_int,
-    arg3: *mut sched_param,
+    thread: pthread_t,
+    policy: *mut libc::c_int,
+    param: *mut sched_param,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_getspecific(arg1: pthread_key_t) -> *mut libc::c_void {
+pub extern "C" fn pthread_getspecific(key: pthread_key_t) -> *mut libc::c_void {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_join(arg1: pthread_t, arg2: *mut *mut libc::c_void) -> libc::c_int {
+pub extern "C" fn pthread_join(thread: pthread_t, value_ptr: *mut *mut libc::c_void) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_key_create(
-    arg1: *mut pthread_key_t,
-    arg2: ::std::option::Option<unsafe extern "C" fn(arg1: *mut libc::c_void)>,
+    key: *mut pthread_key_t,
+    destructor: ::std::option::Option<unsafe extern "C" fn(arg1: *mut libc::c_void)>,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_key_delete(arg1: pthread_key_t) -> libc::c_int {
+pub extern "C" fn pthread_key_delete(key: pthread_key_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_mutex_destroy(arg1: *mut pthread_mutex_t) -> libc::c_int {
+pub extern "C" fn pthread_mutex_destroy(mutex: *mut pthread_mutex_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_mutex_getprioceiling(
-    arg1: *const pthread_mutex_t,
-    arg2: *mut libc::c_int,
+    mutex: *const pthread_mutex_t,
+    prioceiling: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_mutex_init(
-    arg1: *mut pthread_mutex_t,
-    arg2: *const pthread_mutexattr_t,
+    mutex: *mut pthread_mutex_t,
+    attr: *const pthread_mutexattr_t,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_mutex_lock(arg1: *mut pthread_mutex_t) -> libc::c_int {
+pub extern "C" fn pthread_mutex_lock(mutex: *mut pthread_mutex_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_mutex_setprioceiling(
-    arg1: *mut pthread_mutex_t,
-    arg2: libc::c_int,
-    arg3: *mut libc::c_int,
+    mutex: *mut pthread_mutex_t,
+    prioceiling: libc::c_int,
+    old_ceiling: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_mutex_trylock(arg1: *mut pthread_mutex_t) -> libc::c_int {
+pub extern "C" fn pthread_mutex_trylock(mutex: *mut pthread_mutex_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_mutex_unlock(arg1: *mut pthread_mutex_t) -> libc::c_int {
+pub extern "C" fn pthread_mutex_unlock(mutex: *mut pthread_mutex_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_mutexattr_destroy(arg1: *mut pthread_mutexattr_t) -> libc::c_int {
+pub extern "C" fn pthread_mutexattr_destroy(attr: *mut pthread_mutexattr_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_mutexattr_getprioceiling(
-    arg1: *const pthread_mutexattr_t,
-    arg2: *mut libc::c_int,
+    attr: *const pthread_mutexattr_t,
+    prioceiling: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_mutexattr_getprotocol(
-    arg1: *const pthread_mutexattr_t,
-    arg2: *mut libc::c_int,
+    attr: *const pthread_mutexattr_t,
+    protocol: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_mutexattr_getpshared(
-    arg1: *const pthread_mutexattr_t,
-    arg2: *mut libc::c_int,
+    attr: *const pthread_mutexattr_t,
+    pshared: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_mutexattr_gettype(
-    arg1: *const pthread_mutexattr_t,
-    arg2: *mut libc::c_int,
+    attr: *const pthread_mutexattr_t,
+    type_: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_mutexattr_init(arg1: *mut pthread_mutexattr_t) -> libc::c_int {
+pub extern "C" fn pthread_mutexattr_init(attr: *mut pthread_mutexattr_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_mutexattr_setprioceiling(
-    arg1: *mut pthread_mutexattr_t,
-    arg2: libc::c_int,
+    attr: *mut pthread_mutexattr_t,
+    prioceiling: libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_mutexattr_setprotocol(
-    arg1: *mut pthread_mutexattr_t,
-    arg2: libc::c_int,
+    attr: *mut pthread_mutexattr_t,
+    protocol: libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_mutexattr_setpshared(
-    arg1: *mut pthread_mutexattr_t,
-    arg2: libc::c_int,
+    attr: *mut pthread_mutexattr_t,
+    pshared: libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_mutexattr_settype(
-    arg1: *mut pthread_mutexattr_t,
-    arg2: libc::c_int,
+    attr: *mut pthread_mutexattr_t,
+    type_: libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_once(
-    arg1: *mut pthread_once_t,
-    arg2: ::std::option::Option<unsafe extern "C" fn()>,
+    once_control: *mut pthread_once_t,
+    init_routine: ::std::option::Option<unsafe extern "C" fn()>,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_rwlock_destroy(arg1: *mut pthread_rwlock_t) -> libc::c_int {
+pub extern "C" fn pthread_rwlock_destroy(rwlock: *mut pthread_rwlock_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_rwlock_init(
-    arg1: *mut pthread_rwlock_t,
-    arg2: *const pthread_rwlockattr_t,
+    rwlock: *mut pthread_rwlock_t,
+    attr: *const pthread_rwlockattr_t,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_rwlock_rdlock(arg1: *mut pthread_rwlock_t) -> libc::c_int {
+pub extern "C" fn pthread_rwlock_rdlock(rwlock: *mut pthread_rwlock_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_rwlock_tryrdlock(arg1: *mut pthread_rwlock_t) -> libc::c_int {
+pub extern "C" fn pthread_rwlock_tryrdlock(rwlock: *mut pthread_rwlock_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_rwlock_trywrlock(arg1: *mut pthread_rwlock_t) -> libc::c_int {
+pub extern "C" fn pthread_rwlock_trywrlock(rwlock: *mut pthread_rwlock_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_rwlock_unlock(arg1: *mut pthread_rwlock_t) -> libc::c_int {
+pub extern "C" fn pthread_rwlock_unlock(rwlock: *mut pthread_rwlock_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_rwlock_wrlock(arg1: *mut pthread_rwlock_t) -> libc::c_int {
+pub extern "C" fn pthread_rwlock_wrlock(rwlock: *mut pthread_rwlock_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_rwlockattr_destroy(arg1: *mut pthread_rwlockattr_t) -> libc::c_int {
+pub extern "C" fn pthread_rwlockattr_destroy(rwlock: *mut pthread_rwlockattr_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_rwlockattr_getpshared(
-    arg1: *const pthread_rwlockattr_t,
-    arg2: *mut libc::c_int,
+    rwlock: *const pthread_rwlockattr_t,
+    pshared: *mut libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_rwlockattr_init(arg1: *mut pthread_rwlockattr_t) -> libc::c_int {
+pub extern "C" fn pthread_rwlockattr_init(rwlock: *mut pthread_rwlockattr_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_rwlockattr_setpshared(
-    arg1: *mut pthread_rwlockattr_t,
-    arg2: libc::c_int,
+    rwlock: *mut pthread_rwlockattr_t,
+    pshared: libc::c_int,
 ) -> libc::c_int {
     unimplemented!();
 }
@@ -470,33 +470,33 @@ pub extern "C" fn pthread_self() -> pthread_t {
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_setcancelstate(arg1: libc::c_int, arg2: *mut libc::c_int) -> libc::c_int {
+pub extern "C" fn pthread_setcancelstate(state: libc::c_int, oldstate: *mut libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_setcanceltype(arg1: libc::c_int, arg2: *mut libc::c_int) -> libc::c_int {
+pub extern "C" fn pthread_setcanceltype(type_: libc::c_int, oldtype: *mut libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pthread_setconcurrency(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn pthread_setconcurrency(new_level: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_setschedparam(
-    arg1: pthread_t,
-    arg2: libc::c_int,
-    arg3: *mut sched_param,
+    thread: pthread_t,
+    policy: libc::c_int,
+    param: *mut sched_param,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn pthread_setspecific(
-    arg1: pthread_key_t,
-    arg2: *const libc::c_void,
+    key: pthread_key_t,
+    value: *const libc::c_void,
 ) -> libc::c_int {
     unimplemented!();
 }

semaphore/lib.rs

@@ -1,64 +1,64 @@
 #[repr(C)]
 #[derive(Copy)]
 pub union sem_t {
-    pub __size: [libc::c_char; 32usize],
-    pub __align: libc::c_long,
+    pub size: [libc::c_char; 32usize],
+    pub align: libc::c_long,
     _bindgen_union_align: [u64; 4usize],
 }
 impl Clone for sem_t {
     fn clone(&self) -> Self { *self }
 }
 #[no_mangle]
-pub extern "C" fn sem_init(__sem: *mut sem_t, __pshared: libc::c_int,
-                    __value: libc::c_uint) -> libc::c_int {
+pub extern "C" fn sem_init(sem: *mut sem_t, pshared: libc::c_int,
+                    value: libc::c_uint) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn sem_destroy(__sem: *mut sem_t) -> libc::c_int {
+pub extern "C" fn sem_destroy(sem: *mut sem_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn sem_open(__name: *const libc::c_char,
-                    __oflag: libc::c_int, ...) -> *mut sem_t {
+pub extern "C" fn sem_open(name: *const libc::c_char,
+                    oflag: libc::c_int, ...) -> *mut sem_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn sem_close(__sem: *mut sem_t) -> libc::c_int {
+pub extern "C" fn sem_close(sem: *mut sem_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn sem_unlink(__name: *const libc::c_char)
+pub extern "C" fn sem_unlink(name: *const libc::c_char)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn sem_wait(__sem: *mut sem_t) -> libc::c_int {
+pub extern "C" fn sem_wait(sem: *mut sem_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn sem_timedwait(__sem: *mut sem_t, __abstime: *const timespec)
+pub extern "C" fn sem_timedwait(sem: *mut sem_t, abstime: *const timespec)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn sem_trywait(__sem: *mut sem_t) -> libc::c_int {
+pub extern "C" fn sem_trywait(sem: *mut sem_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn sem_post(__sem: *mut sem_t) -> libc::c_int {
+pub extern "C" fn sem_post(sem: *mut sem_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn sem_getvalue(__sem: *mut sem_t, __sval: *mut libc::c_int)
+pub extern "C" fn sem_getvalue(sem: *mut sem_t, sval: *mut libc::c_int)
      -> libc::c_int {
     unimplemented!();
 }

stdio/lib.rs

@@ -1,163 +1,163 @@
 #[no_mangle]
-pub extern "C" fn clearerr(arg1: *mut FILE) {
+pub extern "C" fn clearerr(stream: *mut FILE) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn ctermid(arg1: *mut libc::c_char)
+pub extern "C" fn ctermid(s: *mut libc::c_char)
      -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn cuserid(arg1: *mut libc::c_char)
+pub extern "C" fn cuserid(s: *mut libc::c_char)
      -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fclose(arg1: *mut FILE) -> libc::c_int {
+pub extern "C" fn fclose(stream: *mut FILE) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fdopen(arg1: libc::c_int,
-                  arg2: *const libc::c_char) -> *mut FILE {
+pub extern "C" fn fdopen(fildes: libc::c_int,
+                  mode: *const libc::c_char) -> *mut FILE {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn feof(arg1: *mut FILE) -> libc::c_int {
+pub extern "C" fn feof(stream: *mut FILE) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn ferror(arg1: *mut FILE) -> libc::c_int {
+pub extern "C" fn ferror(stream: *mut FILE) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fflush(arg1: *mut FILE) -> libc::c_int {
+pub extern "C" fn fflush(stream: *mut FILE) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fgetc(arg1: *mut FILE) -> libc::c_int {
+pub extern "C" fn fgetc(stream: *mut FILE) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fgetpos(arg1: *mut FILE, arg2: *mut fpos_t)
+pub extern "C" fn fgetpos(stream: *mut FILE, pos: *mut fpos_t)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fgets(arg1: *mut libc::c_char,
-                 arg2: libc::c_int, arg3: *mut FILE)
+pub extern "C" fn fgets(s: *mut libc::c_char,
+                 n: libc::c_int, stream: *mut FILE)
      -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fileno(arg1: *mut FILE) -> libc::c_int {
+pub extern "C" fn fileno(stream: *mut FILE) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn flockfile(arg1: *mut FILE) {
+pub extern "C" fn flockfile(file: *mut FILE) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fopen(arg1: *const libc::c_char,
-                 arg2: *const libc::c_char) -> *mut FILE {
+pub extern "C" fn fopen(filename: *const libc::c_char,
+                 mode: *const libc::c_char) -> *mut FILE {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fprintf(arg1: *mut FILE, arg2: *const libc::c_char, ...)
+pub extern "C" fn fprintf(stream: *mut FILE, format: *const libc::c_char, ...)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fputc(arg1: libc::c_int, arg2: *mut FILE)
+pub extern "C" fn fputc(c: libc::c_int, stream: *mut FILE)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fputs(arg1: *const libc::c_char, arg2: *mut FILE)
+pub extern "C" fn fputs(s: *const libc::c_char, stream: *mut FILE)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fread(arg1: *mut libc::c_void, arg2: usize, arg3: usize,
-                 arg4: *mut FILE) -> usize {
+pub extern "C" fn fread(ptr: *mut libc::c_void, size: usize, nitems: usize,
+                 stream: *mut FILE) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn freopen(arg1: *const libc::c_char,
-                   arg2: *const libc::c_char, arg3: *mut FILE)
+pub extern "C" fn freopen(filename: *const libc::c_char,
+                   mode: *const libc::c_char, stream: *mut FILE)
      -> *mut FILE {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fscanf(arg1: *mut FILE, arg2: *const libc::c_char, ...)
+pub extern "C" fn fscanf(stream: *mut FILE, format: *const libc::c_char, ...)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fseek(arg1: *mut FILE, arg2: libc::c_long,
-                 arg3: libc::c_int) -> libc::c_int {
+pub extern "C" fn fseek(stream: *mut FILE, offset: libc::c_long,
+                 whence: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fseeko(arg1: *mut FILE, arg2: off_t, arg3: libc::c_int)
+pub extern "C" fn fseeko(stream: *mut FILE, offset: off_t, whence: libc::c_int)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fsetpos(arg1: *mut FILE, arg2: *const fpos_t)
+pub extern "C" fn fsetpos(stream: *mut FILE, pos: *const fpos_t)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn ftell(arg1: *mut FILE) -> libc::c_long {
+pub extern "C" fn ftell(stream: *mut FILE) -> libc::c_long {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn ftello(arg1: *mut FILE) -> off_t {
+pub extern "C" fn ftello(stream: *mut FILE) -> off_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn ftrylockfile(arg1: *mut FILE) -> libc::c_int {
+pub extern "C" fn ftrylockfile(file: *mut FILE) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn funlockfile(arg1: *mut FILE) {
+pub extern "C" fn funlockfile(file: *mut FILE) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fwrite(arg1: *const libc::c_void, arg2: usize,
-                  arg3: usize, arg4: *mut FILE) -> usize {
+pub extern "C" fn fwrite(ptr: *const libc::c_void, size: usize,
+                  nitems: usize, stream: *mut FILE) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn getc(arg1: *mut FILE) -> libc::c_int {
+pub extern "C" fn getc(stream: *mut FILE) -> libc::c_int {
     unimplemented!();
 }
 
@@ -167,7 +167,7 @@ pub extern "C" fn getchar() -> libc::c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn getc_unlocked(arg1: *mut FILE) -> libc::c_int {
+pub extern "C" fn getc_unlocked(stream: *mut FILE) -> libc::c_int {
     unimplemented!();
 }
 
@@ -177,111 +177,111 @@ pub extern "C" fn getchar_unlocked() -> libc::c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn getopt(arg1: libc::c_int,
-                  arg2: *const *const libc::c_char,
-                  arg3: libc::c_char) -> libc::c_int {
+pub extern "C" fn getopt(argc: libc::c_int,
+                  argv: *const *const libc::c_char,
+                  optstring: libc::c_char) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn gets(arg1: *mut libc::c_char)
+pub extern "C" fn gets(s: *mut libc::c_char)
      -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn getw(arg1: *mut FILE) -> libc::c_int {
+pub extern "C" fn getw(stream: *mut FILE) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn pclose(arg1: *mut FILE) -> libc::c_int {
+pub extern "C" fn pclose(stream: *mut FILE) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn perror(arg1: *const libc::c_char) {
+pub extern "C" fn perror(s: *const libc::c_char) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn popen(arg1: *const libc::c_char,
-                 arg2: *const libc::c_char) -> *mut FILE {
+pub extern "C" fn popen(command: *const libc::c_char,
+                 mode: *const libc::c_char) -> *mut FILE {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn printf(arg1: *const libc::c_char, ...)
+pub extern "C" fn printf(format: *const libc::c_char, ...)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn putc(arg1: libc::c_int, arg2: *mut FILE)
+pub extern "C" fn putc(c: libc::c_int, stream: *mut FILE)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn putchar(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn putchar(c: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn putc_unlocked(arg1: libc::c_int, arg2: *mut FILE)
+pub extern "C" fn putc_unlocked(c: libc::c_int, stream: *mut FILE)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn putchar_unlocked(arg1: libc::c_int)
+pub extern "C" fn putchar_unlocked(c: libc::c_int)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn puts(arg1: *const libc::c_char) -> libc::c_int {
+pub extern "C" fn puts(s: *const libc::c_char) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn putw(arg1: libc::c_int, arg2: *mut FILE)
+pub extern "C" fn putw(w: libc::c_int, stream: *mut FILE)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn remove(arg1: *const libc::c_char)
+pub extern "C" fn remove(path: *const libc::c_char)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn rename(arg1: *const libc::c_char,
-                  arg2: *const libc::c_char)
+pub extern "C" fn rename(old: *const libc::c_char,
+                  new: *const libc::c_char)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn rewind(arg1: *mut FILE) {
+pub extern "C" fn rewind(stream: *mut FILE) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn scanf(arg1: *const libc::c_char, ...)
+pub extern "C" fn scanf(format: *const libc::c_char, ...)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn setbuf(arg1: *mut FILE, arg2: *mut libc::c_char) {
+pub extern "C" fn setbuf(stream: *mut FILE, buf: *mut libc::c_char) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn setvbuf(arg1: *mut FILE, arg2: *mut libc::c_char,
-                   arg3: libc::c_int, arg4: usize)
+pub extern "C" fn setvbuf(stream: *mut FILE, buf: *mut libc::c_char,
+                   _IOBUF: libc::c_int, BUFSIZ: usize)
      -> libc::c_int {
     unimplemented!();
 }
@@ -294,22 +294,22 @@ pub extern "C" fn snprintf(arg1: *mut libc::c_char, arg2: usize,
 }
 
 #[no_mangle]
-pub extern "C" fn sprintf(arg1: *mut libc::c_char,
-                   arg2: *const libc::c_char, ...)
+pub extern "C" fn sprintf(s: *mut libc::c_char,
+                   format: *const libc::c_char, ...)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn sscanf(arg1: *const libc::c_char,
-                  arg2: *const libc::c_char, ...)
+pub extern "C" fn sscanf(s: *const libc::c_char,
+                  format: *const libc::c_char, ...)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn tempnam(arg1: *const libc::c_char,
-                   arg2: *const libc::c_char)
+pub extern "C" fn tempnam(dir: *const libc::c_char,
+                   pfx: *const libc::c_char)
      -> *mut libc::c_char {
     unimplemented!();
 }
@@ -320,40 +320,40 @@ pub extern "C" fn tmpfile() -> *mut FILE {
 }
 
 #[no_mangle]
-pub extern "C" fn tmpnam(arg1: *mut libc::c_char)
+pub extern "C" fn tmpnam(s: *mut libc::c_char)
      -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn ungetc(arg1: libc::c_int, arg2: *mut FILE)
+pub extern "C" fn ungetc(c: libc::c_int, stream: *mut FILE)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn vfprintf(arg1: *mut FILE, arg2: *const libc::c_char,
-                    va_list: libc::c_int) -> libc::c_int {
+pub extern "C" fn vfprintf(stream: *mut FILE, format: *const libc::c_char,
+                    ap: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn vprintf(arg1: *const libc::c_char,
-                   va_list: libc::c_int) -> libc::c_int {
+pub extern "C" fn vprintf(format: *const libc::c_char,
+                   ap: va_list) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn vsnprintf(arg1: *mut libc::c_char, arg2: usize,
-                     arg3: *const libc::c_char,
-                     va_list: libc::c_int) -> libc::c_int {
+pub extern "C" fn vsnprintf(s: *mut libc::c_char, n: usize,
+                     format: *const libc::c_char,
+                     ap: va_list) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn vsprintf(arg1: *mut libc::c_char,
-                    arg2: *const libc::c_char,
-                    va_list: libc::c_int) -> libc::c_int {
+pub extern "C" fn vsprintf(s: *mut libc::c_char,
+                    format: *const libc::c_char,
+                    ap: va_list) -> libc::c_int {
     unimplemented!();
 }
 

stdlib/lib.rs

@@ -26,42 +26,44 @@ impl Clone for ldiv_t {
     }
 }
 #[no_mangle]
+pub extern "C" fn a64l(s: *const char)
+#[no_mangle]
 pub extern "C" fn abort() {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn abs(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn abs(i: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn atexit(arg1: ::std::option::Option<unsafe extern "C" fn()>) -> libc::c_int {
+pub extern "C" fn atexit(func: ::std::option::Option<unsafe extern "C" fn()>) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn atof(arg1: *const libc::c_char) -> f64 {
+pub extern "C" fn atof(str_: *const libc::c_char) -> f64 {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn atoi(arg1: *const libc::c_char) -> libc::c_int {
+pub extern "C" fn atoi(str_: *const libc::c_char) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn atol(arg1: *const libc::c_char) -> libc::c_long {
+pub extern "C" fn atol(str_: *const libc::c_char) -> libc::c_long {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn bsearch(
-    arg1: *const libc::c_void,
-    arg2: *const libc::c_void,
-    arg3: usize,
-    arg4: usize,
-    arg5: ::std::option::Option<
+    key: *const libc::c_void,
+    base: *const libc::c_void,
+    nel: usize,
+    width: usize,
+    compar: ::std::option::Option<
         unsafe extern "C" fn(arg1: *const libc::c_void,
                              arg2: *const libc::c_void)
                              -> libc::c_int,
@@ -71,12 +73,12 @@ pub extern "C" fn bsearch(
 }
 
 #[no_mangle]
-pub extern "C" fn calloc(arg1: usize, arg2: usize) -> *mut libc::c_void {
+pub extern "C" fn calloc(nelem: usize, elsize: usize) -> *mut libc::c_void {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn div(arg1: libc::c_int, arg2: libc::c_int) -> div_t {
+pub extern "C" fn div(numer: libc::c_int, denom: libc::c_int) -> div_t {
     unimplemented!();
 }
 
@@ -87,94 +89,94 @@ pub extern "C" fn drand48() -> f64 {
 
 #[no_mangle]
 pub extern "C" fn ecvt(
-    arg1: f64,
-    arg2: libc::c_int,
-    arg3: *mut libc::c_int,
-    arg4: *mut libc::c_int,
+    value: f64,
+    ndigit: libc::c_int,
+    decept: *mut libc::c_int,
+    sign: *mut libc::c_int,
 ) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn erand48(arg1: *mut libc::c_ushort) -> f64 {
+pub extern "C" fn erand48(xsubi: *mut libc::c_ushort) -> f64 {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn exit(arg1: libc::c_int) {
+pub extern "C" fn exit(status: libc::c_int) {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn fcvt(
-    arg1: f64,
-    arg2: libc::c_int,
-    arg3: *mut libc::c_int,
-    arg4: *mut libc::c_int,
+    value: f64,
+    ndigit: libc::c_int,
+    decept: *mut libc::c_int,
+    sign: *mut libc::c_int,
 ) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn free(arg1: *mut libc::c_void) {
+pub extern "C" fn free(ptr: *mut libc::c_void) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn gcvt(arg1: f64, arg2: libc::c_int, arg3: *mut libc::c_char) -> *mut libc::c_char {
+pub extern "C" fn gcvt(value: f64, ndigit: libc::c_int, buf: *mut libc::c_char) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn getenv(arg1: *const libc::c_char) -> *mut libc::c_char {
+pub extern "C" fn getenv(name: *const libc::c_char) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn getsubopt(
-    arg1: *mut *mut libc::c_char,
-    arg2: *const *const libc::c_char,
-    arg3: *mut *mut libc::c_char,
+    optionp: *mut *mut libc::c_char,
+    tokens: *const *const libc::c_char,
+    valuep: *mut *mut libc::c_char,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn grantpt(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn grantpt(fildes: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn initstate(
-    arg1: libc::c_uint,
-    arg2: *mut libc::c_char,
-    arg3: usize,
+    seed: libc::c_uint,
+    state: *mut libc::c_char,
+    size: usize,
 ) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn jrand48(arg1: *mut libc::c_ushort) -> libc::c_long {
+pub extern "C" fn jrand48(xsubi: *mut libc::c_ushort) -> libc::c_long {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn l64a(arg1: libc::c_long) -> *mut libc::c_char {
+pub extern "C" fn l64a(value: libc::c_long) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn labs(arg1: libc::c_long) -> libc::c_long {
+pub extern "C" fn labs(i: libc::c_long) -> libc::c_long {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn lcong48(arg1: *mut libc::c_ushort) {
+pub extern "C" fn lcong48(param: *mut libc::c_ushort) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn ldiv(arg1: libc::c_long, arg2: libc::c_long) -> ldiv_t {
+pub extern "C" fn ldiv(numer: libc::c_long, denom: libc::c_long) -> ldiv_t {
     unimplemented!();
 }
 
@@ -184,36 +186,36 @@ pub extern "C" fn lrand48() -> libc::c_long {
 }
 
 #[no_mangle]
-pub extern "C" fn malloc(arg1: usize) -> *mut libc::c_void {
+pub extern "C" fn malloc(size: usize) -> *mut libc::c_void {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn mblen(arg1: *const libc::c_char, arg2: usize) -> libc::c_int {
+pub extern "C" fn mblen(s: *const libc::c_char, n: usize) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn mbstowcs(arg1: *mut wchar_t, arg2: *const libc::c_char, arg3: usize) -> usize {
+pub extern "C" fn mbstowcs(pwcs: *mut wchar_t, s: *const libc::c_char, n: usize) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn mbtowc(
-    arg1: *mut wchar_t,
-    arg2: *const libc::c_char,
-    arg3: usize,
+    pwc: *mut wchar_t,
+    s: *const libc::c_char,
+    n: usize,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn mktemp(arg1: *mut libc::c_char) -> *mut libc::c_char {
+pub extern "C" fn mktemp(template: *mut libc::c_char) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn mkstemp(arg1: *mut libc::c_char) -> libc::c_int {
+pub extern "C" fn mkstemp(template: *mut libc::c_char) -> libc::c_int {
     unimplemented!();
 }
 
@@ -223,26 +225,26 @@ pub extern "C" fn mrand48() -> libc::c_long {
 }
 
 #[no_mangle]
-pub extern "C" fn nrand48(arg1: *mut libc::c_ushort) -> libc::c_long {
+pub extern "C" fn nrand48(xsubi: *mut libc::c_ushort) -> libc::c_long {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn ptsname(arg1: libc::c_int) -> *mut libc::c_char {
+pub extern "C" fn ptsname(fildes: libc::c_int) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn putenv(arg1: *mut libc::c_char) -> libc::c_int {
+pub extern "C" fn putenv(string: *mut libc::c_char) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn qsort(
-    arg1: *mut libc::c_void,
-    arg2: usize,
-    arg3: usize,
-    arg4: ::std::option::Option<
+    base: *mut libc::c_void,
+    nel: usize,
+    width: usize,
+    compar: ::std::option::Option<
         unsafe extern "C" fn(arg1: *const libc::c_void,
                              arg2: *const libc::c_void)
                              -> libc::c_int,
@@ -257,7 +259,7 @@ pub extern "C" fn rand() -> libc::c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn rand_r(arg1: *mut libc::c_uint) -> libc::c_int {
+pub extern "C" fn rand_r(seed: *mut libc::c_uint) -> libc::c_int {
     unimplemented!();
 }
 
@@ -267,73 +269,73 @@ pub extern "C" fn random() -> libc::c_long {
 }
 
 #[no_mangle]
-pub extern "C" fn realloc(arg1: *mut libc::c_void, arg2: usize) -> *mut libc::c_void {
+pub extern "C" fn realloc(ptr: *mut libc::c_void, size: usize) -> *mut libc::c_void {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn realpath(
-    arg1: *const libc::c_char,
-    arg2: *mut libc::c_char,
+    file_name: *const libc::c_char,
+    resolved_name: *mut libc::c_char,
 ) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn seed48(arg1: *mut libc::c_ushort) -> libc::c_ushort {
+pub extern "C" fn seed48(seed16v: *mut libc::c_ushort) -> libc::c_ushort {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn setkey(arg1: *const libc::c_char) {
+pub extern "C" fn setkey(key: *const libc::c_char) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn setstate(arg1: *const libc::c_char) -> *mut libc::c_char {
+pub extern "C" fn setstate(state: *const libc::c_char) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn srand(arg1: libc::c_uint) {
+pub extern "C" fn srand(seed: libc::c_uint) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn srand48(arg1: libc::c_long) {
+pub extern "C" fn srand48(seedval: libc::c_long) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn srandom(arg1: libc::c_uint) {
+pub extern "C" fn srandom(seed: libc::c_uint) {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strtod(arg1: *const libc::c_char, arg2: *mut *mut libc::c_char) -> f64 {
+pub extern "C" fn strtod(str_: *const libc::c_char, endptr: *mut *mut libc::c_char) -> f64 {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn strtol(
-    arg1: *const libc::c_char,
-    arg2: *mut *mut libc::c_char,
-    arg3: libc::c_int,
+    str_: *const libc::c_char,
+    endptr: *mut *mut libc::c_char,
+    base: libc::c_int,
 ) -> libc::c_long {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn strtoul(
-    arg1: *const libc::c_char,
-    arg2: *mut *mut libc::c_char,
-    arg3: libc::c_int,
+    str_: *const libc::c_char,
+    endptr: *mut *mut libc::c_char,
+    base: libc::c_int,
 ) -> libc::c_ulong {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn system(arg1: *const libc::c_char) -> libc::c_int {
+pub extern "C" fn system(command: *const libc::c_char) -> libc::c_int {
     unimplemented!();
 }
 
@@ -343,21 +345,21 @@ pub extern "C" fn ttyslot() -> libc::c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn unlockpt(arg1: libc::c_int) -> libc::c_int {
+pub extern "C" fn unlockpt(fildes: libc::c_int) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn valloc(arg1: usize) -> *mut libc::c_void {
+pub extern "C" fn valloc(size: usize) -> *mut libc::c_void {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcstombs(arg1: *mut libc::c_char, arg2: *const wchar_t, arg3: usize) -> usize {
+pub extern "C" fn wcstombs(s: *mut libc::c_char, pwcs: *const wchar_t, n: usize) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wctomb(arg1: *mut libc::c_char, arg2: wchar_t) -> libc::c_int {
+pub extern "C" fn wctomb(s: *mut libc::c_char, wchar: wchar_t) -> libc::c_int {
     unimplemented!();
 }

string/lib.rs

@@ -2,176 +2,176 @@
 
 #[no_mangle]
 pub extern "C" fn memccpy(
-    arg1: *mut libc::c_void,
-    arg2: *const libc::c_void,
-    arg3: libc::c_int,
-    arg4: usize,
+    s1: *mut libc::c_void,
+    s2: *const libc::c_void,
+    c: libc::c_int,
+    n: usize,
 ) -> *mut libc::c_void {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn memchr(
-    arg1: *const libc::c_void,
-    arg2: libc::c_int,
-    arg3: usize,
+    s: *const libc::c_void,
+    c: libc::c_int,
+    n: usize,
 ) -> *mut libc::c_void {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn memcmp(
-    arg1: *const libc::c_void,
-    arg2: *const libc::c_void,
-    arg3: usize,
+    s1: *const libc::c_void,
+    s2: *const libc::c_void,
+    n: usize,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn memcpy(
-    arg1: *mut libc::c_void,
-    arg2: *const libc::c_void,
-    arg3: usize,
+    s1: *mut libc::c_void,
+    s2: *const libc::c_void,
+    n: usize,
 ) -> *mut libc::c_void {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn memmove(
-    arg1: *mut libc::c_void,
-    arg2: *const libc::c_void,
-    arg3: usize,
+    s1: *mut libc::c_void,
+    s2: *const libc::c_void,
+    n: usize,
 ) -> *mut libc::c_void {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn memset(
-    arg1: *mut libc::c_void,
-    arg2: libc::c_int,
-    arg3: usize,
+    s: *mut libc::c_void,
+    c: libc::c_int,
+    n: usize,
 ) -> *mut libc::c_void {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strcat(arg1: *mut libc::c_char, arg2: *const libc::c_char) -> *mut libc::c_char {
+pub extern "C" fn strcat(s1: *mut libc::c_char, s2: *const libc::c_char) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strchr(arg1: *const libc::c_char, arg2: libc::c_int) -> *mut libc::c_char {
+pub extern "C" fn strchr(s: *const libc::c_char, c: libc::c_int) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strcmp(arg1: *const libc::c_char, arg2: *const libc::c_char) -> libc::c_int {
+pub extern "C" fn strcmp(s1: *const libc::c_char, s2: *const libc::c_char) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strcoll(arg1: *const libc::c_char, arg2: *const libc::c_char) -> libc::c_int {
+pub extern "C" fn strcoll(s1: *const libc::c_char, s2: *const libc::c_char) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strcpy(arg1: *mut libc::c_char, arg2: *const libc::c_char) -> *mut libc::c_char {
+pub extern "C" fn strcpy(s1: *mut libc::c_char, s2: *const libc::c_char) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strcspn(arg1: *const libc::c_char, arg2: *const libc::c_char) -> libc::c_ulong {
+pub extern "C" fn strcspn(s1: *const libc::c_char, s2: *const libc::c_char) -> libc::c_ulong {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strdup(arg1: *const libc::c_char) -> *mut libc::c_char {
+pub extern "C" fn strdup(s1: *const libc::c_char) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strerror(arg1: libc::c_int) -> *mut libc::c_char {
+pub extern "C" fn strerror(errnum: libc::c_int) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strlen(arg1: *const libc::c_char) -> libc::c_ulong {
+pub extern "C" fn strlen(s: *const libc::c_char) -> libc::c_ulong {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn strncat(
-    arg1: *mut libc::c_char,
-    arg2: *const libc::c_char,
-    arg3: usize,
+    s1: *mut libc::c_char,
+    s2: *const libc::c_char,
+    n: usize,
 ) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn strncmp(
-    arg1: *const libc::c_char,
-    arg2: *const libc::c_char,
-    arg3: usize,
+    s1: *const libc::c_char,
+    s2: *const libc::c_char,
+    n: usize,
 ) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn strncpy(
-    arg1: *mut libc::c_char,
-    arg2: *const libc::c_char,
-    arg3: usize,
+    s1: *mut libc::c_char,
+    s2: *const libc::c_char,
+    n: usize,
 ) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn strpbrk(
-    arg1: *const libc::c_char,
-    arg2: *const libc::c_char,
+    s1: *const libc::c_char,
+    s2: *const libc::c_char,
 ) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strrchr(arg1: *const libc::c_char, arg2: libc::c_int) -> *mut libc::c_char {
+pub extern "C" fn strrchr(s: *const libc::c_char, c: libc::c_int) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strspn(arg1: *const libc::c_char, arg2: *const libc::c_char) -> libc::c_ulong {
+pub extern "C" fn strspn(s1: *const libc::c_char, s2: *const libc::c_char) -> libc::c_ulong {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn strstr(
-    arg1: *const libc::c_char,
-    arg2: *const libc::c_char,
+    s1: *const libc::c_char,
+    s2: *const libc::c_char,
 ) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn strtok(arg1: *mut libc::c_char, arg2: *const libc::c_char) -> *mut libc::c_char {
+pub extern "C" fn strtok(s1: *mut libc::c_char, s2: *const libc::c_char) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn strtok_r(
-    arg1: *mut libc::c_char,
-    arg2: *const libc::c_char,
-    arg3: *mut *mut libc::c_char,
+    s: *mut libc::c_char,
+    sep: *const libc::c_char,
+    lasts: *mut *mut libc::c_char,
 ) -> *mut libc::c_char {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn strxfrm(
-    arg1: *mut libc::c_char,
-    arg2: *const libc::c_char,
-    arg3: usize,
+    s1: *mut libc::c_char,
+    s2: *const libc::c_char,
+    n: usize,
 ) -> libc::c_ulong {
     unimplemented!();
 }

wchar/lib.rs

@@ -1,51 +1,108 @@
-/* automatically generated by rust-bindgen */
+pub type wchar_t = libc::c_int;
+pub type wint_t = libc::c_uint;
+
 #[no_mangle]
-pub extern "C" fn btowc(arg1: libc::c_int) -> wint_t {
+pub extern "C" fn btowc(c: libc::c_int) -> wint_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fwprintf(arg1: *mut FILE, arg2: *const wchar_t, ...)
+pub extern "C" fn fwprintf(stream: *mut FILE, format: *const wchar_t, ...)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fwscanf(arg1: *mut FILE, arg2: *const wchar_t, ...)
+pub extern "C" fn fwscanf(stream: *mut FILE, format: *const wchar_t, ...)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fgetwc(arg1: *mut FILE) -> wint_t {
+pub extern "C" fn iswalnum(wc: wint_t) -> libc::c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn iswalpha(wc: wint_t) -> libc::c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn iswcntrl(wc: wint_t) -> libc::c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn iswdigit(wc: wint_t) -> libc::c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn iswgraph(wc: wint_t) -> libc::c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn iswlower(wc: wint_t) -> libc::c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn iswprint(wc: wint_t) -> libc::c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn iswpunct(wc: wint_t) -> libc::c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn iswspace(wc: wint_t) -> libc::c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn iswupper(wc: wint_t) -> libc::c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn iswxdigit(wc: wint_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fgetws(arg1: *mut wchar_t, arg2: libc::c_int,
-                  arg3: *mut FILE) -> *mut wchar_t {
+pub extern "C" fn fgetwc(stream: *mut FILE) -> wint_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fputwc(arg1: wchar_t, arg2: *mut FILE) -> wint_t {
+pub extern "C" fn fgetws(ws: *mut wchar_t, n: libc::c_int,
+                  stream: *mut FILE) -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fputws(arg1: *const wchar_t, arg2: *mut FILE)
+pub extern "C" fn fputwc(wc: wchar_t, stream: *mut FILE) -> wint_t {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn fputws(ws: *const wchar_t, stream: *mut FILE)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn fwide(arg1: *mut FILE, arg2: libc::c_int)
+pub extern "C" fn fwide(stream: *mut FILE, mode: libc::c_int)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn getwc(arg1: *mut FILE) -> wint_t {
+pub extern "C" fn getwc(stream: *mut FILE) -> wint_t {
     unimplemented!();
 }
 
@@ -55,257 +112,266 @@ pub extern "C" fn getwchar() -> wint_t {
 }
 
 #[no_mangle]
-pub extern "C" fn mbsinit(arg1: *const mbstate_t) -> libc::c_int {
+pub extern "C" fn mbsinit(ps: *const mbstate_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn mbrlen(arg1: *const libc::c_char, arg2: usize,
-                  arg3: *mut mbstate_t) -> usize {
+pub extern "C" fn mbrlen(s: *const libc::c_char, n: usize,
+                  ps: *mut mbstate_t) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn mbrtowc(arg1: *mut wchar_t, arg2: *const libc::c_char,
-                   arg3: usize, arg4: *mut mbstate_t) -> usize {
+pub extern "C" fn mbrtowc(pwc: *mut wchar_t, s: *const libc::c_char,
+                   n: usize, ps: *mut mbstate_t) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn mbsrtowcs(arg1: *mut wchar_t,
-                     arg2: *mut *const libc::c_char, arg3: usize,
-                     arg4: *mut mbstate_t) -> usize {
+pub extern "C" fn mbsrtowcs(dst: *mut wchar_t,
+                     src: *mut *const libc::c_char, len: usize,
+                     ps: *mut mbstate_t) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn putwc(arg1: wchar_t, arg2: *mut FILE) -> wint_t {
+pub extern "C" fn putwc(wc: wchar_t, stream: *mut FILE) -> wint_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn putwchar(arg1: wchar_t) -> wint_t {
+pub extern "C" fn putwchar(wc: wchar_t) -> wint_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn swprintf(arg1: *mut wchar_t, arg2: usize,
-                    arg3: *const wchar_t, ...) -> libc::c_int {
+pub extern "C" fn swprintf(s: *mut wchar_t, n: usize,
+                    format: *const wchar_t, ...) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn swscanf(arg1: *const wchar_t, arg2: *const wchar_t, ...)
+pub extern "C" fn swscanf(s: *const wchar_t, format: *const wchar_t, ...)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn ungetwc(arg1: wint_t, arg2: *mut FILE) -> wint_t {
+pub extern "C" fn towlower(wc: wint_t) -> wint_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn vfwprintf(arg1: *mut FILE, arg2: *const wchar_t,
-                     arg3: *mut __va_list_tag) -> libc::c_int {
+pub extern "C" fn towupper(wc: wint_t) -> wint_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn vwprintf(arg1: *const wchar_t, arg2: *mut __va_list_tag)
+pub extern "C" fn ungetwc(wc: wint_t, stream: *mut FILE) -> wint_t {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn vfwprintf(stream: *mut FILE, format: *const wchar_t,
+                   arg: va_list) -> libc::c_int {
+    unimplemented!();
+}
+
+#[no_mangle]
+pub extern "C" fn vwprintf(format: *const wchar_t, arg: va_list)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn vswprintf(arg1: *mut wchar_t, arg2: usize, arg3: *const wchar_t,
-                     arg4: *mut __va_list_tag) -> libc::c_int {
+pub extern "C" fn vswprintf(s: *mut wchar_t, n: usize, format: *const wchar_t,
+                     arg: va_list) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcrtomb(arg1: *mut libc::c_char, arg2: wchar_t,
-                   arg3: *mut mbstate_t) -> usize {
+pub extern "C" fn wcrtomb(s: *mut libc::c_char, wc: wchar_t,
+                   ps: *mut mbstate_t) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcscat(arg1: *mut wchar_t, arg2: *const wchar_t) -> *mut wchar_t {
+pub extern "C" fn wcscat(ws1: *mut wchar_t, ws2: *const wchar_t) -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcschr(arg1: *const wchar_t, arg2: wchar_t)
+pub extern "C" fn wcschr(ws1: *const wchar_t, ws2: wchar_t)
      -> *mut libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcscmp(arg1: *const wchar_t, arg2: *const wchar_t)
+pub extern "C" fn wcscmp(ws1: *const wchar_t, ws2: *const wchar_t)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcscoll(arg1: *const wchar_t, arg2: *const wchar_t)
+pub extern "C" fn wcscoll(ws1: *const wchar_t, ws2: *const wchar_t)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcscpy(arg1: *mut wchar_t, arg2: *const wchar_t) -> *mut wchar_t {
+pub extern "C" fn wcscpy(ws1: *mut wchar_t, ws2: *const wchar_t) -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcscspn(arg1: *const wchar_t, arg2: *const wchar_t) -> usize {
+pub extern "C" fn wcscspn(ws1: *const wchar_t, ws2: *const wchar_t) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcsftime(arg1: *mut wchar_t, arg2: usize, arg3: *const wchar_t,
-                    arg4: *mut tm) -> usize {
+pub extern "C" fn wcsftime(wcs: *mut wchar_t, maxsize: usize, format: *const wchar_t,
+                    timptr: *mut tm) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcslen(arg1: *const wchar_t) -> libc::c_ulong {
+pub extern "C" fn wcslen(ws: *const wchar_t) -> libc::c_ulong {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcsncat(arg1: *mut wchar_t, arg2: *const wchar_t, arg3: usize)
+pub extern "C" fn wcsncat(ws1: *mut wchar_t, ws2: *const wchar_t, n: usize)
      -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcsncmp(arg1: *const wchar_t, arg2: *const wchar_t, arg3: usize)
+pub extern "C" fn wcsncmp(ws1: *const wchar_t, ws2: *const wchar_t, n: usize)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcsncpy(arg1: *mut wchar_t, arg2: *const wchar_t, arg3: usize)
+pub extern "C" fn wcsncpy(ws1: *mut wchar_t, ws2: *const wchar_t, n: usize)
      -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcspbrk(arg1: *const wchar_t, arg2: *const wchar_t)
+pub extern "C" fn wcspbrk(ws1: *const wchar_t, ws2: *const wchar_t)
      -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcsrchr(arg1: *const wchar_t, arg2: wchar_t) -> *mut wchar_t {
+pub extern "C" fn wcsrchr(ws1: *const wchar_t, ws2: wchar_t) -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcsrtombs(arg1: *mut libc::c_char,
-                     arg2: *mut *const wchar_t, arg3: usize,
-                     arg4: *mut mbstate_t) -> usize {
+pub extern "C" fn wcsrtombs(dst: *mut libc::c_char,
+                     src: *mut *const wchar_t, len: usize,
+                     ps: *mut mbstate_t) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcsspn(arg1: *const wchar_t, arg2: *const wchar_t) -> usize {
+pub extern "C" fn wcsspn(ws1: *const wchar_t, ws2: *const wchar_t) -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcsstr(arg1: *const wchar_t, arg2: *const wchar_t) -> *mut wchar_t {
+pub extern "C" fn wcsstr(ws1: *const wchar_t, ws2: *const wchar_t) -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcstod(arg1: *const wchar_t, arg2: *mut *mut wchar_t) -> f64 {
+pub extern "C" fn wcstod(nptr: *const wchar_t, endptr: *mut *mut wchar_t) -> f64 {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcstok(arg1: *mut wchar_t, arg2: *const wchar_t,
-                  arg3: *mut *mut wchar_t) -> *mut wchar_t {
+pub extern "C" fn wcstok(ws1: *mut wchar_t, ws2: *const wchar_t,
+                  ptr: *mut *mut wchar_t) -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcstol(arg1: *const wchar_t, arg2: *mut *mut wchar_t,
-                  arg3: libc::c_int) -> libc::c_long {
+pub extern "C" fn wcstol(nptr: *const wchar_t, endptr: *mut *mut wchar_t,
+                  base: libc::c_int) -> libc::c_long {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcstoul(arg1: *const wchar_t, arg2: *mut *mut wchar_t,
-                   arg3: libc::c_int) -> libc::c_ulong {
+pub extern "C" fn wcstoul(nptr: *const wchar_t, endptr: *mut *mut wchar_t,
+                   base: libc::c_int) -> libc::c_ulong {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcswcs(arg1: *const wchar_t, arg2: *const wchar_t) -> *mut wchar_t {
+pub extern "C" fn wcswcs(ws1: *const wchar_t, ws2: *const wchar_t) -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcswidth(arg1: *const wchar_t, arg2: usize)
+pub extern "C" fn wcswidth(pwcs: *const wchar_t, n: usize)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcsxfrm(arg1: *mut wchar_t, arg2: *const wchar_t, arg3: usize)
+pub extern "C" fn wcsxfrm(ws1: *mut wchar_t, ws2: *const wchar_t, n: usize)
      -> usize {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wctob(arg1: wint_t) -> libc::c_int {
+pub extern "C" fn wctob(c: wint_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wcwidth(arg1: wchar_t) -> libc::c_int {
+pub extern "C" fn wcwidth(wc: wchar_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wmemchr(arg1: *const wchar_t, arg2: wchar_t, arg3: usize)
+pub extern "C" fn wmemchr(ws: *const wchar_t, wc: wchar_t, n: usize)
      -> *mut libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wmemcmp(arg1: *const wchar_t, arg2: *const wchar_t, arg3: usize)
+pub extern "C" fn wmemcmp(ws1: *const wchar_t, ws2: *const wchar_t, n: usize)
      -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wmemcpy(arg1: *mut wchar_t, arg2: *const wchar_t, arg3: usize)
+pub extern "C" fn wmemcpy(ws1: *mut wchar_t, ws2: *const wchar_t, n: usize)
      -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wmemmove(arg1: *mut wchar_t, arg2: *const wchar_t, arg3: usize)
+pub extern "C" fn wmemmove(ws1: *mut wchar_t, ws2: *const wchar_t, n: usize)
      -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wmemset(arg1: *mut wchar_t, arg2: wchar_t, arg3: usize)
+pub extern "C" fn wmemset(ws1: *mut wchar_t, ws2: wchar_t, n: usize)
      -> *mut wchar_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wprintf(arg1: *const wchar_t, ...) -> libc::c_int {
+pub extern "C" fn wprintf(format: *const wchar_t, ...) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wscanf(arg1: *const wchar_t, ...) -> libc::c_int {
+pub extern "C" fn wscanf(format: *const wchar_t, ...) -> libc::c_int {
     unimplemented!();
 }
-

wctype/lib.rs

@@ -1,89 +1,89 @@
 #[no_mangle]
-pub extern "C" fn iswalnum(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswalnum(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswalpha(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswalpha(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswcntrl(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswcntrl(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswdigit(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswdigit(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswgraph(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswgraph(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswlower(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswlower(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswprint(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswprint(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswpunct(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswpunct(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswspace(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswspace(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswupper(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswupper(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswxdigit(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswxdigit(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswblank(__wc: wint_t, __locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswblank(wc: wint_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wctype(__property: *const libc::c_char, __locale: locale_t) -> wctype_t {
+pub extern "C" fn wctype(property: *const libc::c_char, locale: locale_t) -> wctype_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn iswctype(__wc: wint_t, __desc: wctype_t, _locale: locale_t) -> libc::c_int {
+pub extern "C" fn iswctype(wc: wint_t, desc: wctype_t, locale: locale_t) -> libc::c_int {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn towlower(__wc: wint_t, __locale: locale_t) -> wint_t {
+pub extern "C" fn towlower(wc: wint_t, locale: locale_t) -> wint_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn towupper(__wc: wint_t, __locale: locale_t) -> wint_t {
+pub extern "C" fn towupper(wc: wint_t, locale: locale_t) -> wint_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn wctrans(__property: *const libc::c_char, _locale: locale_t) -> wctrans_t {
+pub extern "C" fn wctrans(property: *const libc::c_char, locale: locale_t) -> wctrans_t {
     unimplemented!();
 }
 
 #[no_mangle]
-pub extern "C" fn towctrans(__wc: wint_t, __desc: wctrans_t, _locale: locale_t) -> wint_t {
+pub extern "C" fn towctrans(wc: wint_t, desc: wctrans_t, locale: locale_t) -> wint_t {
     unimplemented!();
 }