about summary refs log tree commit diff
path: root/src/libstd/libc.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/libc.rs')
-rw-r--r--src/libstd/libc.rs818
1 files changed, 446 insertions, 372 deletions
diff --git a/src/libstd/libc.rs b/src/libstd/libc.rs
index 32dd3264c03..bc360441f2f 100644
--- a/src/libstd/libc.rs
+++ b/src/libstd/libc.rs
@@ -2292,20 +2292,20 @@ pub mod funcs {
         pub mod ctype {
             use libc::types::os::arch::c95::{c_char, c_int};
 
-            pub extern {
-                unsafe fn isalnum(c: c_int) -> c_int;
-                unsafe fn isalpha(c: c_int) -> c_int;
-                unsafe fn iscntrl(c: c_int) -> c_int;
-                unsafe fn isdigit(c: c_int) -> c_int;
-                unsafe fn isgraph(c: c_int) -> c_int;
-                unsafe fn islower(c: c_int) -> c_int;
-                unsafe fn isprint(c: c_int) -> c_int;
-                unsafe fn ispunct(c: c_int) -> c_int;
-                unsafe fn isspace(c: c_int) -> c_int;
-                unsafe fn isupper(c: c_int) -> c_int;
-                unsafe fn isxdigit(c: c_int) -> c_int;
-                unsafe fn tolower(c: c_char) -> c_char;
-                unsafe fn toupper(c: c_char) -> c_char;
+            extern {
+                pub unsafe fn isalnum(c: c_int) -> c_int;
+                pub unsafe fn isalpha(c: c_int) -> c_int;
+                pub unsafe fn iscntrl(c: c_int) -> c_int;
+                pub unsafe fn isdigit(c: c_int) -> c_int;
+                pub unsafe fn isgraph(c: c_int) -> c_int;
+                pub unsafe fn islower(c: c_int) -> c_int;
+                pub unsafe fn isprint(c: c_int) -> c_int;
+                pub unsafe fn ispunct(c: c_int) -> c_int;
+                pub unsafe fn isspace(c: c_int) -> c_int;
+                pub unsafe fn isupper(c: c_int) -> c_int;
+                pub unsafe fn isxdigit(c: c_int) -> c_int;
+                pub unsafe fn tolower(c: c_char) -> c_char;
+                pub unsafe fn toupper(c: c_char) -> c_char;
             }
         }
 
@@ -2315,50 +2315,67 @@ pub mod funcs {
             use libc::types::common::c95::{FILE, c_void, fpos_t};
             use libc::types::os::arch::c95::{c_char, c_int, c_long, size_t};
 
-            pub extern {
-                unsafe fn fopen(filename: *c_char, mode: *c_char) -> *FILE;
-                unsafe fn freopen(filename: *c_char, mode: *c_char,
-                           file: *FILE) -> *FILE;
-                unsafe fn fflush(file: *FILE) -> c_int;
-                unsafe fn fclose(file: *FILE) -> c_int;
-                unsafe fn remove(filename: *c_char) -> c_int;
-                unsafe fn rename(oldname: *c_char, newname: *c_char) -> c_int;
-                unsafe fn tmpfile() -> *FILE;
-                unsafe fn setvbuf(stream: *FILE, buffer: *c_char,
-                           mode: c_int, size: size_t) -> c_int;
-                unsafe fn setbuf(stream: *FILE, buf: *c_char);
+            extern {
+                pub unsafe fn fopen(filename: *c_char, mode: *c_char)
+                                    -> *FILE;
+                pub unsafe fn freopen(filename: *c_char,
+                                      mode: *c_char,
+                                      file: *FILE)
+                                      -> *FILE;
+                pub unsafe fn fflush(file: *FILE) -> c_int;
+                pub unsafe fn fclose(file: *FILE) -> c_int;
+                pub unsafe fn remove(filename: *c_char) -> c_int;
+                pub unsafe fn rename(oldname: *c_char, newname: *c_char)
+                                     -> c_int;
+                pub unsafe fn tmpfile() -> *FILE;
+                pub unsafe fn setvbuf(stream: *FILE,
+                                      buffer: *c_char,
+                                      mode: c_int,
+                                      size: size_t)
+                                      -> c_int;
+                pub unsafe fn setbuf(stream: *FILE, buf: *c_char);
                 // Omitted: printf and scanf variants.
-                unsafe fn fgetc(stream: *FILE) -> c_int;
+                pub unsafe fn fgetc(stream: *FILE) -> c_int;
                 #[fast_ffi]
-                unsafe fn fgets(buf: *mut c_char, n: c_int,
-                         stream: *FILE) -> *c_char;
+                pub unsafe fn fgets(buf: *mut c_char,
+                                    n: c_int,
+                                    stream: *FILE)
+                                    -> *c_char;
                 #[fast_ffi]
-                unsafe fn fputc(c: c_int, stream: *FILE) -> c_int;
+                pub unsafe fn fputc(c: c_int, stream: *FILE) -> c_int;
                 #[fast_ffi]
-                unsafe fn fputs(s: *c_char, stream: *FILE) -> *c_char;
+                pub unsafe fn fputs(s: *c_char, stream: *FILE) -> *c_char;
                 // Omitted: getc, getchar (might be macros).
 
                 // Omitted: gets, so ridiculously unsafe that it should not
                 // survive.
 
                 // Omitted: putc, putchar (might be macros).
-                unsafe fn puts(s: *c_char) -> c_int;
-                unsafe fn ungetc(c: c_int, stream: *FILE) -> c_int;
+                pub unsafe fn puts(s: *c_char) -> c_int;
+                pub unsafe fn ungetc(c: c_int, stream: *FILE) -> c_int;
                 #[fast_ffi]
-                unsafe fn fread(ptr: *mut c_void, size: size_t,
-                         nobj: size_t, stream: *FILE) -> size_t;
+                pub unsafe fn fread(ptr: *mut c_void,
+                                    size: size_t,
+                                    nobj: size_t,
+                                    stream: *FILE)
+                                    -> size_t;
                 #[fast_ffi]
-                unsafe fn fwrite(ptr: *c_void, size: size_t,
-                          nobj: size_t, stream: *FILE) -> size_t;
-                unsafe fn fseek(stream: *FILE, offset: c_long,
-                         whence: c_int) -> c_int;
-                unsafe fn ftell(stream: *FILE) -> c_long;
-                unsafe fn rewind(stream: *FILE);
-                unsafe fn fgetpos(stream: *FILE, ptr: *fpos_t) -> c_int;
-                unsafe fn fsetpos(stream: *FILE, ptr: *fpos_t) -> c_int;
-                unsafe fn feof(stream: *FILE) -> c_int;
-                unsafe fn ferror(stream: *FILE) -> c_int;
-                unsafe fn perror(s: *c_char);
+                pub unsafe fn fwrite(ptr: *c_void,
+                                     size: size_t,
+                                     nobj: size_t,
+                                     stream: *FILE)
+                                     -> size_t;
+                pub unsafe fn fseek(stream: *FILE,
+                                    offset: c_long,
+                                    whence: c_int)
+                                    -> c_int;
+                pub unsafe fn ftell(stream: *FILE) -> c_long;
+                pub unsafe fn rewind(stream: *FILE);
+                pub unsafe fn fgetpos(stream: *FILE, ptr: *fpos_t) -> c_int;
+                pub unsafe fn fsetpos(stream: *FILE, ptr: *fpos_t) -> c_int;
+                pub unsafe fn feof(stream: *FILE) -> c_int;
+                pub unsafe fn ferror(stream: *FILE) -> c_int;
+                pub unsafe fn perror(s: *c_char);
             }
         }
 
@@ -2370,33 +2387,34 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_long, c_uint, c_ulong};
             use libc::types::os::arch::c95::{size_t};
 
-            pub extern {
-                unsafe fn abs(i: c_int) -> c_int;
-                unsafe fn labs(i: c_long) -> c_long;
+            extern {
+                pub unsafe fn abs(i: c_int) -> c_int;
+                pub unsafe fn labs(i: c_long) -> c_long;
                 // Omitted: div, ldiv (return pub type incomplete).
-                unsafe fn atof(s: *c_char) -> c_double;
-                unsafe fn atoi(s: *c_char) -> c_int;
-                unsafe fn strtod(s: *c_char, endp: **c_char) -> c_double;
-                unsafe fn strtol(s: *c_char, endp: **c_char, base: c_int)
-                              -> c_long;
-                unsafe fn strtoul(s: *c_char, endp: **c_char, base: c_int)
-                               -> c_ulong;
+                pub unsafe fn atof(s: *c_char) -> c_double;
+                pub unsafe fn atoi(s: *c_char) -> c_int;
+                pub unsafe fn strtod(s: *c_char, endp: **c_char) -> c_double;
+                pub unsafe fn strtol(s: *c_char, endp: **c_char, base: c_int)
+                                     -> c_long;
+                pub unsafe fn strtoul(s: *c_char, endp: **c_char, base: c_int)
+                                      -> c_ulong;
                 #[fast_ffi]
-                unsafe fn calloc(nobj: size_t, size: size_t) -> *c_void;
+                pub unsafe fn calloc(nobj: size_t, size: size_t) -> *c_void;
                 #[fast_ffi]
-                unsafe fn malloc(size: size_t) -> *c_void;
+                pub unsafe fn malloc(size: size_t) -> *c_void;
                 #[fast_ffi]
-                unsafe fn realloc(p: *mut c_void, size: size_t) -> *mut c_void;
+                pub unsafe fn realloc(p: *mut c_void, size: size_t)
+                                      -> *mut c_void;
                 #[fast_ffi]
-                unsafe fn free(p: *c_void);
-                unsafe fn abort() -> !;
-                unsafe fn exit(status: c_int) -> !;
+                pub unsafe fn free(p: *c_void);
+                pub unsafe fn abort() -> !;
+                pub unsafe fn exit(status: c_int) -> !;
                 // Omitted: atexit.
-                unsafe fn system(s: *c_char) -> c_int;
-                unsafe fn getenv(s: *c_char) -> *c_char;
+                pub unsafe fn system(s: *c_char) -> c_int;
+                pub unsafe fn getenv(s: *c_char) -> *c_char;
                 // Omitted: bsearch, qsort
-                unsafe fn rand() -> c_int;
-                unsafe fn srand(seed: c_uint);
+                pub unsafe fn rand() -> c_int;
+                pub unsafe fn srand(seed: c_uint);
             }
         }
 
@@ -2407,29 +2425,29 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_char, c_int, size_t};
             use libc::types::os::arch::c95::{wchar_t};
 
-            pub extern {
-                unsafe fn strcpy(dst: *c_char, src: *c_char) -> *c_char;
-                unsafe fn strncpy(dst: *c_char, src: *c_char, n: size_t)
-                               -> *c_char;
-                unsafe fn strcat(s: *c_char, ct: *c_char) -> *c_char;
-                unsafe fn strncat(s: *c_char, ct: *c_char, n: size_t)
-                               -> *c_char;
-                unsafe fn strcmp(cs: *c_char, ct: *c_char) -> c_int;
-                unsafe fn strncmp(cs: *c_char, ct: *c_char, n: size_t)
-                               -> c_int;
-                unsafe fn strcoll(cs: *c_char, ct: *c_char) -> c_int;
-                unsafe fn strchr(cs: *c_char, c: c_int) -> *c_char;
-                unsafe fn strrchr(cs: *c_char, c: c_int) -> *c_char;
-                unsafe fn strspn(cs: *c_char, ct: *c_char) -> size_t;
-                unsafe fn strcspn(cs: *c_char, ct: *c_char) -> size_t;
-                unsafe fn strpbrk(cs: *c_char, ct: *c_char) -> *c_char;
-                unsafe fn strstr(cs: *c_char, ct: *c_char) -> *c_char;
-                unsafe fn strlen(cs: *c_char) -> size_t;
-                unsafe fn strerror(n: c_int) -> *c_char;
-                unsafe fn strtok(s: *c_char, t: *c_char) -> *c_char;
-                unsafe fn strxfrm(s: *c_char, ct: *c_char, n: size_t)
-                               -> size_t;
-                unsafe fn wcslen(buf: *wchar_t) -> size_t;
+            extern {
+                pub unsafe fn strcpy(dst: *c_char, src: *c_char) -> *c_char;
+                pub unsafe fn strncpy(dst: *c_char, src: *c_char, n: size_t)
+                                      -> *c_char;
+                pub unsafe fn strcat(s: *c_char, ct: *c_char) -> *c_char;
+                pub unsafe fn strncat(s: *c_char, ct: *c_char, n: size_t)
+                                      -> *c_char;
+                pub unsafe fn strcmp(cs: *c_char, ct: *c_char) -> c_int;
+                pub unsafe fn strncmp(cs: *c_char, ct: *c_char, n: size_t)
+                                      -> c_int;
+                pub unsafe fn strcoll(cs: *c_char, ct: *c_char) -> c_int;
+                pub unsafe fn strchr(cs: *c_char, c: c_int) -> *c_char;
+                pub unsafe fn strrchr(cs: *c_char, c: c_int) -> *c_char;
+                pub unsafe fn strspn(cs: *c_char, ct: *c_char) -> size_t;
+                pub unsafe fn strcspn(cs: *c_char, ct: *c_char) -> size_t;
+                pub unsafe fn strpbrk(cs: *c_char, ct: *c_char) -> *c_char;
+                pub unsafe fn strstr(cs: *c_char, ct: *c_char) -> *c_char;
+                pub unsafe fn strlen(cs: *c_char) -> size_t;
+                pub unsafe fn strerror(n: c_int) -> *c_char;
+                pub unsafe fn strtok(s: *c_char, t: *c_char) -> *c_char;
+                pub unsafe fn strxfrm(s: *c_char, ct: *c_char, n: size_t)
+                                      -> size_t;
+                pub unsafe fn wcslen(buf: *wchar_t) -> size_t;
 
                 // Omitted: memcpy, memmove, memset (provided by LLVM)
 
@@ -2437,11 +2455,12 @@ pub mod funcs {
                 // in fact, because LLVM generates calls to them!
                 #[rust_stack]
                 #[inline]
-                unsafe fn memcmp(cx: *c_void, ct: *c_void, n: size_t)
-                              -> c_int;
+                pub unsafe fn memcmp(cx: *c_void, ct: *c_void, n: size_t)
+                                     -> c_int;
                 #[rust_stack]
                 #[inline]
-                unsafe fn memchr(cx: *c_void, c: c_int, n: size_t) -> *c_void;
+                pub unsafe fn memchr(cx: *c_void, c: c_int, n: size_t)
+                                     -> *c_void;
             }
         }
     }
@@ -2460,18 +2479,18 @@ pub mod funcs {
             use libc::types::os::common::posix01::stat;
             use libc::types::os::arch::c95::{c_int, c_char};
 
-            pub extern {
+            extern {
                 #[link_name = "_chmod"]
-                unsafe fn chmod(path: *c_char, mode: c_int) -> c_int;
+                pub unsafe fn chmod(path: *c_char, mode: c_int) -> c_int;
 
                 #[link_name = "_mkdir"]
-                unsafe fn mkdir(path: *c_char) -> c_int;
+                pub unsafe fn mkdir(path: *c_char) -> c_int;
 
                 #[link_name = "_fstat64"]
-                unsafe fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
+                pub unsafe fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
 
                 #[link_name = "_stat64"]
-                unsafe fn stat(path: *c_char, buf: *mut stat) -> c_int;
+                pub unsafe fn stat(path: *c_char, buf: *mut stat) -> c_int;
             }
         }
 
@@ -2481,19 +2500,19 @@ pub mod funcs {
             use libc::types::common::c95::FILE;
             use libc::types::os::arch::c95::{c_int, c_char};
 
-            pub extern {
+            extern {
                 #[link_name = "_popen"]
-                unsafe fn popen(command: *c_char, mode: *c_char) -> *FILE;
+                pub unsafe fn popen(command: *c_char, mode: *c_char) -> *FILE;
 
                 #[link_name = "_pclose"]
-                unsafe fn pclose(stream: *FILE) -> c_int;
+                pub unsafe fn pclose(stream: *FILE) -> c_int;
 
                 #[link_name = "_fdopen"]
                 #[fast_ffi]
-                unsafe fn fdopen(fd: c_int, mode: *c_char) -> *FILE;
+                pub unsafe fn fdopen(fd: c_int, mode: *c_char) -> *FILE;
 
                 #[link_name = "_fileno"]
-                unsafe fn fileno(stream: *FILE) -> c_int;
+                pub unsafe fn fileno(stream: *FILE) -> c_int;
             }
         }
 
@@ -2501,13 +2520,13 @@ pub mod funcs {
         #[abi = "cdecl"]
         pub mod fcntl {
             use libc::types::os::arch::c95::{c_int, c_char};
-            pub extern {
+            extern {
                 #[link_name = "_open"]
-                unsafe fn open(path: *c_char, oflag: c_int, mode: c_int)
-                            -> c_int;
+                pub unsafe fn open(path: *c_char, oflag: c_int, mode: c_int)
+                                   -> c_int;
 
                 #[link_name = "_creat"]
-                unsafe fn creat(path: *c_char, mode: c_int) -> c_int;
+                pub unsafe fn creat(path: *c_char, mode: c_int) -> c_int;
             }
         }
 
@@ -2525,68 +2544,75 @@ pub mod funcs {
                                              c_long, size_t};
             use libc::types::os::arch::c99::intptr_t;
 
-            pub extern {
+            extern {
                 #[link_name = "_access"]
-                unsafe fn access(path: *c_char, amode: c_int) -> c_int;
+                pub unsafe fn access(path: *c_char, amode: c_int) -> c_int;
 
                 #[link_name = "_chdir"]
-                unsafe fn chdir(dir: *c_char) -> c_int;
+                pub unsafe fn chdir(dir: *c_char) -> c_int;
 
                 #[link_name = "_close"]
-                unsafe fn close(fd: c_int) -> c_int;
+                pub unsafe fn close(fd: c_int) -> c_int;
 
                 #[link_name = "_dup"]
-                unsafe fn dup(fd: c_int) -> c_int;
+                pub unsafe fn dup(fd: c_int) -> c_int;
 
                 #[link_name = "_dup2"]
-                unsafe fn dup2(src: c_int, dst: c_int) -> c_int;
+                pub unsafe fn dup2(src: c_int, dst: c_int) -> c_int;
 
                 #[link_name = "_execv"]
-                unsafe fn execv(prog: *c_char, argv: **c_char) -> intptr_t;
+                pub unsafe fn execv(prog: *c_char, argv: **c_char)
+                                    -> intptr_t;
 
                 #[link_name = "_execve"]
-                unsafe fn execve(prog: *c_char, argv: **c_char,
-                          envp: **c_char) -> c_int;
+                pub unsafe fn execve(prog: *c_char,
+                                     argv: **c_char,
+                                     envp: **c_char)
+                                     -> c_int;
 
                 #[link_name = "_execvp"]
-                unsafe fn execvp(c: *c_char, argv: **c_char) -> c_int;
+                pub unsafe fn execvp(c: *c_char, argv: **c_char) -> c_int;
 
                 #[link_name = "_execvpe"]
-                unsafe fn execvpe(c: *c_char, argv: **c_char,
-                           envp: **c_char) -> c_int;
+                pub unsafe fn execvpe(c: *c_char,
+                                      argv: **c_char,
+                                      envp: **c_char)
+                                      -> c_int;
 
                 #[link_name = "_getcwd"]
-                unsafe fn getcwd(buf: *c_char, size: size_t) -> *c_char;
+                pub unsafe fn getcwd(buf: *c_char, size: size_t) -> *c_char;
 
                 #[link_name = "_getpid"]
-                unsafe fn getpid() -> c_int;
+                pub unsafe fn getpid() -> c_int;
 
                 #[link_name = "_isatty"]
-                unsafe fn isatty(fd: c_int) -> c_int;
+                pub unsafe fn isatty(fd: c_int) -> c_int;
 
                 #[link_name = "_lseek"]
-                unsafe fn lseek(fd: c_int, offset: c_long, origin: c_int)
-                             -> c_long;
+                pub unsafe fn lseek(fd: c_int, offset: c_long, origin: c_int)
+                                    -> c_long;
 
                 #[link_name = "_pipe"]
-                unsafe fn pipe(fds: *mut c_int, psize: c_uint,
-                        textmode: c_int) -> c_int;
+                pub unsafe fn pipe(fds: *mut c_int,
+                                   psize: c_uint,
+                                   textmode: c_int)
+                                   -> c_int;
 
                 #[link_name = "_read"]
                 #[fast_ffi]
-                unsafe fn read(fd: c_int, buf: *mut c_void, count: c_uint)
-                            -> c_int;
+                pub unsafe fn read(fd: c_int, buf: *mut c_void, count: c_uint)
+                                   -> c_int;
 
                 #[link_name = "_rmdir"]
-                unsafe fn rmdir(path: *c_char) -> c_int;
+                pub unsafe fn rmdir(path: *c_char) -> c_int;
 
                 #[link_name = "_unlink"]
-                unsafe fn unlink(c: *c_char) -> c_int;
+                pub unsafe fn unlink(c: *c_char) -> c_int;
 
                 #[link_name = "_write"]
                 #[fast_ffi]
-                unsafe fn write(fd: c_int, buf: *c_void, count: c_uint)
-                             -> c_int;
+                pub unsafe fn write(fd: c_int, buf: *c_void, count: c_uint)
+                                    -> c_int;
             }
         }
 
@@ -2607,30 +2633,30 @@ pub mod funcs {
 
             #[nolink]
             #[abi = "cdecl"]
-            pub extern {
-                unsafe fn chmod(path: *c_char, mode: mode_t) -> c_int;
-                unsafe fn fchmod(fd: c_int, mode: mode_t) -> c_int;
+            extern {
+                pub unsafe fn chmod(path: *c_char, mode: mode_t) -> c_int;
+                pub unsafe fn fchmod(fd: c_int, mode: mode_t) -> c_int;
 
                 #[cfg(target_os = "linux")]
                 #[cfg(target_os = "freebsd")]
                 #[cfg(target_os = "android")]
-               unsafe fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
+                pub unsafe fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
 
                 #[cfg(target_os = "macos")]
                 #[link_name = "fstat64"]
-                unsafe fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
+                pub unsafe fn fstat(fildes: c_int, buf: *mut stat) -> c_int;
 
-                unsafe fn mkdir(path: *c_char, mode: mode_t) -> c_int;
-                unsafe fn mkfifo(path: *c_char, mode: mode_t) -> c_int;
+                pub unsafe fn mkdir(path: *c_char, mode: mode_t) -> c_int;
+                pub unsafe fn mkfifo(path: *c_char, mode: mode_t) -> c_int;
 
                 #[cfg(target_os = "linux")]
                 #[cfg(target_os = "freebsd")]
                 #[cfg(target_os = "android")]
-                unsafe fn stat(path: *c_char, buf: *mut stat) -> c_int;
+                pub unsafe fn stat(path: *c_char, buf: *mut stat) -> c_int;
 
                 #[cfg(target_os = "macos")]
                 #[link_name = "stat64"]
-                unsafe fn stat(path: *c_char, buf: *mut stat) -> c_int;
+                pub unsafe fn stat(path: *c_char, buf: *mut stat) -> c_int;
             }
         }
 
@@ -2640,11 +2666,11 @@ pub mod funcs {
             use libc::types::common::c95::FILE;
             use libc::types::os::arch::c95::{c_char, c_int};
 
-            pub extern {
-                unsafe fn popen(command: *c_char, mode: *c_char) -> *FILE;
-                unsafe fn pclose(stream: *FILE) -> c_int;
-                unsafe fn fdopen(fd: c_int, mode: *c_char) -> *FILE;
-                unsafe fn fileno(stream: *FILE) -> c_int;
+            extern {
+                pub unsafe fn popen(command: *c_char, mode: *c_char) -> *FILE;
+                pub unsafe fn pclose(stream: *FILE) -> c_int;
+                pub unsafe fn fdopen(fd: c_int, mode: *c_char) -> *FILE;
+                pub unsafe fn fileno(stream: *FILE) -> c_int;
             }
         }
 
@@ -2654,11 +2680,11 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_char, c_int};
             use libc::types::os::arch::posix88::mode_t;
 
-            pub extern {
-                unsafe fn open(path: *c_char, oflag: c_int, mode: c_int)
-                            -> c_int;
-                unsafe fn creat(path: *c_char, mode: mode_t) -> c_int;
-                unsafe fn fcntl(fd: c_int, cmd: c_int) -> c_int;
+            extern {
+                pub unsafe fn open(path: *c_char, oflag: c_int, mode: c_int)
+                                   -> c_int;
+                pub unsafe fn creat(path: *c_char, mode: mode_t) -> c_int;
+                pub unsafe fn fcntl(fd: c_int, cmd: c_int) -> c_int;
             }
         }
 
@@ -2686,11 +2712,11 @@ pub mod funcs {
                 unsafe fn rust_readdir(dirp: *DIR) -> *dirent_t;
             }
 
-            pub extern {
-                unsafe fn closedir(dirp: *DIR) -> c_int;
-                unsafe fn rewinddir(dirp: *DIR);
-                unsafe fn seekdir(dirp: *DIR, loc: c_long);
-                unsafe fn telldir(dirp: *DIR) -> c_long;
+            extern {
+                pub unsafe fn closedir(dirp: *DIR) -> c_int;
+                pub unsafe fn rewinddir(dirp: *DIR);
+                pub unsafe fn seekdir(dirp: *DIR, loc: c_long);
+                pub unsafe fn telldir(dirp: *DIR) -> c_long;
             }
         }
 
@@ -2703,59 +2729,63 @@ pub mod funcs {
             use libc::types::os::arch::posix88::{gid_t, off_t, pid_t};
             use libc::types::os::arch::posix88::{ssize_t, uid_t};
 
-            pub extern {
-                unsafe fn access(path: *c_char, amode: c_int) -> c_int;
-                unsafe fn alarm(seconds: c_uint) -> c_uint;
-                unsafe fn chdir(dir: *c_char) -> c_int;
-                unsafe fn chown(path: *c_char, uid: uid_t, gid: gid_t)
-                             -> c_int;
-                unsafe fn close(fd: c_int) -> c_int;
-                unsafe fn dup(fd: c_int) -> c_int;
-                unsafe fn dup2(src: c_int, dst: c_int) -> c_int;
-                unsafe fn execv(prog: *c_char, argv: **c_char) -> c_int;
-                unsafe fn execve(prog: *c_char,
-                                 argv: **c_char,
-                                 envp: **c_char)
-                              -> c_int;
-                unsafe fn execvp(c: *c_char, argv: **c_char) -> c_int;
-                unsafe fn fork() -> pid_t;
-                unsafe fn fpathconf(filedes: c_int, name: c_int) -> c_long;
-                unsafe fn getcwd(buf: *c_char, size: size_t) -> *c_char;
-                unsafe fn getegid() -> gid_t;
-                unsafe fn geteuid() -> uid_t;
-                unsafe fn getgid() -> gid_t ;
-                unsafe fn getgroups(ngroups_max: c_int, groups: *mut gid_t)
-                                 -> c_int;
-                unsafe fn getlogin() -> *c_char;
-                unsafe fn getopt(argc: c_int, argv: **c_char, optstr: *c_char)
-                              -> c_int;
-                unsafe fn getpgrp() -> pid_t;
-                unsafe fn getpid() -> pid_t;
-                unsafe fn getppid() -> pid_t;
-                unsafe fn getuid() -> uid_t;
-                unsafe fn isatty(fd: c_int) -> c_int;
-                unsafe fn link(src: *c_char, dst: *c_char) -> c_int;
-                unsafe fn lseek(fd: c_int, offset: off_t, whence: c_int)
-                             -> off_t;
-                unsafe fn pathconf(path: *c_char, name: c_int) -> c_long;
-                unsafe fn pause() -> c_int;
-                unsafe fn pipe(fds: *mut c_int) -> c_int;
+            extern {
+                pub unsafe fn access(path: *c_char, amode: c_int) -> c_int;
+                pub unsafe fn alarm(seconds: c_uint) -> c_uint;
+                pub unsafe fn chdir(dir: *c_char) -> c_int;
+                pub unsafe fn chown(path: *c_char, uid: uid_t, gid: gid_t)
+                                    -> c_int;
+                pub unsafe fn close(fd: c_int) -> c_int;
+                pub unsafe fn dup(fd: c_int) -> c_int;
+                pub unsafe fn dup2(src: c_int, dst: c_int) -> c_int;
+                pub unsafe fn execv(prog: *c_char, argv: **c_char) -> c_int;
+                pub unsafe fn execve(prog: *c_char,
+                                     argv: **c_char,
+                                     envp: **c_char)
+                                     -> c_int;
+                pub unsafe fn execvp(c: *c_char, argv: **c_char) -> c_int;
+                pub unsafe fn fork() -> pid_t;
+                pub unsafe fn fpathconf(filedes: c_int, name: c_int)
+                                        -> c_long;
+                pub unsafe fn getcwd(buf: *c_char, size: size_t) -> *c_char;
+                pub unsafe fn getegid() -> gid_t;
+                pub unsafe fn geteuid() -> uid_t;
+                pub unsafe fn getgid() -> gid_t ;
+                pub unsafe fn getgroups(ngroups_max: c_int,
+                                        groups: *mut gid_t)
+                                        -> c_int;
+                pub unsafe fn getlogin() -> *c_char;
+                pub unsafe fn getopt(argc: c_int,
+                                     argv: **c_char,
+                                     optstr: *c_char)
+                                     -> c_int;
+                pub unsafe fn getpgrp() -> pid_t;
+                pub unsafe fn getpid() -> pid_t;
+                pub unsafe fn getppid() -> pid_t;
+                pub unsafe fn getuid() -> uid_t;
+                pub unsafe fn isatty(fd: c_int) -> c_int;
+                pub unsafe fn link(src: *c_char, dst: *c_char) -> c_int;
+                pub unsafe fn lseek(fd: c_int, offset: off_t, whence: c_int)
+                                    -> off_t;
+                pub unsafe fn pathconf(path: *c_char, name: c_int) -> c_long;
+                pub unsafe fn pause() -> c_int;
+                pub unsafe fn pipe(fds: *mut c_int) -> c_int;
                 #[fast_ffi]
-                unsafe fn read(fd: c_int, buf: *mut c_void,
-                        count: size_t) -> ssize_t;
-                unsafe fn rmdir(path: *c_char) -> c_int;
-                unsafe fn setgid(gid: gid_t) -> c_int;
-                unsafe fn setpgid(pid: pid_t, pgid: pid_t) -> c_int;
-                unsafe fn setsid() -> pid_t;
-                unsafe fn setuid(uid: uid_t) -> c_int;
-                unsafe fn sleep(secs: c_uint) -> c_uint;
-                unsafe fn sysconf(name: c_int) -> c_long;
-                unsafe fn tcgetpgrp(fd: c_int) -> pid_t;
-                unsafe fn ttyname(fd: c_int) -> *c_char;
-                unsafe fn unlink(c: *c_char) -> c_int;
+                pub unsafe fn read(fd: c_int, buf: *mut c_void, count: size_t)
+                                   -> ssize_t;
+                pub unsafe fn rmdir(path: *c_char) -> c_int;
+                pub unsafe fn setgid(gid: gid_t) -> c_int;
+                pub unsafe fn setpgid(pid: pid_t, pgid: pid_t) -> c_int;
+                pub unsafe fn setsid() -> pid_t;
+                pub unsafe fn setuid(uid: uid_t) -> c_int;
+                pub unsafe fn sleep(secs: c_uint) -> c_uint;
+                pub unsafe fn sysconf(name: c_int) -> c_long;
+                pub unsafe fn tcgetpgrp(fd: c_int) -> pid_t;
+                pub unsafe fn ttyname(fd: c_int) -> *c_char;
+                pub unsafe fn unlink(c: *c_char) -> c_int;
                 #[fast_ffi]
-                unsafe fn write(fd: c_int, buf: *c_void, count: size_t)
-                             -> ssize_t;
+                pub unsafe fn write(fd: c_int, buf: *c_void, count: size_t)
+                                    -> ssize_t;
             }
         }
 
@@ -2765,8 +2795,8 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_int};
             use libc::types::os::arch::posix88::{pid_t};
 
-            pub extern {
-                unsafe fn kill(pid: pid_t, sig: c_int) -> c_int;
+            extern {
+                pub unsafe fn kill(pid: pid_t, sig: c_int) -> c_int;
             }
         }
 
@@ -2777,28 +2807,33 @@ pub mod funcs {
             use libc::types::os::arch::c95::{size_t, c_int, c_char};
             use libc::types::os::arch::posix88::{mode_t, off_t};
 
-            pub extern {
-                unsafe fn mlock(addr: *c_void, len: size_t) -> c_int;
-                unsafe fn munlock(addr: *c_void, len: size_t) -> c_int;
-                unsafe fn mlockall(flags: c_int) -> c_int;
-                unsafe fn munlockall() -> c_int;
-
-                unsafe fn mmap(addr: *c_void,
-                               len: size_t,
-                               prot: c_int,
-                               flags: c_int,
-                               fd: c_int,
-                               offset: off_t) -> *mut c_void;
-                unsafe fn munmap(addr: *c_void, len: size_t) -> c_int;
-
-                unsafe fn mprotect(addr: *c_void, len: size_t, prot: c_int)
-                    -> c_int;
-
-                unsafe fn msync(addr: *c_void, len: size_t, flags: c_int)
-                    -> c_int;
-                unsafe fn shm_open(name: *c_char, oflag: c_int, mode: mode_t)
-                    -> c_int;
-                unsafe fn shm_unlink(name: *c_char) -> c_int;
+            extern {
+                pub unsafe fn mlock(addr: *c_void, len: size_t) -> c_int;
+                pub unsafe fn munlock(addr: *c_void, len: size_t) -> c_int;
+                pub unsafe fn mlockall(flags: c_int) -> c_int;
+                pub unsafe fn munlockall() -> c_int;
+
+                pub unsafe fn mmap(addr: *c_void,
+                                   len: size_t,
+                                   prot: c_int,
+                                   flags: c_int,
+                                   fd: c_int,
+                                   offset: off_t)
+                                   -> *mut c_void;
+                pub unsafe fn munmap(addr: *c_void, len: size_t) -> c_int;
+
+                pub unsafe fn mprotect(addr: *c_void,
+                                       len: size_t,
+                                       prot: c_int)
+                                       -> c_int;
+
+                pub unsafe fn msync(addr: *c_void, len: size_t, flags: c_int)
+                                    -> c_int;
+                pub unsafe fn shm_open(name: *c_char,
+                                       oflag: c_int,
+                                       mode: mode_t)
+                                       -> c_int;
+                pub unsafe fn shm_unlink(name: *c_char) -> c_int;
             }
         }
     }
@@ -2814,15 +2849,15 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_char, c_int};
             use libc::types::os::arch::posix01::stat;
 
-            pub extern {
+            extern {
                 #[cfg(target_os = "linux")]
                 #[cfg(target_os = "freebsd")]
                 #[cfg(target_os = "android")]
-                unsafe fn lstat(path: *c_char, buf: *mut stat) -> c_int;
+                pub unsafe fn lstat(path: *c_char, buf: *mut stat) -> c_int;
 
                 #[cfg(target_os = "macos")]
                 #[link_name = "lstat64"]
-                unsafe fn lstat(path: *c_char, buf: *mut stat) -> c_int;
+                pub unsafe fn lstat(path: *c_char, buf: *mut stat) -> c_int;
             }
         }
 
@@ -2832,22 +2867,27 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_char, c_int, size_t};
             use libc::types::os::arch::posix88::{ssize_t};
 
-            pub extern {
-                unsafe fn readlink(path: *c_char, buf: *mut c_char,
-                            bufsz: size_t) -> ssize_t;
+            extern {
+                pub unsafe fn readlink(path: *c_char,
+                                       buf: *mut c_char,
+                                       bufsz: size_t)
+                                       -> ssize_t;
 
-                unsafe fn fsync(fd: c_int) -> c_int;
+                pub unsafe fn fsync(fd: c_int) -> c_int;
 
                 #[cfg(target_os = "linux")]
                 #[cfg(target_os = "android")]
-                unsafe fn fdatasync(fd: c_int) -> c_int;
+                pub unsafe fn fdatasync(fd: c_int) -> c_int;
 
-                unsafe fn setenv(name: *c_char, val: *c_char,
-                          overwrite: c_int) -> c_int;
-                unsafe fn unsetenv(name: *c_char) -> c_int;
-                unsafe fn putenv(string: *c_char) -> c_int;
+                pub unsafe fn setenv(name: *c_char,
+                                     val: *c_char,
+                                     overwrite: c_int)
+                                     -> c_int;
+                pub unsafe fn unsetenv(name: *c_char) -> c_int;
+                pub unsafe fn putenv(string: *c_char) -> c_int;
 
-                unsafe fn symlink(path1: *c_char, path2: *c_char) -> c_int;
+                pub unsafe fn symlink(path1: *c_char, path2: *c_char)
+                                      -> c_int;
             }
         }
 
@@ -2857,11 +2897,11 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_int};
             use libc::types::os::arch::posix88::{pid_t};
 
-            pub extern {
-                unsafe fn waitpid(pid: pid_t,
-                                  status: *mut c_int,
-                                  options: c_int)
-                               -> pid_t;
+            extern {
+                pub unsafe fn waitpid(pid: pid_t,
+                                      status: *mut c_int,
+                                      options: c_int)
+                                      -> pid_t;
             }
         }
 
@@ -2872,11 +2912,12 @@ pub mod funcs {
             use libc::types::os::arch::c95::{c_char, c_int};
             use libc::types::os::common::posix01::{glob_t};
 
-            pub extern {
-                unsafe fn glob(pattern: *c_char, flags: c_int,
-                               errfunc: *c_void, // XXX callback
-                               pglob: *mut glob_t);
-                unsafe fn globfree(pglob: *mut glob_t);
+            extern {
+                pub unsafe fn glob(pattern: *c_char,
+                                   flags: c_int,
+                                   errfunc: *c_void, // XXX callback
+                                   pglob: *mut glob_t);
+                pub unsafe fn globfree(pglob: *mut glob_t);
             }
         }
 
@@ -2886,10 +2927,11 @@ pub mod funcs {
             use libc::types::common::c95::{c_void};
             use libc::types::os::arch::c95::{c_int, size_t};
 
-            pub extern {
-                unsafe fn posix_madvise(addr: *c_void,
-                                        len: size_t,
-                                        advice: c_int) -> c_int;
+            extern {
+                pub unsafe fn posix_madvise(addr: *c_void,
+                                            len: size_t,
+                                            advice: c_int)
+                                            -> c_int;
             }
         }
     }
@@ -2929,25 +2971,34 @@ pub mod funcs {
                                          size_t};
 
         #[abi = "cdecl"]
-        pub extern {
-            unsafe fn sysctl(name: *c_int, namelen: c_uint,
-                      oldp: *mut c_void, oldlenp: *mut size_t,
-                      newp: *c_void, newlen: size_t) -> c_int;
+        extern {
+            pub unsafe fn sysctl(name: *c_int,
+                                 namelen: c_uint,
+                                 oldp: *mut c_void,
+                                 oldlenp: *mut size_t,
+                                 newp: *c_void,
+                                 newlen: size_t)
+                                 -> c_int;
 
-            unsafe fn sysctlbyname(name: *c_char,
-                            oldp: *mut c_void, oldlenp: *mut size_t,
-                            newp: *c_void, newlen: size_t) -> c_int;
+            pub unsafe fn sysctlbyname(name: *c_char,
+                                       oldp: *mut c_void,
+                                       oldlenp: *mut size_t,
+                                       newp: *c_void,
+                                       newlen: size_t)
+                                       -> c_int;
 
-            unsafe fn sysctlnametomib(name: *c_char, mibp: *mut c_int,
-                               sizep: *mut size_t) -> c_int;
+            pub unsafe fn sysctlnametomib(name: *c_char,
+                                          mibp: *mut c_int,
+                                          sizep: *mut size_t)
+                                          -> c_int;
 
-            unsafe fn getdtablesize() -> c_int;
+            pub unsafe fn getdtablesize() -> c_int;
 
-            unsafe fn madvise(addr: *c_void, len: size_t, advice: c_int)
-                -> c_int;
+            pub unsafe fn madvise(addr: *c_void, len: size_t, advice: c_int)
+                                  -> c_int;
 
-            unsafe fn mincore(addr: *c_void, len: size_t, vec: *c_uchar)
-                -> c_int;
+            pub unsafe fn mincore(addr: *c_void, len: size_t, vec: *c_uchar)
+                                  -> c_int;
         }
     }
 
@@ -2959,14 +3010,14 @@ pub mod funcs {
         use libc::types::os::arch::c95::{c_uchar, c_int, size_t};
 
         #[abi = "cdecl"]
-        pub extern {
-            unsafe fn getdtablesize() -> c_int;
+        extern {
+            pub unsafe fn getdtablesize() -> c_int;
 
-            unsafe fn madvise(addr: *c_void, len: size_t, advice: c_int)
-                -> c_int;
+            pub unsafe fn madvise(addr: *c_void, len: size_t, advice: c_int)
+                                  -> c_int;
 
-            unsafe fn mincore(addr: *c_void, len: size_t, vec: *c_uchar)
-                -> c_int;
+            pub unsafe fn mincore(addr: *c_void, len: size_t, vec: *c_uchar)
+                                  -> c_int;
         }
     }
 
@@ -2981,10 +3032,10 @@ pub mod funcs {
         use libc::types::os::arch::c95::{c_char, c_int};
 
         #[abi = "cdecl"]
-        pub extern {
-            unsafe fn _NSGetExecutablePath(buf: *mut c_char,
-                                           bufsize: *mut u32)
-                                        -> c_int;
+        extern {
+            pub unsafe fn _NSGetExecutablePath(buf: *mut c_char,
+                                               bufsize: *mut u32)
+                                               -> c_int;
         }
     }
 
@@ -3014,96 +3065,119 @@ pub mod funcs {
             use libc::types::os::arch::extra::{HANDLE, LPHANDLE};
 
             #[abi = "stdcall"]
-            pub extern "stdcall" {
-                unsafe fn GetEnvironmentVariableW(n: LPCWSTR,
-                                                  v: LPWSTR,
-                                                  nsize: DWORD)
-                                               -> DWORD;
-                unsafe fn SetEnvironmentVariableW(n: LPCWSTR, v: LPCWSTR)
-                                               -> BOOL;
-                unsafe fn GetEnvironmentStringsA() -> LPTCH;
-                unsafe fn FreeEnvironmentStringsA(env_ptr: LPTCH) -> BOOL;
-
-                unsafe fn GetModuleFileNameW(hModule: HMODULE,
-                                             lpFilename: LPWSTR,
-                                             nSize: DWORD)
-                                          -> DWORD;
-                unsafe fn CreateDirectoryW(lpPathName: LPCWSTR,
-                                           lpSecurityAttributes:
-                                           LPSECURITY_ATTRIBUTES)
+            extern "stdcall" {
+                pub unsafe fn GetEnvironmentVariableW(n: LPCWSTR,
+                                                      v: LPWSTR,
+                                                      nsize: DWORD)
+                                                      -> DWORD;
+                pub unsafe fn SetEnvironmentVariableW(n: LPCWSTR, v: LPCWSTR)
+                                                      -> BOOL;
+                pub unsafe fn GetEnvironmentStringsA() -> LPTCH;
+                pub unsafe fn FreeEnvironmentStringsA(env_ptr: LPTCH) -> BOOL;
+
+                pub unsafe fn GetModuleFileNameW(hModule: HMODULE,
+                                                 lpFilename: LPWSTR,
+                                                 nSize: DWORD)
+                                                 -> DWORD;
+                pub unsafe fn CreateDirectoryW(lpPathName: LPCWSTR,
+                                               lpSecurityAttributes:
+                                               LPSECURITY_ATTRIBUTES)
+                                            -> BOOL;
+                pub unsafe fn CopyFileW(lpExistingFileName: LPCWSTR,
+                                        lpNewFileName: LPCWSTR,
+                                        bFailIfExists: BOOL)
                                         -> BOOL;
-                unsafe fn CopyFileW(lpExistingFileName: LPCWSTR,
-                                    lpNewFileName: LPCWSTR,
-                                    bFailIfExists: BOOL)
-                                 -> BOOL;
-                unsafe fn DeleteFileW(lpPathName: LPCWSTR) -> BOOL;
-                unsafe fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;
-                unsafe fn SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL;
-
-                unsafe fn GetLastError() -> DWORD;
-                unsafe fn FindFirstFileW(fileName: *u16,
-                                        findFileData: HANDLE)
-                    -> HANDLE;
-                unsafe fn FindNextFileW(findFile: HANDLE,
-                                       findFileData: HANDLE)
-                    -> BOOL;
-                unsafe fn FindClose(findFile: HANDLE) -> BOOL;
-                unsafe fn DuplicateHandle(hSourceProcessHandle: HANDLE,
-                                          hSourceHandle: HANDLE,
-                                          hTargetProcessHandle: HANDLE,
-                                          lpTargetHandle: LPHANDLE,
-                                          dwDesiredAccess: DWORD,
+                pub unsafe fn DeleteFileW(lpPathName: LPCWSTR) -> BOOL;
+                pub unsafe fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;
+                pub unsafe fn SetCurrentDirectoryW(lpPathName: LPCWSTR)
+                                                   -> BOOL;
+
+                pub unsafe fn GetLastError() -> DWORD;
+                pub unsafe fn FindFirstFileW(fileName: *u16,
+                                             findFileData: HANDLE)
+                                             -> HANDLE;
+                pub unsafe fn FindNextFileW(findFile: HANDLE,
+                                            findFileData: HANDLE)
+                                            -> BOOL;
+                pub unsafe fn FindClose(findFile: HANDLE) -> BOOL;
+                pub unsafe fn DuplicateHandle(hSourceProcessHandle: HANDLE,
+                                              hSourceHandle: HANDLE,
+                                              hTargetProcessHandle: HANDLE,
+                                              lpTargetHandle: LPHANDLE,
+                                              dwDesiredAccess: DWORD,
+                                              bInheritHandle: BOOL,
+                                              dwOptions: DWORD)
+                                              -> BOOL;
+                pub unsafe fn CloseHandle(hObject: HANDLE) -> BOOL;
+                pub unsafe fn OpenProcess(dwDesiredAccess: DWORD,
                                           bInheritHandle: BOOL,
-                                          dwOptions: DWORD) -> BOOL;
-                unsafe fn CloseHandle(hObject: HANDLE) -> BOOL;
-                unsafe fn OpenProcess(dwDesiredAccess: DWORD,
-                                      bInheritHandle: BOOL,
-                                      dwProcessId: DWORD) -> HANDLE;
-                unsafe fn GetCurrentProcess() -> HANDLE;
-                unsafe fn CreateProcessA(lpApplicationName: LPCTSTR,
-                                         lpCommandLine: LPTSTR,
-                                         lpProcessAttributes: LPSECURITY_ATTRIBUTES,
-                                         lpThreadAttributes: LPSECURITY_ATTRIBUTES,
-                                         bInheritHandles: BOOL,
-                                         dwCreationFlags: DWORD,
-                                         lpEnvironment: LPVOID,
-                                         lpCurrentDirectory: LPCTSTR,
-                                         lpStartupInfo: LPSTARTUPINFO,
-                                         lpProcessInformation: LPPROCESS_INFORMATION) -> BOOL;
-                unsafe fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) -> DWORD;
-                unsafe fn TerminateProcess(hProcess: HANDLE, uExitCode: c_uint) -> BOOL;
-                unsafe fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: LPDWORD) -> BOOL;
-
-                unsafe fn GetSystemInfo(lpSystemInfo: LPSYSTEM_INFO);
-                unsafe fn VirtualAlloc(lpAddress: LPVOID,
-                                       dwSize: SIZE_T,
-                                       flAllocationType: DWORD,
-                                       flProtect: DWORD) -> LPVOID;
-                unsafe fn VirtualFree(lpAddress: LPVOID,
-                                      dwSize: SIZE_T,
-                                      dwFreeType: DWORD) -> BOOL;
-                unsafe fn VirtualLock(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL;
-                unsafe fn VirtualUnlock(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL;
-                unsafe fn VirtualProtect(lpAddress: LPVOID,
-                                         dwSize: SIZE_T,
-                                         flNewProtect: DWORD,
-                                         lpflOldProtect: LPDWORD) -> BOOL;
-                unsafe fn VirtualQuery(lpAddress: LPCVOID,
-                                       lpBuffer: LPMEMORY_BASIC_INFORMATION,
-                                       dwLength: SIZE_T) -> SIZE_T;
-
-                unsafe fn CreateFileMappingW(hFile: HANDLE,
-                                             lpAttributes: LPSECURITY_ATTRIBUTES,
-                                             flProtect: DWORD,
-                                             dwMaximumSizeHigh: DWORD,
-                                             dwMaximumSizeLow: DWORD,
-                                             lpName: LPCTSTR) -> HANDLE;
-                unsafe fn MapViewOfFile(hFileMappingObject: HANDLE,
-                                        dwDesiredAccess: DWORD,
-                                        dwFileOffsetHigh: DWORD,
-                                        dwFileOffsetLow: DWORD,
-                                        dwNumberOfBytesToMap: SIZE_T) -> LPVOID;
-                unsafe fn UnmapViewOfFile(lpBaseAddress: LPCVOID) -> BOOL;
+                                          dwProcessId: DWORD)
+                                          -> HANDLE;
+                pub unsafe fn GetCurrentProcess() -> HANDLE;
+                pub unsafe fn CreateProcessA(lpApplicationName: LPCTSTR,
+                                             lpCommandLine: LPTSTR,
+                                             lpProcessAttributes:
+                                             LPSECURITY_ATTRIBUTES,
+                                             lpThreadAttributes:
+                                             LPSECURITY_ATTRIBUTES,
+                                             bInheritHandles: BOOL,
+                                             dwCreationFlags: DWORD,
+                                             lpEnvironment: LPVOID,
+                                             lpCurrentDirectory: LPCTSTR,
+                                             lpStartupInfo: LPSTARTUPINFO,
+                                             lpProcessInformation:
+                                             LPPROCESS_INFORMATION)
+                                             -> BOOL;
+                pub unsafe fn WaitForSingleObject(hHandle: HANDLE,
+                                                  dwMilliseconds: DWORD)
+                                                  -> DWORD;
+                pub unsafe fn TerminateProcess(hProcess: HANDLE,
+                                               uExitCode: c_uint)
+                                               -> BOOL;
+                pub unsafe fn GetExitCodeProcess(hProcess: HANDLE,
+                                                 lpExitCode: LPDWORD)
+                                                 -> BOOL;
+
+                pub unsafe fn GetSystemInfo(lpSystemInfo: LPSYSTEM_INFO);
+                pub unsafe fn VirtualAlloc(lpAddress: LPVOID,
+                                           dwSize: SIZE_T,
+                                           flAllocationType: DWORD,
+                                           flProtect: DWORD)
+                                           -> LPVOID;
+                pub unsafe fn VirtualFree(lpAddress: LPVOID,
+                                          dwSize: SIZE_T,
+                                          dwFreeType: DWORD)
+                                          -> BOOL;
+                pub unsafe fn VirtualLock(lpAddress: LPVOID, dwSize: SIZE_T)
+                                          -> BOOL;
+                pub unsafe fn VirtualUnlock(lpAddress: LPVOID, dwSize: SIZE_T)
+                                            -> BOOL;
+                pub unsafe fn VirtualProtect(lpAddress: LPVOID,
+                                             dwSize: SIZE_T,
+                                             flNewProtect: DWORD,
+                                             lpflOldProtect: LPDWORD)
+                                             -> BOOL;
+                pub unsafe fn VirtualQuery(lpAddress: LPCVOID,
+                                           lpBuffer:
+                                           LPMEMORY_BASIC_INFORMATION,
+                                           dwLength: SIZE_T)
+                                           -> SIZE_T;
+
+                pub unsafe fn CreateFileMappingW(hFile: HANDLE,
+                                                 lpAttributes:
+                                                 LPSECURITY_ATTRIBUTES,
+                                                 flProtect: DWORD,
+                                                 dwMaximumSizeHigh: DWORD,
+                                                 dwMaximumSizeLow: DWORD,
+                                                 lpName: LPCTSTR)
+                                                 -> HANDLE;
+                pub unsafe fn MapViewOfFile(hFileMappingObject: HANDLE,
+                                            dwDesiredAccess: DWORD,
+                                            dwFileOffsetHigh: DWORD,
+                                            dwFileOffsetLow: DWORD,
+                                            dwNumberOfBytesToMap: SIZE_T)
+                                            -> LPVOID;
+                pub unsafe fn UnmapViewOfFile(lpBaseAddress: LPCVOID) -> BOOL;
             }
         }
 
@@ -3112,12 +3186,12 @@ pub mod funcs {
 
             #[abi = "cdecl"]
             #[nolink]
-            pub extern {
+            extern {
                 #[link_name = "_commit"]
-                unsafe fn commit(fd: c_int) -> c_int;
+                pub unsafe fn commit(fd: c_int) -> c_int;
 
                 #[link_name = "_get_osfhandle"]
-                unsafe fn get_osfhandle(fd: c_int) -> c_long;
+                pub unsafe fn get_osfhandle(fd: c_int) -> c_long;
             }
         }
     }