ezffi 0.1.1

Generate C-FFI bindings from Rust types/functions via a single proc-macro attribute
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

use ezffi_macros::{export, export_extern_type, wrap_methods};

use crate::{CRefIntoRust, RustRefIntoC};

export_extern_type!(String);

#[doc(hidden)]
#[repr(C)]
#[derive(Clone, Copy)]
pub struct EzffiStr {
    len: usize,
    ptr: *mut u8,
}

impl RustRefIntoC<()> for str {
    type C = EzffiStr;

    unsafe fn ref_into_c(&self) -> EzffiStr {
        EzffiStr {
            ptr: self.as_ptr() as *mut u8,
            len: self.len(),
        }
    }
}

impl CRefIntoRust<str> for EzffiStr {
    unsafe fn into_rust(&self) -> &str {
        let slice = unsafe { core::slice::from_raw_parts(self.ptr, self.len) };
        unsafe { core::str::from_utf8_unchecked(slice) }
    }

    unsafe fn into_rust_mut(&mut self) -> &mut str {
        let slice = unsafe { core::slice::from_raw_parts_mut(self.ptr, self.len) };
        unsafe { core::str::from_utf8_unchecked_mut(slice) }
    }
}

wrap_methods!(String {
    fn new() -> String;
    fn with_capacity(capacity: usize) -> String;
    fn from(s: &str) -> String;
    fn len(&self) -> usize;
    fn is_empty(&self) -> bool;
    fn capacity(&self) -> usize;
    fn clear(&mut self);
    fn reserve(&mut self, additional: usize);
    fn truncate(&mut self, new_len: usize);
    fn shrink_to_fit(&mut self);
    fn push_str(&mut self, s: &str);
    fn insert_str(&mut self, idx: usize, s: &str);
});

#[doc(hidden)]
#[export]
pub fn string_eq_str(s: &String, other: &str) -> bool {
    s == other
}