use error::Error;
use fmt::{self, Write};
use io;
-use libc;
use mem;
use memchr;
use ops;
use ptr;
use slice;
use str::{self, Utf8Error};
+use sys;
/// A type representing an owned, C-compatible, nul-terminated string with no nul bytes in the
/// middle.
/// ```
#[stable(feature = "cstr_memory", since = "1.4.0")]
pub unsafe fn from_raw(ptr: *mut c_char) -> CString {
- let len = libc::strlen(ptr) + 1; // Including the NUL byte
+ let len = sys::strlen(ptr) + 1; // Including the NUL byte
let slice = slice::from_raw_parts_mut(ptr, len as usize);
CString { inner: Box::from_raw(slice as *mut [c_char] as *mut [u8]) }
}
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub unsafe fn from_ptr<'a>(ptr: *const c_char) -> &'a CStr {
- let len = libc::strlen(ptr);
+ let len = sys::strlen(ptr);
let ptr = ptr as *const u8;
CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts(ptr, len as usize + 1))
}
if cx.idx < cx.frames.len() {
cx.frames[cx.idx] = Frame {
- symbol_addr: symaddr,
- exact_position: ip,
+ symbol_addr: symaddr as *mut u8,
+ exact_position: ip as *mut u8,
};
cx.idx += 1;
}
use io::{self, ErrorKind};
+pub use libc::strlen;
pub use self::rand::hashmap_random_keys;
pub mod args;
{
unsafe {
let mut info: Dl_info = intrinsics::init();
- let symname = if dladdr(frame.exact_position, &mut info) == 0 ||
+ let symname = if dladdr(frame.exact_position as *mut _, &mut info) == 0 ||
info.dli_sname.is_null() {
None
} else {
}
extern {
- fn dladdr(addr: *const libc::c_void,
- info: *mut Dl_info) -> libc::c_int;
+ fn dladdr(addr: *const libc::c_void, info: *mut Dl_info) -> libc::c_int;
}
#[cfg(target_os = "emscripten")]
pub fn foreach_symbol_fileline<F>(_: Frame, _: F, _: &BacktraceContext) -> io::Result<bool>
where
- F: FnMut(&[u8], ::libc::c_int) -> io::Result<()>
+ F: FnMut(&[u8], u32) -> io::Result<()>
{
Ok(false)
}
} as usize;
for (from, to) in raw_frames.iter().zip(frames.iter_mut()).take(nb_frames) {
*to = Frame {
- exact_position: *from,
- symbol_addr: *from,
+ exact_position: *from as *mut u8,
+ symbol_addr: *from as *mut u8,
};
}
Ok((nb_frames as usize, BacktraceContext))
if cx.idx < cx.frames.len() {
cx.frames[cx.idx] = Frame {
- symbol_addr: symaddr,
- exact_position: ip,
+ symbol_addr: symaddr as *mut u8,
+ exact_position: ip as *mut u8,
};
cx.idx += 1;
}
#[cfg(all(not(dox), target_os = "l4re"))] pub use os::linux as platform;
pub use self::rand::hashmap_random_keys;
+pub use libc::strlen;
#[macro_use]
pub mod weak;
};
extern fn thread_start(main: *mut libc::c_void) -> *mut libc::c_void {
- unsafe { start_thread(main); }
+ unsafe { start_thread(main as *mut u8); }
ptr::null_mut()
}
}
frame.AddrReturn.Offset == 0 { break }
frames[i] = Frame {
- symbol_addr: (addr - 1) as *const c_void,
- exact_position: (addr - 1) as *const c_void,
+ symbol_addr: (addr - 1) as *const u8,
+ exact_position: (addr - 1) as *const u8,
};
i += 1;
}
use ffi::CStr;
use io;
-use libc::{c_ulong, c_int, c_char};
+use libc::{c_ulong, c_char};
use mem;
use sys::c;
use sys::backtrace::BacktraceContext;
mut f: F,
context: &BacktraceContext)
-> io::Result<bool>
- where F: FnMut(&[u8], c_int) -> io::Result<()>
+ where F: FnMut(&[u8], u32) -> io::Result<()>
{
let SymGetLineFromAddr64 = sym!(&context.dbghelp,
"SymGetLineFromAddr64",
&mut line);
if ret == c::TRUE {
let name = CStr::from_ptr(line.Filename).to_bytes();
- f(name, line.LineNumber as c_int)?;
+ f(name, line.LineNumber as u32)?;
}
Ok(false)
}
use path::PathBuf;
use time::Duration;
+pub use libc::strlen;
pub use self::rand::hashmap_random_keys;
#[macro_use] pub mod compat;
};
extern "system" fn thread_start(main: *mut c_void) -> c::DWORD {
- unsafe { start_thread(main); }
+ unsafe { start_thread(main as *mut u8); }
0
}
}
use env;
use io::prelude::*;
use io;
-use libc;
use str;
use sync::atomic::{self, Ordering};
use path::{self, Path};
#[derive(Debug, Copy, Clone)]
pub struct Frame {
/// Exact address of the call that failed.
- pub exact_position: *const libc::c_void,
+ pub exact_position: *const u8,
/// Address of the enclosing function.
- pub symbol_addr: *const libc::c_void,
+ pub symbol_addr: *const u8,
}
/// Max number of frames to print.
///
/// See also `output`.
#[allow(dead_code)]
-fn output_fileline(w: &mut Write, file: &[u8], line: libc::c_int,
- format: PrintFormat) -> io::Result<()> {
+fn output_fileline(w: &mut Write,
+ file: &[u8],
+ line: u32,
+ format: PrintFormat) -> io::Result<()> {
// prior line: " ##: {:2$} - func"
w.write_all(b"")?;
match format {
pub fn foreach_symbol_fileline<F>(frame: Frame,
mut f: F,
_: &BacktraceContext) -> io::Result<bool>
-where F: FnMut(&[u8], libc::c_int) -> io::Result<()>
+where F: FnMut(&[u8], u32) -> io::Result<()>
{
// pcinfo may return an arbitrary number of file:line pairs,
// in the order of stack trace (i.e. inlined calls first).
// in order to avoid allocation, we stack-allocate a fixed size of entries.
const FILELINE_SIZE: usize = 32;
- let mut fileline_buf = [(ptr::null(), -1); FILELINE_SIZE];
+ let mut fileline_buf = [(ptr::null(), !0); FILELINE_SIZE];
let ret;
let fileline_count = {
let state = unsafe { init_state() };
// helper callbacks
////////////////////////////////////////////////////////////////////////
-type FileLine = (*const libc::c_char, libc::c_int);
+type FileLine = (*const libc::c_char, u32);
extern fn error_cb(_data: *mut libc::c_void, _msg: *const libc::c_char,
_errnum: libc::c_int) {
// if the buffer is not full, add file:line to the buffer
// and adjust the buffer for next possible calls to pcinfo_cb.
if !buffer.is_empty() {
- buffer[0] = (filename, lineno);
+ buffer[0] = (filename, lineno as u32);
unsafe { ptr::write(slot, &mut buffer[1..]); }
}
}
use env;
use alloc::boxed::FnBox;
-use libc;
use sync::atomic::{self, Ordering};
use sys::stack_overflow;
use sys::thread as imp;
-pub unsafe fn start_thread(main: *mut libc::c_void) {
+pub unsafe fn start_thread(main: *mut u8) {
// Next, set up our stack overflow handler which may get triggered if we run
// out of stack.
let _handler = stack_overflow::Handler::new();