callable/closure impl

crates/lune-std-ffi/src/c/c_fn.rs

@@ -5,7 +5,9 @@ use mlua::prelude::*;
 use super::c_helper::{
     get_conv, get_conv_list_from_table, libffi_type_from_userdata, libffi_type_list_from_table,
 };
-use crate::ffi::NativeConvert;
+use crate::ffi::{
+    FfiClosure, NativeArgInfo, NativeArgType, NativeConvert, NativeResultInfo, NativeResultType,
+};
 
 // cfn is a type declaration for a function.
 // Basically, when calling an external function, this type declaration
@@ -25,39 +27,51 @@ use crate::ffi::NativeConvert;
 
 pub struct CFn {
     cif: *mut ffi_cif,
-    args_conv: Vec<*const dyn NativeConvert>,
-    ret_conv: *const dyn NativeConvert,
+    arg_info_list: Vec<NativeArgInfo>,
+    result_info: NativeResultInfo,
 }
 
+// support: Cfn as function pointer
+
 impl CFn {
     pub fn new(
         args: Vec<Type>,
         ret: Type,
-        args_conv: Vec<*const dyn NativeConvert>,
-        ret_conv: *const dyn NativeConvert,
+        arg_info_list: Vec<NativeArgInfo>,
+        result_info: NativeResultInfo,
     ) -> Self {
         Self {
             cif: Cif::new(args.clone(), ret.clone()).as_raw_ptr(),
-            args_conv,
-            ret_conv,
+            arg_info_list,
+            result_info,
         }
     }
 
     pub fn new_from_lua_table(lua: &Lua, args: LuaTable, ret: LuaAnyUserData) -> LuaResult<Self> {
         let args_types = libffi_type_list_from_table(lua, &args)?;
         let ret_type = libffi_type_from_userdata(lua, &ret)?;
 
-        Ok(Self::new(
-            args_types,
-            ret_type,
-            unsafe { get_conv_list_from_table(&args)? },
-            unsafe { get_conv(&ret)? },
-        ))
+        let len = args.raw_len();
+        let mut arg_info_list = Vec::<NativeArgInfo>::with_capacity(len);
+
+        for conv in unsafe { get_conv_list_from_table(&args)? } {
+            arg_info_list.push(NativeArgInfo { conv })
+        }
+
+        // get_conv_list_from_table(&args)?.iter().map(|conv| {
+        //     conv.to_owned()
+        // }).collect()
+
+        Ok(Self::new(args_types, ret_type, unsafe {}, unsafe {
+            get_conv(&ret)?
+        }))
     }
 }
 
 impl LuaUserData for CFn {
     fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-        // methods.add_method("from", | this,  |)
+        methods.add_method("closure", |lua, this, func: LuaFunction| {
+            lua.create_userdata(FfiClosure::new(this.cif, userdata))
+        })
     }
 }

crates/lune-std-ffi/src/c/c_helper.rs

@@ -9,7 +9,9 @@ use mlua::prelude::*;
 use super::{
     association_names::CTYPE_STATIC, types::get_ctype_conv, CArr, CPtr, CStruct, CTypeStatic,
 };
-use crate::ffi::{ffi_association::get_association, NativeConvert, FFI_STATUS_NAMES};
+use crate::ffi::{
+    ffi_association::get_association, NativeConvert, NativeSignedness, NativeSize, FFI_STATUS_NAMES,
+};
 
 // Get the NativeConvert handle from the type UserData
 // this is intended to avoid lookup userdata and lua table every time. (eg: struct)
@@ -22,6 +24,7 @@ pub unsafe fn get_conv(userdata: &LuaAnyUserData) -> LuaResult<*const dyn Native
         unsafe { get_ctype_conv(userdata) }
     }
 }
