---

yaml
---
r: 214257
b: refs/heads/auto
c: 8193133
h: refs/heads/master
i:
  214255: 996fcde
v: v3

Author: sfackler

[refs]

@@ -8,7 +8,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: dedd4302d190f5a232e75e2b808a4b86ae323678
+refs/heads/auto: 8193133f3548390559936fdaf377f5ef951ffd29
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/src/doc/trpl/ffi.md

@@ -530,37 +530,3 @@ The `extern` makes this function adhere to the C calling convention, as
 discussed above in "[Foreign Calling
 Conventions](ffi.html#foreign-calling-conventions)". The `no_mangle`
 attribute turns off Rust's name mangling, so that it is easier to link to.
-
-# FFI and panics
-
-It’s important to be mindful of `panic!`s when working with FFI. This code,
-when called from C, will `abort`:
-
-```rust
-#[no_mangle]
-pub extern fn oh_no() -> ! {
-    panic!("Oops!");
-}
-# fn main() {}
-```
-
-If you’re writing code that may panic, you should run it in another thread,
-so that the panic doesn’t bubble up to C:
-
-```rust
-use std::thread;
-
-#[no_mangle]
-pub extern fn oh_no() -> i32 {
-    let h = thread::spawn(|| {
-        panic!("Oops!");
-    });
-
-    match h.join() {
-        Ok(_) => 1,
-        Err(_) => 0,
-    }
-}
-# fn main() {}
-```
-

branches/auto/src/libcore/num/mod.rs

@@ -1372,13 +1372,14 @@ macro_rules! from_str_float_impl {
             /// This function accepts strings such as
             ///
             /// * '3.14'
+            /// * '+3.14', equivalent to '3.14'
             /// * '-3.14'
             /// * '2.5E10', or equivalently, '2.5e10'
             /// * '2.5E-10'
             /// * '.' (understood as 0)
             /// * '5.'
             /// * '.5', or, equivalently,  '0.5'
-            /// * 'inf', '-inf', 'NaN'
+            /// * '+inf', 'inf', '-inf', 'NaN'
             ///
             /// Leading and trailing whitespace represent an error.
             ///

branches/auto/src/liblibc/lib.rs

@@ -5493,17 +5493,17 @@ pub mod funcs {
                 pub fn dup2(src: c_int, dst: c_int) -> c_int;
                 #[link_name = "_execv"]
                 pub fn execv(prog: *const c_char,
-                             argv: *const *const c_char) -> intptr_t;
+                             argv: *mut *const c_char) -> intptr_t;
                 #[link_name = "_execve"]
-                pub fn execve(prog: *const c_char, argv: *const *const c_char,
-                              envp: *const *const c_char)
+                pub fn execve(prog: *const c_char, argv: *mut *const c_char,
+                              envp: *mut *const c_char)
                               -> c_int;
                 #[link_name = "_execvp"]
                 pub fn execvp(c: *const c_char,
-                              argv: *const *const c_char) -> c_int;
+                              argv: *mut *const c_char) -> c_int;
                 #[link_name = "_execvpe"]
-                pub fn execvpe(c: *const c_char, argv: *const *const c_char,
-                               envp: *const *const c_char) -> c_int;
+                pub fn execvpe(c: *const c_char, argv: *mut *const c_char,
+                               envp: *mut *const c_char) -> c_int;
                 #[link_name = "_getcwd"]
                 pub fn getcwd(buf: *mut c_char, size: size_t) -> *mut c_char;
                 #[link_name = "_getpid"]
@@ -5687,12 +5687,12 @@ pub mod funcs {
                 pub fn dup(fd: c_int) -> c_int;
                 pub fn dup2(src: c_int, dst: c_int) -> c_int;
                 pub fn execv(prog: *const c_char,
-                             argv: *const *const c_char) -> c_int;
-                pub fn execve(prog: *const c_char, argv: *const *const c_char,
-                              envp: *const *const c_char)
+                             argv: *mut *const c_char) -> c_int;
+                pub fn execve(prog: *const c_char, argv: *mut *const c_char,
+                              envp: *mut *const c_char)
                               -> c_int;
                 pub fn execvp(c: *const c_char,
-                              argv: *const *const c_char) -> c_int;
+                              argv: *mut *const c_char) -> c_int;
                 pub fn fork() -> pid_t;
                 pub fn fpathconf(filedes: c_int, name: c_int) -> c_long;
                 pub fn getcwd(buf: *mut c_char, size: size_t) -> *mut c_char;
