Implement call (#243)

Author: qwreey

.gitignore

@@ -22,6 +22,11 @@ luneDocs.json
 luneTypes.d.luau
 
 # Files generated by runtime or build scripts
+
 scripts/brick_color.rs
 scripts/font_enum_map.rs
 scripts/physical_properties_enum_map.rs
+
+# Files generated by tests
+
+/tests/ffi/**/*.so

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

@@ -5,13 +5,14 @@ use mlua::prelude::*;
 
 use super::{
     association_names::CARR_INNER,
-    c_helper::{get_conv, get_ensured_size, libffi_type_from_userdata, pretty_format_userdata},
+    c_helper::{get_conv, libffi_type_from_userdata, pretty_format_userdata},
     CPtr,
 };
 use crate::ffi::{
     ffi_association::{get_association, set_association},
     FfiBox, GetNativeData, NativeConvert, NativeData, NativeSize,
 };
+use crate::libffi_helper::get_ensured_size;
 
 // This is a series of some type.
 // It provides the final size and the offset of the index,

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

@@ -1,20 +1,17 @@
 use std::ptr;
 
-use libffi::low::ffi_cif;
 use libffi::middle::{Cif, Type};
 use mlua::prelude::*;
 
+use super::c_helper::{get_size, get_userdata};
 use super::{
     association_names::{CALLABLE_CFN, CALLABLE_REF, CFN_ARGS, CFN_RESULT},
-    c_helper::{
-        get_conv, get_conv_list_from_table, libffi_type_from_userdata, libffi_type_list_from_table,
-    },
+    c_helper::{get_conv, libffi_type_from_userdata, libffi_type_list_from_table},
 };
-use crate::ffi::bit_mask::u8_test_not;
 use crate::ffi::{
-    ffi_association::set_association, FfiClosure, NativeArgInfo, NativeConvert, NativeResultInfo,
+    bit_mask::u8_test_not, ffi_association::set_association, FfiCallable, FfiRef, FfiRefFlag,
+    NativeArgInfo, NativeData, NativeResultInfo,
 };
-use crate::ffi::{FfiCallable, FfiRef, FfiRefFlag, NativeData};
 
 // cfn is a type declaration for a function.
 // Basically, when calling an external function, this type declaration
@@ -33,7 +30,7 @@ use crate::ffi::{FfiCallable, FfiRef, FfiRefFlag, NativeData};
 // moved to a Lua function or vice versa.
 
 pub struct CFn {
-    cif: *mut ffi_cif,
+    cif: Cif,
     arg_info_list: Vec<NativeArgInfo>,
     result_info: NativeResultInfo,
 }
@@ -46,37 +43,44 @@ impl CFn {
         ret: Type,
         arg_info_list: Vec<NativeArgInfo>,
         result_info: NativeResultInfo,
-    ) -> Self {
-        Self {
-            cif: Cif::new(args.clone(), ret.clone()).as_raw_ptr(),
+    ) -> LuaResult<Self> {
+        // let cif = ;
+
+        Ok(Self {
+            cif: Cif::new(args.clone(), ret.clone()),
             arg_info_list,
             result_info,
-        }
+        })
     }
 
     pub fn new_from_lua_table<'lua>(
         lua: &'lua Lua,
-        args: LuaTable,
+        arg_table: LuaTable,
         ret: LuaAnyUserData,
     ) -> LuaResult<LuaAnyUserData<'lua>> {
-        let args_types = libffi_type_list_from_table(lua, &args)?;
+        let args_types = libffi_type_list_from_table(lua, &arg_table)?;
         let ret_type = libffi_type_from_userdata(lua, &ret)?;
 
-        let mut arg_info_list = Vec::<NativeArgInfo>::with_capacity(args.raw_len());
-        for conv in unsafe { get_conv_list_from_table(&args)? } {
-            arg_info_list.push(NativeArgInfo { conv })
+        let arg_len = arg_table.raw_len();
+        let mut arg_info_list = Vec::<NativeArgInfo>::with_capacity(arg_len);
+        for index in 0..arg_len {
+            let userdata = get_userdata(arg_table.raw_get(index + 1)?)?;
+            arg_info_list.push(NativeArgInfo {
+                conv: unsafe { get_conv(&userdata)? },
+                size: get_size(&userdata)?,
+            });
         }
-
         let result_info = NativeResultInfo {
             conv: unsafe { get_conv(&ret)? },
+            size: get_size(&ret)?,
         };
 
         let cfn =
-            lua.create_userdata(Self::new(args_types, ret_type, arg_info_list, result_info))?;
+            lua.create_userdata(Self::new(args_types, ret_type, arg_info_list, result_info)?)?;
 
         // Create association to hold argument and result type
-        set_association(lua, CFN_ARGS, &cfn, args)?;
-        set_association(lua, CFN_ARGS, &cfn, ret)?;
+        set_association(lua, CFN_ARGS, &cfn, arg_table)?;
+        set_association(lua, CFN_RESULT, &cfn, ret)?;
 
         Ok(cfn)
     }