+
 pub unsafe fn get_conv_list_from_table(
     table: &LuaTable,
 ) -> LuaResult<Vec<*const dyn NativeConvert>> {
@@ -55,7 +58,7 @@ pub unsafe fn get_conv_list_from_table(
 //     }
 // }
 
-// get Vec<libffi_type> from table(array) of c-types userdata
+// get Vec<libffi_type> from table(array) of c-type userdata
 pub fn libffi_type_list_from_table(lua: &Lua, table: &LuaTable) -> LuaResult<Vec<Type>> {
     let len: usize = table.raw_len();
     let mut fields = Vec::with_capacity(len);
@@ -82,9 +85,7 @@ pub fn libffi_type_from_userdata(lua: &Lua, userdata: &LuaAnyUserData) -> LuaRes
         Ok(userdata.borrow::<CStruct>()?.get_type().to_owned())
     } else if let Some(t) = get_association(lua, CTYPE_STATIC, userdata)? {
         Ok(t.as_userdata()
-            .ok_or(LuaError::external(
-                "Failed to get static ctype from userdata",
-            ))?
+            .ok_or_else(|| LuaError::external("Failed to get static ctype from userdata"))?
             .borrow::<CTypeStatic>()?
             .libffi_type
             .clone())
@@ -120,9 +121,7 @@ pub fn stringify_userdata(lua: &Lua, userdata: &LuaAnyUserData) -> LuaResult<Str
     } else if let Some(t) = get_association(lua, CTYPE_STATIC, userdata)? {
         Ok(String::from(
             t.as_userdata()
-                .ok_or(LuaError::external(
-                    "Failed to get static ctype from userdata",
-                ))?
+                .ok_or_else(|| LuaError::external("Failed to get static ctype from userdata"))?
                 .borrow::<CTypeStatic>()?
                 .name
                 .unwrap_or("unnamed"),

crates/lune-std-ffi/src/ffi/ffi_callable.rs

@@ -0,0 +1,109 @@
+use core::ffi::c_void;
+use std::cell::Ref;
+// use std::ptr;
+
+use libffi::{
+    // low::{closure_alloc, ffi_cif, CodePtr, RawCallback},
+    low::{ffi_cif, CodePtr},
+    // middle::Cif,
+    // raw::ffi_prep_closure_loc,
+};
+use mlua::prelude::*;
+
+use super::{
+    bit_mask::u8_test_not, ffi_native::NativeArgInfo, FfiRef, FfiRefFlag, GetNativeData,
+    NativeConvert, NativeData,
+};
+
+// unsafe extern "C" fn callback() {
+//     _cif: ffi_cif,
+//     result: &mut
+// }
+
+// pub type RawCallback = unsafe extern "C" fn(cif: *mut ffi_cif, result: *mut c_void, args: *mut *mut c_void, userdata: *mut c_void);
+// pub unsafe extern "C" fn ffi_prep_raw_closure(
+//     arg1: *mut ffi_raw_closure,
+//     cif: *mut ffi_cif,
+//     fun: Option<unsafe extern "C" fn(_: *mut ffi_cif, _: *mut c_void, _: *mut ffi_raw, _: *mut c_void)>,
+//     user_data: *mut c_void
+// ) -> u32
+
+// pub fn ffi_prep_raw_closure_loc(
+//     arg1: *mut ffi_raw_closure,
+//     cif: *mut ffi_cif,
+//     fun: Option<
+//         unsafe extern "C" fn(
+//             arg1: *mut ffi_cif,
+//             arg2: *mut c_void,
+//             arg3: *mut ffi_raw,
+//             arg4: *mut c_void,
+//         ),
+//     >,
+//     user_data: *mut c_void,
+//     codeloc: *mut c_void,
+// ) -> ffi_status;
+
+pub struct FfiCallable {
+    cif: *mut ffi_cif,
+    arg_type_list: Vec<NativeArgInfo>,
+    result_size: usize,
+    code: CodePtr,
+}
+
+impl FfiCallable {
+    pub unsafe fn new(
+        cif: *mut ffi_cif,
+        arg_type_list: Vec<NativeArgInfo>,
+        result_size: usize,
+        function_ref: FfiRef,
+    ) -> LuaResult<Self> {
+        if u8_test_not(function_ref.flags, FfiRefFlag::Function.value()) {
+            return Err(LuaError::external("ref is not function pointer"));
+        }
+        Ok(Self {
+            cif,
+            arg_type_list,
+            result_size,
+            code: CodePtr::from_ptr(function_ref.get_pointer(0).cast::<c_void>()),
+        })
+    }
+
+    pub unsafe fn call(&self, result: &Ref<dyn NativeData>, args: LuaMultiValue) -> LuaResult<()> {
+        result
+            .check_boundary(0, self.result_size)
+            .then_some(())
+            .ok_or_else(|| LuaError::external("result boundary check failed"))
+    }
+    // pub fn new_from_lua_table(lua: &Lua, args: LuaTable, ret: LuaAnyUserData) -> LuaResult<Self> {
+    //     let args_types = libffi_type_list_from_table(lua, &args)?;
+    //     let ret_type = libffi_type_from_userdata(lua, &ret)?;
+
+    //     Ok(Self::new(
+    //         args_types,
+    //         ret_type,
+    //         unsafe { get_conv_list_from_table(&args)? },
+    //         unsafe { get_conv(&ret)? },
+    //     ))
+    // }
+    // pub fn call() {
+
+    // }
+}
+
+impl LuaUserData for FfiCallable {
+    fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
+        methods.add_method(
+            "call",
+            |_lua, this: &FfiCallable, mut args: LuaMultiValue| {
+                let LuaValue::UserData(result) = args.pop_front().ok_or_else(|| {
+                    LuaError::external("first argument must be result data handle")
+                })?
+                else {
+                    return Err(LuaError::external(""));
+                };
+                let call_result = unsafe { this.call(&result.get_data_handle()?, args) };
+                call_result
+            },
+        )
+    }
+}

crates/lune-std-ffi/src/ffi/ffi_closure.rs

@@ -0,0 +1,106 @@
+use core::ffi::c_void;
+use std::ptr;
+
+use libffi::{
+    low::{closure_alloc, closure_free, ffi_cif, CodePtr},
+    raw::{ffi_closure, ffi_prep_closure_loc},
+};
+use mlua::prelude::*;
+
+use super::{
+    ffi_ref::{FfiRefBounds, FfiRefFlag},
+    FfiRef, FFI_STATUS_NAMES,
+};
+
+pub struct FfiClosure<'a> {
+    closure: *mut ffi_closure,
+    code: CodePtr,
+    userdata: CallbackUserdata<'a>,
+}
+
+impl<'a> Drop for FfiClosure<'a> {
+    fn drop(&mut self) {
+        unsafe {
+            closure_free(self.closure);
+        }
+    }
+}
+
+#[allow(unused)]
+pub struct CallbackUserdata<'a> {
+    pub func: LuaFunction<'a>,
+    pub lua: &'a Lua,
+    pub arg_ref_flags: Vec<u8>,
+    pub arg_ref_size: Vec<usize>,
+    pub result_size: usize,
+}
+
+const RESULT_REF_FLAGS: u8 = FfiRefFlag::Leaked.value() | FfiRefFlag::Writable.value();
+
+unsafe extern "C" fn callback(
+    cif: *mut ffi_cif,
+    result_pointer: *mut c_void,
+    arg_pointers: *mut *mut c_void,
+    userdata: *mut c_void,
+) {
+    let userdata = userdata.cast::<CallbackUserdata>();
+    let len = (*cif).nargs as usize;
+    let mut args = Vec::<LuaValue>::with_capacity(len + 1);
+
+    // Push result pointer (ref)
+    args.push(LuaValue::UserData(
+        (*userdata)
+            .lua
+            .create_userdata(FfiRef::new(
+                result_pointer.cast::<()>(),
+                RESULT_REF_FLAGS,
+                FfiRefBounds::new(0, (*userdata).result_size),
+            ))
+            .unwrap(),
+    ));
+
+    // Push arg pointer (ref)
+    for i in 0..len {
+        args.push(LuaValue::UserData(
+            (*userdata)
+                .lua
+                .create_userdata(FfiRef::new(
+                    (*arg_pointers.add(i)).cast::<()>(),
+                    (*userdata).arg_ref_flags.get(i).unwrap().to_owned(),
+                    FfiRefBounds::new(0, (*userdata).arg_ref_size.get(i).unwrap().to_owned()),
+                ))
+                .unwrap(),
+        ));
+    }
+
+    (*userdata).func.call::<_, ()>(args).unwrap();
+}
+
+impl<'a> FfiClosure<'a> {
+    pub unsafe fn new(
+        cif: *mut ffi_cif,
+        userdata: CallbackUserdata<'a>,
+    ) -> LuaResult<FfiClosure<'a>> {
+        let (closure, code) = closure_alloc();
+        let prep_result = ffi_prep_closure_loc(
+            closure,
+            cif,
+            Some(callback),
+            ptr::from_ref(&userdata).cast::<c_void>().cast_mut(),
+            code.as_mut_ptr(),
+        );
+
+        if prep_result != 0 {
+            Err(LuaError::external(format!(
+                "ffi_get_struct_offsets failed. expected result {}, got {}",
+                FFI_STATUS_NAMES[0], FFI_STATUS_NAMES[prep_result as usize]
+            )))
+        } else {
+            Ok(FfiClosure {
+                closure,
+                code,
+                userdata,
+            })
+        }
+    }
+}

crates/lune-std-ffi/src/ffi/ffi_native/arg.rs

@@ -0,0 +1,15 @@
+use super::NativeConvert;
+
+pub struct FfiArgRefOption {
+    pub flag: u8,
+}
+
+pub enum NativeArgType {
+    FfiBox,
+    FfiRef(FfiArgRefOption),
+}
+
+pub struct NativeArgInfo {
+    pub conv: *const dyn NativeConvert,
+    pub kind: NativeArgType,
+}

crates/lune-std-ffi/src/ffi/ffi_native/convert.rs

@@ -4,10 +4,13 @@ use std::cell::Ref;
 
 use mlua::prelude::*;
 
-use super::NativeData;
+use super::{NativeData, NativeSize};
 
 // Handle native data, provide type conversion between luavalue and native types
-pub trait NativeConvert {
+pub trait NativeConvert
+where
+    Self: NativeSize,
+{
     // Convert luavalue into data, then write into ptr
     unsafe fn luavalue_into<'lua>(
         &self,