FFI Destruct

![crates badge] ![docs badge] ![build badge]

Generates destructors for structures that contain raw pointers in the FFI.

About

The Destruct derive macro will implement Drop trait and free(drop) memory for structures containing raw pointers. It may be a common procedure for FFI structure memory operations.

Supported types

Both *const and *mut are acceptable. But currently, only single-level pointers are supported.

• * c_char: c-style string, using std::ffi::CString::from_raw() to handle std::ffi::CString::into_raw()
• * <T>: Using std::boxed::Box::from_raw() to handle std::boxed::Box::into_raw()

Example

Provides a structure with several raw pointers that need to be dropped manually. ```rust use ffidestruct::{externc_destructor, Destruct}; use std::ffi::*;

[derive(Destruct)]

pub struct MyStruct { field: *mut std::ffi::c_char, }

pub struct AnyOther(u32, u32);

// Struct definition here, with deriving Destruct and nullable attributes.

[derive(Destruct)]

pub struct Structure { // Default is non-null. cstring: *const cchar, #[nullable] cstringnullable: *mut c_char,

other: *mut MyStruct,
#[nullable]
other_nullable: *mut MyStruct,

// Raw pointer for any other things
any: *mut AnyOther,

// Non-pointer types are still available, and will not be added to drop().
pub normal_int: u32,
pub normal_string: String,

}

// (Optional) The macro here generates the destructor: destructstructure() externc_destructor!(Structure);

fn main() { let mystruct = Structure { cstring: CString::new("Hello").unwrap().intoraw(), cstringnullable: std::ptr::nullmut(), other: Box::intoraw(Box::new(MyStruct { field: CString::new("Hello").unwrap().intoraw(), })), othernullable: std::ptr::nullmut(), any: Box::intoraw(Box::new(AnyOther(1, 1))), normalint: 114514, normalstring: "Hello".tostring(), };

let my_struct_ptr = Box::into_raw(Box::new(my_struct));
// FFI calling
unsafe {
    destruct_structure(my_struct_ptr);
}

} ```

After expanding the macros: ```rust

[macro_use]

extern crate std; use ffidestruct::{externc_destructor, Destruct}; use std::ffi::*;

pub struct MyStruct { field: *mut std::ffi::c_char, }

impl ::std::ops::Drop for MyStruct { fn drop(&mut self) { unsafe { let _ = ::std::ffi::CString::fromraw(self.field as *mut ::std::ffi::cchar); } } }

pub struct AnyOther(u32, u32);

pub struct Structure { cstring: *const cchar, #[nullable] cstringnullable: *mut cchar, other: *mut MyStruct, #[nullable] othernullable: *mut MyStruct, any: *mut AnyOther, pub normalint: u32, pub normalstring: String, }

impl ::std::ops::Drop for Structure { fn drop(&mut self) { unsafe { let _ = ::std::ffi::CString::fromraw( self.cstring as *mut ::std::ffi::cchar, ); if !self.cstringnullable.isnull() { let _ = ::std::ffi::CString::fromraw( self.cstringnullable as *mut ::std::ffi::cchar, ); } let _ = ::std::boxed::Box::fromraw(self.other as *mut MyStruct); if !self.othernullable.isnull() { let _ = ::std::boxed::Box::fromraw( self.othernullable as *mut MyStruct, ); } let _ = ::std::boxed::Box::fromraw(self.any as *mut AnyOther); } } }

[no_mangle]

pub unsafe extern "C" fn destructstructure(ptr: *mut Structure) { if ptr.isnull() { return; } let _ = ::std::boxed::Box::from_raw(ptr); }

fn main() { let mystruct = Structure { cstring: CString::new("Hello").unwrap().intoraw(), cstringnullable: std::ptr::nullmut(), other: Box::intoraw( Box::new(MyStruct { field: CString::new("Hello").unwrap().intoraw(), }), ), othernullable: std::ptr::nullmut(), any: Box::intoraw(Box::new(AnyOther(1, 1))), normalint: 114514, normalstring: "Hello".tostring(), }; let mystructptr = Box::intoraw(Box::new(mystruct)); unsafe { destructstructure(mystruct_ptr); } } ```