@@ -88,22 +92,22 @@ impl LuaUserData for CFn {
         //     lua.create_userdata(FfiClosure::new(this.cif, userdata))
         // })
         methods.add_function(
-            "func",
+            "caller",
             |lua, (cfn, function_ref): (LuaAnyUserData, LuaAnyUserData)| {
                 let this = cfn.borrow::<CFn>()?;
 
                 if !function_ref.is::<FfiRef>() {
-                    return Err(LuaError::external(""));
+                    return Err(LuaError::external("argument 0 must be ffiref"));
                 }
 
                 let ffi_ref = function_ref.borrow::<FfiRef>()?;
                 if u8_test_not(ffi_ref.flags, FfiRefFlag::Function.value()) {
-                    return Err(LuaError::external(""));
+                    return Err(LuaError::external("not a function ref"));
                 }
 
                 let callable = lua.create_userdata(unsafe {
                     FfiCallable::new(
-                        this.cif,
+                        this.cif.as_raw_ptr(),
                         ptr::from_ref(&this.arg_info_list),
                         ptr::from_ref(&this.result_info),
                         ffi_ref.get_pointer(0),

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

@@ -1,17 +1,26 @@
 #![allow(clippy::inline_always)]
 
-use std::ptr::{self, null_mut};
-
-use libffi::{low, middle::Type, raw};
+use libffi::middle::Type;
 use lune_utils::fmt::{pretty_format_value, ValueFormatConfig};
 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, NativeSignedness, NativeSize, FFI_STATUS_NAMES,
+    association_names::CTYPE_STATIC,
+    types::{get_ctype_conv, get_ctype_size},
+    CArr, CPtr, CStruct, CTypeStatic,
 };
+use crate::ffi::{ffi_association::get_association, NativeConvert, NativeSize};
+
+pub fn get_userdata(value: LuaValue) -> LuaResult<LuaAnyUserData> {
+    if let LuaValue::UserData(field_type) = value {
+        Ok(field_type)
+    } else {
+        Err(LuaError::external(format!(
+            "Unexpected field. CStruct, CType or CArr is required for element but got {}",
+            pretty_format_value(&value, &ValueFormatConfig::new())
+        )))
+    }
+}
 
 // Get the NativeConvert handle from the type UserData
 // this is intended to avoid lookup userdata and lua table every time. (eg: struct)
@@ -33,30 +42,21 @@ pub unsafe fn get_conv_list_from_table(
 
     for i in 0..len {
         let value: LuaValue = table.raw_get(i + 1)?;
-
-        if let LuaValue::UserData(field_type) = value {
-            conv_list.push(get_conv(&field_type)?);
-        } else {
-            return Err(LuaError::external(format!(
-                "Unexpected field. CStruct, CType or CArr is required for element but got {}",
-                pretty_format_value(&value, &ValueFormatConfig::new())
-            )));
-        }
+        conv_list.push(get_conv(&get_userdata(value)?)?);
     }
 
     Ok(conv_list)
 }
 
-// #[inline(always)]
-// pub fn type_size_from_userdata(this: &LuaAnyUserData) -> LuaResult<usize> {
-//     if this.is::<CStruct>() {
-//         Ok(this.borrow::<CStruct>()?.get_size())
-//     } else if this.is::<CArr>() {
-//         Ok(this.borrow::<CArr>()?.get_size())
-//     } else {
-//         ctype_size_from_userdata(this)
-//     }
-// }
+pub fn get_size(this: &LuaAnyUserData) -> LuaResult<usize> {
+    if this.is::<CStruct>() {
+        Ok(this.borrow::<CStruct>()?.get_size())
+    } else if this.is::<CArr>() {
+        Ok(this.borrow::<CArr>()?.get_size())
+    } else {
+        get_ctype_size(this)
+    }
+}
 
 // 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>> {
@@ -162,26 +162,3 @@ pub fn pretty_format_userdata(lua: &Lua, userdata: &LuaAnyUserData) -> LuaResult
         ))
     }
 }
-
-// Ensure sizeof c-type (raw::libffi_type)
-// See: http://www.chiark.greenend.org.uk/doc/libffi-dev/html/Size-and-Alignment.html
-pub fn get_ensured_size(ffi_type: *mut raw::ffi_type) -> LuaResult<usize> {
-    let mut cif = low::ffi_cif::default();
-    let result = unsafe {
-        raw::ffi_prep_cif(
-            ptr::from_mut(&mut cif),
-            raw::ffi_abi_FFI_DEFAULT_ABI,
-            0,
-            ffi_type,
-            null_mut(),
-        )
-    };
-
-    if result != raw::ffi_status_FFI_OK {
-        return Err(LuaError::external(format!(
-            "ffi_get_struct_offsets failed. expected result {}, got {}",
-            FFI_STATUS_NAMES[0], FFI_STATUS_NAMES[result as usize]
-        )));
-    }
-    unsafe { Ok((*ffi_type).size) }
-}

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

@@ -4,3 +4,5 @@
 // but separated it for clarity.
 // This also allows operations such as ffi.string:intoBox().
 // (Write a string to an already existing box)
+
+// FIXME: use buffer instead?

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

@@ -7,11 +7,12 @@ use lune_utils::fmt::{pretty_format_value, ValueFormatConfig};
 use mlua::prelude::*;
 use num::cast::AsPrimitive;
 
-use super::{association_names::CTYPE_STATIC, c_helper::get_ensured_size, CArr, CPtr};
+use super::{association_names::CTYPE_STATIC, CArr, CPtr};
 use crate::ffi::{
     ffi_association::set_association, native_num_cast, FfiBox, GetNativeData, NativeConvert,
     NativeData, NativeSignedness, NativeSize,
 };
+use crate::libffi_helper::get_ensured_size;
 
 // We can't get a CType<T> through mlua, something like
 // .is::<CType<dyn Any>> will fail.
@@ -106,11 +107,9 @@ where
         libffi_type: Type,
         name: Option<&'static str>,
     ) -> LuaResult<LuaAnyUserData<'lua>> {
