libstd::sys refactor

src/libstd/sys/common/at_exit_imp.rs → src/libstd/at_exit.rs

@@ -12,10 +12,10 @@
//!
//! Documentation can be found on the `rt::at_exit` function.

use sys::sync::Mutex;
use alloc::boxed::FnBox;
use boxed::Box;
use ptr;
use sys_common::mutex::Mutex;
use vec::Vec;

type Queue = Vec<Box<FnBox()>>;
@@ -67,7 +67,7 @@ pub fn cleanup() {
    }
}

pub fn push(f: Box<FnBox()>) -> bool {
fn push(f: Box<FnBox()>) -> bool {
    let mut ret = true;
    unsafe {
        LOCK.lock();
@@ -80,3 +80,7 @@ pub fn push(f: Box<FnBox()>) -> bool {
    }
    ret
}

pub fn at_exit<F: FnOnce() + Send + 'static>(f: F) -> Result<(), ()> {
    if push(Box::new(f)) {Ok(())} else {Err(())}
}

src/libstd/sys/common/backtrace.rs → src/libstd/backtrace.rs

@@ -8,25 +8,46 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use env;
use io::prelude::*;
use sys::inner::*;
use sys::error as sys_error;
use io;
use libc;
use str;
use sync::atomic::{self, Ordering};

pub use sys::backtrace::write;

#[cfg(target_pointer_width = "64")]
pub const HEX_WIDTH: usize = 18;

#[cfg(target_pointer_width = "32")]
pub const HEX_WIDTH: usize = 10;

pub fn output(w: &mut Write, idx: isize, addr: *mut (),
          s: Option<&[u8]>) -> sys_error::Result<()> {
    try!(write!(w, "  {:2}: {:2$?} - ", idx, addr, HEX_WIDTH).map_err(IntoInner::into_inner));
    match s.and_then(|s| str::from_utf8(s).ok()) {
        Some(string) => try!(demangle(w, string).map_err(IntoInner::into_inner)),
        None => try!(write!(w, "<unknown>").map_err(IntoInner::into_inner)),
    }
    w.write_all(&['\n' as u8]).map_err(IntoInner::into_inner)
}

pub fn output_fileline(w: &mut Write, file: &[u8], line: i32,
                   more: bool) -> sys_error::Result<()> {
    let file = str::from_utf8(file).unwrap_or("<unknown>");
    // prior line: "  ##: {:2$} - func"
    try!(write!(w, "      {:3$}at {}:{}", "", file, line, HEX_WIDTH).map_err(IntoInner::into_inner));
    if more {
        try!(write!(w, " <... and possibly more>").map_err(IntoInner::into_inner));
    }
    w.write_all(&['\n' as u8]).map_err(IntoInner::into_inner)
}

// For now logging is turned off by default, and this function checks to see
// whether the magical environment variable is present to see if it's turned on.
pub fn log_enabled() -> bool {
    static ENABLED: atomic::AtomicIsize = atomic::AtomicIsize::new(0);
    use env;
    use sync::atomic::{AtomicIsize, Ordering};

    static ENABLED: AtomicIsize = AtomicIsize::new(0);
    match ENABLED.load(Ordering::SeqCst) {
        1 => return false,
        2 => return true,
@@ -35,36 +56,12 @@ pub fn log_enabled() -> bool {

    let val = match env::var_os("RUST_BACKTRACE") {
        Some(..) => 2,
        None => 1,
        _ => 1,
    };
    ENABLED.store(val, Ordering::SeqCst);
    val == 2
}

// These output functions should now be used everywhere to ensure consistency.
pub fn output(w: &mut Write, idx: isize, addr: *mut libc::c_void,
              s: Option<&[u8]>) -> io::Result<()> {
    try!(write!(w, "  {:2}: {:2$?} - ", idx, addr, HEX_WIDTH));
    match s.and_then(|s| str::from_utf8(s).ok()) {
        Some(string) => try!(demangle(w, string)),
        None => try!(write!(w, "<unknown>")),
    }
    w.write_all(&['\n' as u8])
}

#[allow(dead_code)]
pub fn output_fileline(w: &mut Write, file: &[u8], line: libc::c_int,
                       more: bool) -> io::Result<()> {
    let file = str::from_utf8(file).unwrap_or("<unknown>");
    // prior line: "  ##: {:2$} - func"
    try!(write!(w, "      {:3$}at {}:{}", "", file, line, HEX_WIDTH));
    if more {
        try!(write!(w, " <... and possibly more>"));
    }
    w.write_all(&['\n' as u8])
}


// All rust symbols are in theory lists of "::"-separated identifiers. Some
// assemblers, however, can't handle these characters in symbol names. To get
// around this, we use C++-style mangling. The mangling method is:
@@ -188,10 +185,9 @@ pub fn demangle(writer: &mut Write, s: &str) -> io::Result<()> {
#[cfg(test)]
mod tests {
    use prelude::v1::*;
    use sys_common;
    macro_rules! t { ($a:expr, $b:expr) => ({
        let mut m = Vec::new();
        sys_common::backtrace::demangle(&mut m, $a).unwrap();
        super::demangle(&mut m, $a).unwrap();
        assert_eq!(String::from_utf8(m).unwrap(), $b);
    }) }