diplomat 0.14.0

The diplomat FFI generation macro
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

---
source: macro/src/lib.rs
expression: "pretty_print_code(gen_bridge(parse_quote!\n{\n    mod ffi\n    {\n        pub struct Wrapper { cant_be_empty: bool, } pub struct TestingStruct\n        { x: i32, y: i32, } impl Wrapper\n        {\n            pub fn test_multi_arg_callback(f: impl Fn(i32) -> i32, x: i32) ->\n            i32 { f(10 + x) } pub fn\n            test_multiarg_void_callback(f: impl Fn(i32, &str))\n            { f(-10, \"hello it's a string\\0\"); } pub fn\n            test_mod_array(g: impl Fn(&[u8]))\n            {\n                let bytes: Vec<u8> = vec![0x11, 0x22];\n                g(bytes.as_slice().into());\n            } pub fn test_no_args(h: impl Fn()) -> i32 { h(); -5 } pub fn\n            test_cb_with_struct(f: impl Fn(TestingStruct) -> i32) -> i32\n            { let arg = TestingStruct { x: 1, y: 5, }; f(arg) } pub fn\n            test_multiple_cb_args(f: impl Fn() -> i32, g: impl Fn(i32) -> i32)\n            -> i32 { f() + g(5) }\n        }\n    }\n}).to_token_stream())"
---
mod ffi {
    #[repr(C)]
    pub struct Wrapper {
        cant_be_empty: bool,
    }
    #[repr(C)]
    pub struct TestingStruct {
        x: i32,
        y: i32,
    }
    impl Wrapper {
        pub fn test_multi_arg_callback(f: impl Fn(i32) -> i32, x: i32) -> i32 {
            f(10 + x)
        }
        pub fn test_multiarg_void_callback(f: impl Fn(i32, &str)) {
            f(-10, "hello it's a string\0");
        }
        pub fn test_mod_array(g: impl Fn(&[u8])) {
            let bytes: Vec<u8> = vec![0x11, 0x22];
            g(bytes.as_slice().into());
        }
        pub fn test_no_args(h: impl Fn()) -> i32 {
            h();
            -5
        }
        pub fn test_cb_with_struct(f: impl Fn(TestingStruct) -> i32) -> i32 {
            let arg = TestingStruct { x: 1, y: 5 };
            f(arg)
        }
        pub fn test_multiple_cb_args(
            f: impl Fn() -> i32,
            g: impl Fn(i32) -> i32,
        ) -> i32 {
            f() + g(5)
        }
    }
    use diplomat_runtime::*;
    use core::ffi::c_void;
    #[no_mangle]
    #[allow(deprecated)]
    extern "C" fn Wrapper_test_multi_arg_callback(
        f: DiplomatCallback<i32>,
        x: i32,
    ) -> i32 {
        let f = move |arg0: i32| unsafe {
            let _ = &f;
            std::mem::transmute::<
                unsafe extern "C" fn(*mut c_void, ...) -> i32,
                unsafe extern "C" fn(*const c_void, i32) -> i32,
            >(f.run_callback)(f.data, arg0)
        };
        Wrapper::test_multi_arg_callback(f, x)
    }
    #[no_mangle]
    #[allow(deprecated)]
    extern "C" fn Wrapper_test_multiarg_void_callback(f: DiplomatCallback<()>) {
        let f = move |arg0: i32, arg1: &str| unsafe {
            let arg1: diplomat_runtime::DiplomatUtf8StrSlice = arg1.into();
            let _ = &f;
            std::mem::transmute::<
                unsafe extern "C" fn(*mut c_void, ...) -> (),
                unsafe extern "C" fn(
                    *const c_void,
                    i32,
                    diplomat_runtime::DiplomatUtf8StrSlice,
                ) -> (),
            >(f.run_callback)(f.data, arg0, arg1)
                .into()
        };
        Wrapper::test_multiarg_void_callback(f)
    }
    #[no_mangle]
    #[allow(deprecated)]
    extern "C" fn Wrapper_test_mod_array(g: DiplomatCallback<()>) {
        let g = move |arg0: &[u8]| unsafe {
            let arg0: diplomat_runtime::DiplomatSlice<u8> = arg0.into();
            let _ = &g;
            std::mem::transmute::<
                unsafe extern "C" fn(*mut c_void, ...) -> (),
                unsafe extern "C" fn(
                    *const c_void,
                    diplomat_runtime::DiplomatSlice<u8>,
                ) -> (),
            >(g.run_callback)(g.data, arg0)
                .into()
        };
        Wrapper::test_mod_array(g)
    }
    #[no_mangle]
    #[allow(deprecated)]
    extern "C" fn Wrapper_test_no_args(h: DiplomatCallback<()>) -> i32 {
        let h = move || unsafe {
            let _ = &h;
            std::mem::transmute::<
                unsafe extern "C" fn(*mut c_void, ...) -> (),
                unsafe extern "C" fn(*const c_void) -> (),
            >(h.run_callback)(h.data)
                .into()
        };
        Wrapper::test_no_args(h)
    }
    #[no_mangle]
    #[allow(deprecated)]
    extern "C" fn Wrapper_test_cb_with_struct(f: DiplomatCallback<i32>) -> i32 {
        let f = move |arg0: TestingStruct| unsafe {
            let _ = &f;
            std::mem::transmute::<
                unsafe extern "C" fn(*mut c_void, ...) -> i32,
                unsafe extern "C" fn(*const c_void, TestingStruct) -> i32,
            >(f.run_callback)(f.data, arg0)
        };
        Wrapper::test_cb_with_struct(f)
    }
    #[no_mangle]
    #[allow(deprecated)]
    extern "C" fn Wrapper_test_multiple_cb_args(
        f: DiplomatCallback<i32>,
        g: DiplomatCallback<i32>,
    ) -> i32 {
        let f = move || unsafe {
            let _ = &f;
            std::mem::transmute::<
                unsafe extern "C" fn(*mut c_void, ...) -> i32,
                unsafe extern "C" fn(*const c_void) -> i32,
            >(f.run_callback)(f.data)
        };
        let g = move |arg0: i32| unsafe {
            let _ = &g;
            std::mem::transmute::<
                unsafe extern "C" fn(*mut c_void, ...) -> i32,
                unsafe extern "C" fn(*const c_void, i32) -> i32,
            >(g.run_callback)(g.data, arg0)
        };
        Wrapper::test_multiple_cb_args(f, g)
    }
}