nostd version of C API

Author: zokier

rustc-demangle-capi/src/lib.rs

@@ -1,7 +1,29 @@
+#![no_std]
+#![feature(lang_items, core_intrinsics)]
+
+#[cfg(test)]
+#[macro_use]
+extern crate std;
+
 extern crate rustc_demangle;
 
-use std::os::raw::{c_char,c_int};
-use std::io::Write;
+use core::fmt::Write;
+
+struct WriteAdaptor<'a> {
+    inner: &'a mut [u8]
+}
+
+impl<'a> core::fmt::Write for WriteAdaptor<'a> {
+    fn write_str(&mut self, s: &str) -> core::fmt::Result {
+        if s.len() > self.inner.len() {
+            return Err(core::fmt::Error);
+        }
+        let (left,right) = core::mem::replace(self, WriteAdaptor { inner: &mut [] }).inner.split_at_mut(s.len());
+        left.copy_from_slice(s.as_bytes());
+        *self = WriteAdaptor { inner: right };
+        Ok(())
+    }
+}
 
 /// C-style interface for demangling.
 /// Demangles symbol given in `mangled` argument into `out` buffer
@@ -11,16 +33,23 @@ use std::io::Write;
 /// Returns 0 if `mangled` is not Rust symbol or if `out` buffer is too small
 /// Returns 1 otherwise
 #[no_mangle]
