foreignc 0.1.2

Auto generate ffi abis directly from rust code
Documentation 
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71

extern crate libc;
use crate::{CResult, IntoFFi};
use std::fmt::Display;
use std::marker::PhantomData;
use std::mem;
use std::os::raw::{c_char, c_void};

pub type FFiResult<T> = Result<T, FFiError>;

/// Representation of a error during traversal of the ffi barrier.
/// This can be caused from everything from null pointer exceptions to the program panicing
#[derive(Debug)]
pub struct FFiError {
    pub content: String,
}

impl<T> From<T> for FFiError
where
    T: Display,
{
    fn from(v: T) -> FFiError {
        FFiError {
            content: format!("{}", v),
        }
    }
}

pub struct FFiResultWrap<T>(FFiResult<T>);
impl<T> From<FFiResult<T>> for FFiResultWrap<T> {
    fn from(v: FFiResult<T>) -> Self {
        Self(v)
    }
}

impl<T> Into<*mut CResult<T, *mut c_char>> for FFiResultWrap<T> {
    fn into(self) -> *mut CResult<T, *mut c_char> {
        unsafe {
            let v = match self.0 {
                Ok(v) => {
                    let obj_size = mem::size_of_val(&v);
                    let ptr: *mut T = libc::malloc(obj_size) as *mut T;
                    *ptr = v;
                    CResult {
                        is_err: false,
                        value: ptr as *mut c_void,
                        t: PhantomData,
                        e: PhantomData,
                    }
                }
                Err(e) => {
                    let v = String::into_ffi(e.content).unwrap();
                    let obj_size = mem::size_of_val(&v);
                    let ptr: *mut *mut c_char = libc::malloc(obj_size) as *mut *mut c_char;
                    *ptr = v;
                    CResult {
                        is_err: true,
                        value: ptr as *mut c_void,
                        t: PhantomData,
                        e: PhantomData,
                    }
                }
            };

            let obj_size = mem::size_of_val(&v);
            let ptr = libc::malloc(obj_size) as *mut CResult<T, *mut c_char>;
            *ptr = v;

            ptr
        }
    }
}