std based C API

Author: zokier

Cargo.toml

@@ -10,3 +10,7 @@ documentation = "http://alexcrichton.com/rustc-demangle"
 description = """
 Rust compiler symbol demangling.
 """
+
+[workspace]
+members = ["rustc-demangle-capi"]
+

rustc-demangle-capi/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "rustc-demangle-capi"
+version = "0.1.0"
+authors = ["Torste Aikio <[email protected]>"]
+
+[lib]
+name = "rustc_demangle"
+crate-type = ["staticlib", "cdylib"]
+
+[dependencies]
+rustc-demangle = { version = "*", path = ".." }

rustc-demangle-capi/include/rustc_demangle.h

@@ -0,0 +1,18 @@
+#ifndef RUST_DEMANGLE_H_
+#define RUST_DEMANGLE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Demangles symbol given in `mangled` argument into `out` buffer
+//
+// Returns 0 if `mangled` is not Rust symbol or if `out` buffer is too small
+// Returns 1 otherwise
+int rustc_demangle(const char *mangled, char *out, size_t out_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // RUSTC_DEMANGLE_H_

rustc-demangle-capi/src/lib.rs

@@ -0,0 +1,109 @@
+extern crate rustc_demangle;
+
+use std::os::raw::{c_char,c_int};
+use std::io::Write;
+
+/// C-style interface for demangling.
+/// Demangles symbol given in `mangled` argument into `out` buffer
+///
+/// Unsafe as it handles buffers by raw pointers.
+///
+/// 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();
+    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) {
+                Ok(_) => { return 1 },
+                Err(_) => { return 0 }
+            }
+        },
+        Err(_) => { return 0 }
+    }
+}
+
+#[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) };
+        assert_eq!(res, 1);
+        let out_str = std::str::from_utf8(&out_buf[..5]).unwrap();
+        assert_eq!(out_str, "test\0");
+    }
+
+    #[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) };
+        assert_eq!(res, 1);
+        let out_str = std::str::from_utf8(&out_buf).unwrap();
+        assert_eq!(out_str, "test\0***");
+    }
+
+    #[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) };
+        assert_eq!(res, 0);
+        let out_str = std::str::from_utf8(&out_buf[4..]).unwrap();
+        assert_eq!(out_str, "****");
+    }
+
+    #[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) };
+        assert_eq!(res, 0);
+        let out_str = std::str::from_utf8(&out_buf[3..]).unwrap();
+        assert_eq!(out_str, "*****");
+    }
+
+    #[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) };
+        assert_eq!(res, 0);
+        let out_str = std::str::from_utf8(&out_buf).unwrap();
+        assert_eq!(out_str, "********");
+    }
+
+    #[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) };
+        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) };
+        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) };
+        assert_eq!(res, 0);
+    }
+}