-pub unsafe extern fn rustc_demangle(mangled: *const c_char, out: *mut c_char, out_size: usize) -> c_int {
-    let mangled_str = std::ffi::CStr::from_ptr(mangled).to_str();
+pub unsafe extern fn rustc_demangle(mangled: *const u8, out: *mut u8, out_size: usize) -> i64 {
+    // homebrew version of strlen
+    let mut mangled_len = 0;
+    while *(mangled.add(mangled_len)) != 0 {
+        mangled_len += 1;
+    }
+    let mangled_slice = core::slice::from_raw_parts(mangled, mangled_len);
+    let mangled_str = core::str::from_utf8(mangled_slice);
     if mangled_str.is_err() {
         return 0;
     }
     let mangled_str = mangled_str.unwrap();
     match rustc_demangle::try_demangle(mangled_str) {
         Ok(demangle) => {
-            let mut out_slice = std::slice::from_raw_parts_mut(out as *mut u8, out_size);
-            match write!(out_slice, "{:#}\0", demangle) {
+            let mut out_slice = core::slice::from_raw_parts_mut(out, out_size);
+            let mut out_adaptor = WriteAdaptor { inner: out_slice };
+            match write!(out_adaptor, "{:#}\0", demangle) {
                 Ok(_) => { return 1 },
                 Err(_) => { return 0 }
             }
@@ -31,13 +60,13 @@ pub unsafe extern fn rustc_demangle(mangled: *const c_char, out: *mut c_char, ou
 
 #[cfg(test)]
 mod tests {
-    use std::os::raw::c_char;
     use std;
+
     #[test]
     fn demangle_c_str_large() {
         let mangled = "_ZN4testE\0";
-        let mut out_buf: Vec<u8> = vec![42;8];
-        let res = unsafe { super::rustc_demangle(mangled.as_ptr() as *const c_char, out_buf.as_mut_ptr() as *mut c_char, 8) };
+        let mut out_buf = vec![42;8];
+        let res = unsafe { super::rustc_demangle(mangled.as_ptr(), out_buf.as_mut_ptr(), 8) };
         assert_eq!(res, 1);
         let out_str = std::str::from_utf8(&out_buf[..5]).unwrap();
         assert_eq!(out_str, "test\0");
@@ -46,8 +75,8 @@ mod tests {
     #[test]
     fn demangle_c_str_exact() {
         let mangled = "_ZN4testE\0";
-        let mut out_buf: Vec<u8> = vec![42;8];
-        let res = unsafe { super::rustc_demangle(mangled.as_ptr() as *const c_char, out_buf.as_mut_ptr() as *mut c_char, 5) };
+        let mut out_buf = vec![42;8];
+        let res = unsafe { super::rustc_demangle(mangled.as_ptr(), out_buf.as_mut_ptr(), 5) };
         assert_eq!(res, 1);
         let out_str = std::str::from_utf8(&out_buf).unwrap();
         assert_eq!(out_str, "test\0***");
@@ -56,8 +85,8 @@ mod tests {
     #[test]
     fn demangle_c_str_small() {
         let mangled = "_ZN4testE\0";
-        let mut out_buf: Vec<u8> = vec![42;8];
-        let res = unsafe { super::rustc_demangle(mangled.as_ptr() as *const c_char, out_buf.as_mut_ptr() as *mut c_char, 4) };
+        let mut out_buf = vec![42;8];
+        let res = unsafe { super::rustc_demangle(mangled.as_ptr(), out_buf.as_mut_ptr(), 4) };
         assert_eq!(res, 0);
         let out_str = std::str::from_utf8(&out_buf[4..]).unwrap();
         assert_eq!(out_str, "****");
@@ -66,8 +95,8 @@ mod tests {
     #[test]
     fn demangle_c_str_smaller() {
         let mangled = "_ZN4testE\0";
-        let mut out_buf: Vec<u8> = vec![42;8];
-        let res = unsafe { super::rustc_demangle(mangled.as_ptr() as *const c_char, out_buf.as_mut_ptr() as *mut c_char, 3) };
+        let mut out_buf = vec![42;8];
+        let res = unsafe { super::rustc_demangle(mangled.as_ptr(), out_buf.as_mut_ptr(), 3) };
         assert_eq!(res, 0);
         let out_str = std::str::from_utf8(&out_buf[3..]).unwrap();
         assert_eq!(out_str, "*****");
@@ -76,8 +105,8 @@ mod tests {
     #[test]
     fn demangle_c_str_zero() {
         let mangled = "_ZN4testE\0";
-        let mut out_buf: Vec<u8> = vec![42;8];
-        let res = unsafe { super::rustc_demangle(mangled.as_ptr() as *const c_char, out_buf.as_mut_ptr() as *mut c_char, 0) };
+        let mut out_buf = vec![42;8];
+        let res = unsafe { super::rustc_demangle(mangled.as_ptr(), out_buf.as_mut_ptr(), 0) };
         assert_eq!(res, 0);
         let out_str = std::str::from_utf8(&out_buf).unwrap();
         assert_eq!(out_str, "********");
@@ -86,24 +115,51 @@ mod tests {
     #[test]
     fn demangle_c_str_not_rust_symbol() {
         let mangled = "la la la\0";
-        let mut out_buf: Vec<u8> = vec![42;8];
-        let res = unsafe { super::rustc_demangle(mangled.as_ptr() as *const c_char, out_buf.as_mut_ptr() as *mut c_char, 8) };
+        let mut out_buf = vec![42;8];
+        let res = unsafe { super::rustc_demangle(mangled.as_ptr(), out_buf.as_mut_ptr(), 8) };
         assert_eq!(res, 0);
     }
 
     #[test]
     fn demangle_c_str_null() {
         let mangled = "\0";
-        let mut out_buf: Vec<u8> = vec![42;8];
-        let res = unsafe { super::rustc_demangle(mangled.as_ptr() as *const c_char, out_buf.as_mut_ptr() as *mut c_char, 8) };
+        let mut out_buf = vec![42;8];
+        let res = unsafe { super::rustc_demangle(mangled.as_ptr(), out_buf.as_mut_ptr(), 8) };
         assert_eq!(res, 0);
     }
 
     #[test]
     fn demangle_c_str_invalid_utf8() {
         let mangled = [116, 101, 115, 116, 165, 0];
-        let mut out_buf: Vec<u8> = vec![42;8];
-        let res = unsafe { super::rustc_demangle(mangled.as_ptr() as *const c_char, out_buf.as_mut_ptr() as *mut c_char, 8) };
+        let mut out_buf = vec![42;8];
+        let res = unsafe { super::rustc_demangle(mangled.as_ptr(), out_buf.as_mut_ptr(), 8) };
         assert_eq!(res, 0);
     }
 }
+
+#[cfg(not(test))]
+pub mod nostd_boilerplate {
+    use core;
+    // These functions are used by the compiler, but not
+    // for a bare-bones hello world. These are normally
+    // provided by libstd.
+    #[lang = "eh_personality"]
+    #[no_mangle]
+    pub extern fn rust_eh_personality() {
+    }
+
+    // This function may be needed based on the compilation target.
+    #[lang = "eh_unwind_resume"]
+    #[no_mangle]
+    pub extern fn rust_eh_unwind_resume() {
+    }
+
+    #[lang = "panic_fmt"]
+    #[no_mangle]
+    pub extern fn rust_begin_panic(_msg: core::fmt::Arguments,
+                                   _file: &'static str,
+                                   _line: u32,
+                                   _column: u32) -> ! {
+        unsafe { core::intrinsics::abort() }
+    }
+}