@@ -5702,9 +5702,7 @@ pub mod funcs {
                 pub fn getgroups(ngroups_max: c_int, groups: *mut gid_t)
                                  -> c_int;
                 pub fn getlogin() -> *mut c_char;
-                // GNU getopt(3) modifies its arguments despite the
-                // char * const [] prototype; see the manpage.
-                pub fn getopt(argc: c_int, argv: *mut *mut c_char,
+                pub fn getopt(argc: c_int, argv: *mut *const c_char,
                               optstr: *const c_char) -> c_int;
                 pub fn getpgrp() -> pid_t;
                 pub fn getpid() -> pid_t;
@@ -5754,19 +5752,19 @@ pub mod funcs {
                 pub fn dup(fd: c_int) -> c_int;
                 pub fn dup2(src: c_int, dst: c_int) -> c_int;
                 pub fn execv(prog: *const c_char,
-                             argv: *const *const c_char) -> c_int;
-                pub fn execve(prog: *const c_char, argv: *const *const c_char,
-                              envp: *const *const c_char)
+                             argv: *mut *const c_char) -> c_int;
+                pub fn execve(prog: *const c_char, argv: *mut *const c_char,
+                              envp: *mut *const c_char)
                               -> c_int;
                 pub fn execvp(c: *const c_char,
-                              argv: *const *const c_char) -> c_int;
+                              argv: *mut *const c_char) -> c_int;
                 pub fn fork() -> pid_t;
                 pub fn getcwd(buf: *mut c_char, size: size_t) -> *mut c_char;
                 pub fn getegid() -> gid_t;
                 pub fn geteuid() -> uid_t;
                 pub fn getgid() -> gid_t;
                 pub fn getlogin() -> *mut c_char;
-                pub fn getopt(argc: c_int, argv: *const *const c_char,
+                pub fn getopt(argc: c_int, argv: *mut *const c_char,
                               optstr: *const c_char) -> c_int;
                 pub fn getuid() -> uid_t;
                 pub fn getsid(pid: pid_t) -> pid_t;

branches/auto/src/libstd/io/error.rs

@@ -37,6 +37,7 @@ pub struct Error {
     repr: Repr,
 }
 
+#[derive(Debug)]
 enum Repr {
     Os(i32),
     Custom(Box<Custom>),
@@ -239,17 +240,6 @@ impl Error {
     }
 }
 
-impl fmt::Debug for Repr {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &Repr::Os(ref code) =>
-                fmt.debug_struct("Os").field("code", code)
-                   .field("message", &sys::os::error_string(*code)).finish(),
-            &Repr::Custom(ref c) => fmt.debug_tuple("Custom").field(c).finish(),
-        }
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
@@ -292,16 +282,6 @@ mod test {
     use error;
     use error::Error as error_Error;
     use fmt;
-    use sys::os::error_string;
-
-    #[test]
-    fn test_debug_error() {
-        let code = 6;
-        let msg = error_string(code);
-        let err = Error { repr: super::Repr::Os(code) };
-        let expected = format!("Error {{ repr: Os {{ code: {:?}, message: {:?} }} }}", code, msg);
-        assert_eq!(format!("{:?}", err), expected);
-    }
 
     #[test]
     fn test_downcasting() {

branches/auto/src/libstd/net/mod.rs

@@ -30,7 +30,8 @@ mod udp;
 mod parser;
 #[cfg(test)] mod test;
 
-/// Possible values which can be passed to the `shutdown` method of `TcpStream`.
+/// Possible values which can be passed to the `shutdown` method of `TcpStream`
+/// and `UdpSocket`.
 #[derive(Copy, Clone, PartialEq, Debug)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub enum Shutdown {

branches/auto/src/libstd/panicking.rs

@@ -31,15 +31,12 @@ pub fn on_panic(obj: &(Any+Send), file: &'static str, line: u32) {
             None => "Box<Any>",
         }
     };
-    let mut err = match Stderr::new() {
-        Ok(err) => err,
-        _ => return,
-    };
+    let mut err = Stderr::new().ok();
     let thread = thread_info::current_thread();
     let name = thread.as_ref().and_then(|t| t.name()).unwrap_or("<unnamed>");
     let prev = LOCAL_STDERR.with(|s| s.borrow_mut().take());
-    match prev {
-        Some(mut stderr) => {
+    match (prev, err.as_mut()) {
+        (Some(mut stderr), _) => {
             // FIXME: what to do when the thread printing panics?
             let _ = writeln!(stderr,
                              "thread '{}' panicked at '{}', {}:{}\n",
@@ -52,18 +49,22 @@ pub fn on_panic(obj: &(Any+Send), file: &'static str, line: u32) {
                 *slot.borrow_mut() = s.take();
             });
         }
-        None => {
-            let _ = writeln!(&mut err, "thread '{}' panicked at '{}', {}:{}",
+        (None, Some(ref mut err)) => {
+            let _ = writeln!(err, "thread '{}' panicked at '{}', {}:{}",
                              name, msg, file, line);
             if backtrace::log_enabled() {
-                let _ = backtrace::write(&mut err);
+                let _ = backtrace::write(err);
             }
         }
+        _ => {}
     }
 
     // If this is a double panic, make sure that we printed a backtrace
     // for this panic.
-    if unwind::panicking() && !backtrace::log_enabled() {
-        let _ = backtrace::write(&mut err);
+    match err {
+        Some(ref mut err) if unwind::panicking() && !backtrace::log_enabled() => {
+            let _ = backtrace::write(err);
+        }
+        _ => {}
     }
 }

branches/auto/src/libstd/sys/unix/process.rs

@@ -313,7 +313,7 @@ impl Process {
         if !envp.is_null() {
             *sys::os::environ() = envp as *const _;
         }
-        let _ = libc::execvp(*argv, argv);
+        let _ = libc::execvp(*argv, argv as *mut _);
         fail(&mut output)
     }