-        // let libffi_cfi = Cif::new(vec![libffi_type.clone()], Type::void());
         let size = get_ensured_size(libffi_type.as_raw_ptr())?;
 
         let ctype = Self {
-            // libffi_cif: libffi_cfi,
             libffi_type,
             size,
             name,

crates/lune-std-ffi/src/c/types/mod.rs

@@ -8,7 +8,7 @@ use mlua::prelude::*;
 use num::cast::AsPrimitive;
 
 use super::{CType, CTypeCast};
-use crate::ffi::{NativeConvert, NativeData};
+use crate::ffi::{NativeConvert, NativeData, NativeSize};
 
 pub mod f32;
 pub mod f64;
@@ -145,3 +145,18 @@ macro_rules! define_get_ctype_conv {
 pub unsafe fn get_ctype_conv(userdata: &LuaAnyUserData) -> LuaResult<*const dyn NativeConvert> {
     define_get_ctype_conv!(userdata, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64)
 }
+
+macro_rules! define_get_ctype_size {
+    ($userdata:ident, $f:ty, $( $c:ty ),*) => {
+        if $userdata.is::<CType<$f>>() {
+            Ok($userdata.borrow::<CType<$f>>()?.get_size())
+        }$( else if $userdata.is::<CType<$c>>() {
+            Ok($userdata.borrow::<CType<$c>>()?.get_size())
+        })* else {
+            Err(LuaError::external("Unexpected type"))
+        }
+    };
+}
+pub fn get_ctype_size(userdata: &LuaAnyUserData) -> LuaResult<usize> {
+    define_get_ctype_size!(userdata, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128, f32, f64)
+}

crates/lune-std-ffi/src/ffi/ffi_box/mod.rs

@@ -128,7 +128,7 @@ impl NativeData for FfiBox {
         if offset < 0 {
             return false;
         }
-        self.size() > ((offset as usize) + size)
+        self.size() - (offset as usize) >= size
     }
     unsafe fn get_pointer(&self, offset: isize) -> *mut () {
         self.data