---

yaml
---
r: 110190
b: refs/heads/auto
c: 2d22243
h: refs/heads/master
v: v3

Author: eddyb

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: f1f50565a1fda0dfd60d89fea65e2328f42cc5e0
+refs/heads/auto: 2d22243b0c582574394da7e3d8aaf8b2abf2c147
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/crates.mk

@@ -49,14 +49,14 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
+TARGET_CRATES := std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
 		 workcache url log
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
-DEPS_std := libc native:rustrt native:compiler-rt native:backtrace
+DEPS_std := native:rustrt native:compiler-rt native:backtrace
 DEPS_green := std rand native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std

branches/auto/src/doc/guide-ffi.md

@@ -12,8 +12,7 @@ The following is a minimal example of calling a foreign function which will
 compile if snappy is installed:
 
 ~~~~ {.ignore}
-extern crate libc;
-use libc::size_t;
+use std::libc::size_t;
 
 #[link(name = "snappy")]
 extern {
@@ -45,8 +44,7 @@ keeping the binding correct at runtime.
 The `extern` block can be extended to cover the entire snappy API:
 
 ~~~~ {.ignore}
-extern crate libc;
-use libc::{c_int, size_t};
+use std::libc::{c_int, size_t};
 
 #[link(name = "snappy")]
 extern {
@@ -404,7 +402,7 @@ global state. In order to access these variables, you declare them in `extern`
 blocks with the `static` keyword:
 
 ~~~{.ignore}
-extern crate libc;
+use std::libc;
 
 #[link(name = "readline")]
 extern {
@@ -422,7 +420,7 @@ interface. To do this, statics can be declared with `mut` so rust can mutate
 them.
 
 ~~~{.ignore}
-extern crate libc;
+use std::libc;
 use std::ptr;
 
 #[link(name = "readline")]
@@ -446,15 +444,11 @@ calling foreign functions. Some foreign functions, most notably the Windows API,
 conventions. Rust provides a way to tell the compiler which convention to use:
 
 ~~~~
-extern crate libc;
-
 #[cfg(target_os = "win32", target_arch = "x86")]
 #[link(name = "kernel32")]
 extern "stdcall" {
-    fn SetEnvironmentVariableA(n: *u8, v: *u8) -> libc::c_int;
+    fn SetEnvironmentVariableA(n: *u8, v: *u8) -> std::libc::c_int;
 }
-
-# fn main() { }
 ~~~~
 
 This applies to the entire `extern` block. The list of supported ABI constraints

branches/auto/src/doc/guide-unsafe.md

@@ -192,8 +192,7 @@ As an example, we give a reimplementation of owned boxes by wrapping
 reimplementation is as safe as the built-in `~` type.
 
 ```
-extern crate libc;
-use libc::{c_void, size_t, malloc, free};
+use std::libc::{c_void, size_t, malloc, free};
 use std::mem;
 use std::ptr;
 

branches/auto/src/doc/index.md

@@ -36,7 +36,6 @@ li {list-style-type: none; }
 * [The `glob` file path matching library](glob/index.html)
 * [The `green` M:N runtime library](green/index.html)
 * [The `hexfloat` library for hexadecimal floating-point literals](hexfloat/index.html)
-* [The `libc` bindings](libc/index.html)
 * [The `native` 1:1 threading runtime](native/index.html)
 * [The `num` arbitrary precision numerics library](num/index.html)
 * [The `rand` library for random numbers and distributions](rand/index.html)

branches/auto/src/doc/rust.md

@@ -1471,13 +1471,11 @@ with the exception that they may not have a body
 and are instead terminated by a semicolon.
 
 ~~~~
-extern crate libc;
-use libc::{c_char, FILE};
+# use std::libc::{c_char, FILE};
 
 extern {
     fn fopen(filename: *c_char, mode: *c_char) -> *FILE;
 }
-# fn main() {}
 ~~~~
 
 Functions within external blocks may be called by Rust code,

branches/auto/src/etc/zsh/_rust

@@ -40,7 +40,7 @@ _rustc_opts_switches=(
 )
 _rustc_opts_lint=(
     'attribute-usage[detects bad use of attributes]'
-    'ctypes[proper use of libc types in foreign modules]'
+    'ctypes[proper use of std::libc types in foreign modules]'
     'dead-assignment[detect assignments that will never be read]'
     'dead-code[detect piece of code that will never be used]'
     'default-type-param-usage[prevents explicitly setting a type parameter with a default]'

branches/auto/src/libcollections/hashmap.rs

@@ -30,12 +30,11 @@ use std::result::{Ok, Err};
 use std::slice::ImmutableVector;
 
 mod table {
-    extern crate libc;
-
     use std::clone::Clone;
     use std::cmp::Eq;
     use std::hash::{Hash, Hasher};
     use std::kinds::marker;
+    use std::libc;
     use std::num::CheckedMul;
     use std::option::{Option, Some, None};
     use std::prelude::Drop;

branches/auto/src/libflate/lib.rs

@@ -26,14 +26,13 @@ Simple compression
 
 #[cfg(test)] #[phase(syntax, link)] extern crate log;
 
-extern crate libc;
-
+use std::libc::{c_void, size_t, c_int};
+use std::libc;
 use std::c_vec::CVec;
-use libc::{c_void, size_t, c_int};
-
 
 pub mod rustrt {
-    use libc::{c_void, size_t, c_int};
+    use std::libc::{c_int, c_void, size_t};
+
     #[link(name = "miniz", kind = "static")]
     extern {
         pub fn tdefl_compress_mem_to_heap(psrc_buf: *c_void,

branches/auto/src/libgreen/lib.rs

@@ -199,7 +199,6 @@
 #[cfg(test)] #[phase(syntax, link)] extern crate log;
 #[cfg(test)] extern crate rustuv;
 extern crate rand;
-extern crate libc;
 
 use std::mem::replace;
 use std::os;

branches/auto/src/libgreen/macros.rs

@@ -52,7 +52,7 @@ macro_rules! rtabort (
 
 pub fn dumb_println(args: &fmt::Arguments) {
     use std::io;
-    use libc;
+    use std::libc;
 
     struct Stderr;
     impl io::Writer for Stderr {

branches/auto/src/libgreen/sched.rs

@@ -976,7 +976,7 @@ fn new_sched_rng() -> XorShiftRng {
 }
 #[cfg(unix)]
 fn new_sched_rng() -> XorShiftRng {
-    use libc;
+    use std::libc;
     use std::mem;
     use rand::SeedableRng;
 

branches/auto/src/libgreen/stack.rs

@@ -11,7 +11,7 @@
 use std::rt::env::max_cached_stacks;
 use std::os::{errno, page_size, MemoryMap, MapReadable, MapWritable,
               MapNonStandardFlags, MapVirtual};
-use libc;
+use std::libc;
 
 /// A task's stack. The name "Stack" is a vestige of segmented stacks.
 pub struct Stack {

branches/auto/src/libnative/io/addrinfo.rs

@@ -12,8 +12,8 @@ use ai = std::io::net::addrinfo;
 use std::c_str::CString;
 use std::cast;
 use std::io::IoError;
-use libc;
-use libc::{c_char, c_int};
+use std::libc;
+use std::libc::{c_char, c_int};
 use std::ptr::{null, mut_null};
 
 use super::net::sockaddr_to_addr;

branches/auto/src/libnative/io/file_unix.rs

@@ -14,8 +14,8 @@ use std::sync::arc::UnsafeArc;
 use std::c_str::CString;
 use std::io::IoError;
 use std::io;
-use libc::{c_int, c_void};
-use libc;
+use std::libc::{c_int, c_void};
+use std::libc;
 use std::mem;
 use std::rt::rtio;
 use std::slice;
@@ -341,8 +341,8 @@ pub fn mkdir(p: &CString, mode: io::FilePermission) -> IoResult<()> {
 }
 
 pub fn readdir(p: &CString) -> IoResult<~[Path]> {
-    use libc::{dirent_t};
-    use libc::{opendir, readdir_r, closedir};
+    use std::libc::{dirent_t};
+    use std::libc::{opendir, readdir_r, closedir};
 
     fn prune(root: &CString, dirs: ~[Path]) -> ~[Path] {
         let root = unsafe { CString::new(root.with_ref(|p| p), false) };
@@ -520,7 +520,7 @@ pub fn utime(p: &CString, atime: u64, mtime: u64) -> IoResult<()> {
 mod tests {
     use super::{CFile, FileDesc};
     use std::io;
-    use libc;
+    use std::libc;
     use std::os;
     use std::rt::rtio::RtioFileStream;
 

branches/auto/src/libnative/io/file_win32.rs

@@ -14,8 +14,8 @@ use std::c_str::CString;
 use std::cast;
 use std::io::IoError;
 use std::io;
-use libc::{c_int, c_void};
-use libc;
+use std::libc::{c_int, c_void};
+use std::libc;
 use std::mem;
 use std::os::win32::{as_utf16_p, fill_utf16_buf_and_decode};
 use std::ptr;

branches/auto/src/libnative/io/mod.rs

@@ -27,8 +27,8 @@ use std::io::IoError;
 use std::io::net::ip::SocketAddr;
 use std::io::process::ProcessConfig;
 use std::io::signal::Signum;
-use libc::c_int;
-use libc;
+use std::libc::c_int;
+use std::libc;
 use std::os;
 use std::rt::rtio;
 use std::rt::rtio::{RtioTcpStream, RtioTcpListener, RtioUdpSocket,

branches/auto/src/libnative/io/net.rs

@@ -11,7 +11,7 @@
 use std::cast;
 use std::io::net::ip;
 use std::io;
-use libc;
+use std::libc;
 use std::mem;
 use std::rt::rtio;
 use std::sync::arc::UnsafeArc;

branches/auto/src/libnative/io/pipe_unix.rs

@@ -11,7 +11,7 @@
 use std::c_str::CString;
 use std::cast;
 use std::io;
-use libc;
+use std::libc;
 use std::mem;
 use std::rt::rtio;
 use std::sync::arc::UnsafeArc;

branches/auto/src/libnative/io/pipe_win32.rs

@@ -85,7 +85,7 @@
 //! me!
 
 use std::c_str::CString;
-use libc;
+use std::libc;
 use std::os::win32::as_utf16_p;
 use std::ptr;
 use std::rt::rtio;

branches/auto/src/libnative/io/process.rs

@@ -9,8 +9,8 @@
 // except according to those terms.
 
 use std::io;
-use libc::{pid_t, c_void, c_int};
-use libc;
+use std::libc::{pid_t, c_void, c_int};
+use std::libc;
 use std::os;
 use std::ptr;
 use std::rt::rtio;
@@ -223,20 +223,20 @@ fn spawn_process_os(config: p::ProcessConfig,
                     dir: Option<&Path>,
                     in_fd: c_int, out_fd: c_int,
                     err_fd: c_int) -> IoResult<SpawnProcessResult> {
-    use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
-    use libc::consts::os::extra::{
+    use std::libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
+    use std::libc::consts::os::extra::{
         TRUE, FALSE,
         STARTF_USESTDHANDLES,
         INVALID_HANDLE_VALUE,
         DUPLICATE_SAME_ACCESS
     };
-    use libc::funcs::extra::kernel32::{
+    use std::libc::funcs::extra::kernel32::{
         GetCurrentProcess,
         DuplicateHandle,
         CloseHandle,
         CreateProcessA
     };
-    use libc::funcs::extra::msvcrt::get_osfhandle;
+    use std::libc::funcs::extra::msvcrt::get_osfhandle;
 
     use std::mem;
 
@@ -422,9 +422,9 @@ fn spawn_process_os(config: p::ProcessConfig,
                     dir: Option<&Path>,
                     in_fd: c_int, out_fd: c_int,
                     err_fd: c_int) -> IoResult<SpawnProcessResult> {
-    use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
-    use libc::funcs::bsd44::getdtablesize;
-    use libc::c_ulong;
+    use std::libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
+    use std::libc::funcs::bsd44::getdtablesize;
+    use std::libc::c_ulong;
 
     mod rustrt {
         extern {
@@ -716,16 +716,16 @@ fn waitpid(pid: pid_t) -> p::ProcessExit {
 
     #[cfg(windows)]
     fn waitpid_os(pid: pid_t) -> p::ProcessExit {
-        use libc::types::os::arch::extra::DWORD;
-        use libc::consts::os::extra::{
+        use std::libc::types::os::arch::extra::DWORD;
+        use std::libc::consts::os::extra::{
             SYNCHRONIZE,
             PROCESS_QUERY_INFORMATION,
             FALSE,
             STILL_ACTIVE,
             INFINITE,
             WAIT_FAILED
         };
-        use libc::funcs::extra::kernel32::{
+        use std::libc::funcs::extra::kernel32::{
             OpenProcess,
             GetExitCodeProcess,
             CloseHandle,
@@ -761,7 +761,7 @@ fn waitpid(pid: pid_t) -> p::ProcessExit {
 
     #[cfg(unix)]
     fn waitpid_os(pid: pid_t) -> p::ProcessExit {
-        use libc::funcs::posix01::wait;
+        use std::libc::funcs::posix01::wait;
         let mut status = 0 as c_int;
         match retry(|| unsafe { wait::waitpid(pid, &mut status, 0) }) {
             -1 => fail!("unknown waitpid error: {}", super::last_error()),
@@ -779,7 +779,7 @@ fn waitpid_nowait(pid: pid_t) -> Option<p::ProcessExit> {
 
     #[cfg(unix)]
     fn waitpid_os(pid: pid_t) -> Option<p::ProcessExit> {
-        use libc::funcs::posix01::wait;
+        use std::libc::funcs::posix01::wait;
         let mut status = 0 as c_int;
         match retry(|| unsafe {
             wait::waitpid(pid, &mut status, libc::WNOHANG)

branches/auto/src/libnative/io/timer_helper.rs

@@ -94,7 +94,7 @@ fn shutdown() {
 
 #[cfg(unix)]
 mod imp {
-    use libc;
+    use std::libc;
     use std::os;
 
     use io::file::FileDesc;
@@ -117,9 +117,9 @@ mod imp {
 
 #[cfg(windows)]
 mod imp {
-    use libc::{BOOL, LPCSTR, HANDLE, LPSECURITY_ATTRIBUTES, CloseHandle};
+    use std::libc::{BOOL, LPCSTR, HANDLE, LPSECURITY_ATTRIBUTES, CloseHandle};
     use std::ptr;
-    use libc;
+    use std::libc;
 
     pub type signal = HANDLE;