Implement carr, cstruct, ctype and cptr (#243)

Author: qwreey

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

@@ -1,7 +1,11 @@
 use libffi::middle::Type;
 use mlua::prelude::*;
 
-use crate::ctype::libffi_type_ensured_size;
+use crate::association::{get_association, set_association};
+use crate::cptr::CPtr;
+use crate::ctype::{
+    libffi_type_ensured_size, libffi_type_from_userdata, type_userdata_stringify, CType,
+};
 
 // This is a series of some type.
 // It provides the final size and the offset of the index,
@@ -14,7 +18,9 @@ use crate::ctype::libffi_type_ensured_size;
 // Padding after each field inside the struct is set to next field can follow the alignment.
 // There is no problem even if you create a struct with n fields of a single type within the struct. Array adheres to the condition that there is no additional padding between each element. Padding to a struct is padding inside the struct. Simply think of the padding byte as a trailing unnamed field.
 
-struct CArr {
+const CARR_INNER: &str = "__carr_inner";
+
+pub struct CArr {
     libffi_type: Type,
     struct_type: Type,
     length: usize,
@@ -23,7 +29,7 @@ struct CArr {
 }
 
 impl CArr {
-    fn new(libffi_type: Type, length: usize) -> LuaResult<Self> {
+    pub fn new(libffi_type: Type, length: usize) -> LuaResult<Self> {
         let struct_type = Type::structure(vec![libffi_type.clone(); length]);
         let field_size = libffi_type_ensured_size(libffi_type.as_raw_ptr())?;
 
@@ -35,6 +41,70 @@ impl CArr {
             size: field_size * length,
         })
     }
+
+    pub fn from_lua_userdata<'lua>(
+        lua: &'lua Lua,
+        luatype: &LuaAnyUserData<'lua>,
+        length: usize,
+    ) -> LuaResult<LuaAnyUserData<'lua>> {
+        let fields = libffi_type_from_userdata(luatype)?;
+        let carr = lua.create_userdata(Self::new(fields, length)?)?;
+
+        set_association(lua, CARR_INNER, carr.clone(), luatype)?;
+        Ok(carr)
+    }
+
+    pub fn get_type(&self) -> Type {
+        self.libffi_type.clone()
+    }
+
+    // Stringify cstruct for pretty printing something like:
+    // <CStruct( u8, i32, size = 8 )>
+    pub fn stringify(userdata: &LuaAnyUserData) -> LuaResult<String> {
+        let inner: LuaValue = userdata.get("inner")?;
+        let carr = userdata.borrow::<CArr>()?;
+        if inner.is_userdata() {
+            let inner = inner
+                .as_userdata()
+                .ok_or(LuaError::external("failed to get inner type userdata."))?;
+            Ok(format!(
+                " {} ; {} ",
+                type_userdata_stringify(inner)?,
+                carr.length
+            ))
+        } else {
+            Err(LuaError::external("failed to get inner type userdata."))
+        }
+    }
 }
 
-impl LuaUserData for CArr {}
+impl LuaUserData for CArr {
+    fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) {
+        fields.add_field_method_get("size", |_, this| Ok(this.size));
+        fields.add_field_method_get("length", |_, this| Ok(this.length));
+        fields.add_field_function_get("inner", |lua, this: LuaAnyUserData| {
+            let inner: LuaValue = get_association(lua, CARR_INNER, this)?
+                // It shouldn't happen.
+                .ok_or(LuaError::external("inner field not found"))?;
+            Ok(inner)
+        });
+    }
+
+    fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
+        methods.add_method("offset", |_, this, offset: isize| {
+            if this.length > (offset as usize) && offset >= 0 {
+                Ok(this.field_size * (offset as usize))
+            } else {
+                Err(LuaError::external("Out of index"))
+            }
+        });
+        methods.add_function("ptr", |lua, this: LuaAnyUserData| {
+            let pointer = CPtr::from_lua_userdata(lua, &this)?;
+            Ok(pointer)
+        });
+        methods.add_meta_function(LuaMetaMethod::ToString, |_, this: LuaAnyUserData| {
+            let result = CArr::stringify(&this)?;
+            Ok(result)
+        });
+    }
+}

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

@@ -0,0 +1,78 @@
+#![allow(clippy::cargo_common_metadata)]
+
+use std::borrow::Borrow;
+
+use libffi::middle::Type;
+use mlua::prelude::*;
+
+use crate::association::{get_association, set_association};
+use crate::carr::CArr;
+use crate::ctype::{type_name_from_userdata, type_userdata_stringify};
+
+const POINTER_INNER: &str = "__pointer_inner";
+
+pub struct CPtr();
+
+impl CPtr {
+    // Create pointer type with '.inner' field
+    // inner can be CArr, CType or CStruct
+    pub fn from_lua_userdata<'lua>(
+        lua: &'lua Lua,
+        inner: &LuaAnyUserData,
+    ) -> LuaResult<LuaValue<'lua>> {
+        let value = Self().into_lua(lua)?;
+
+        set_association(lua, POINTER_INNER, value.borrow(), inner)?;
+
+        Ok(value)
+    }
+
+    // Stringify CPtr with inner ctype
+    pub fn stringify(userdata: &LuaAnyUserData) -> LuaResult<String> {
+        let inner: LuaValue = userdata.get("inner")?;
+
+        if inner.is_userdata() {
+            let inner = inner
+                .as_userdata()
+                .ok_or(LuaError::external("failed to get inner type userdata."))?;
+            Ok(format!(
+                " <{}({})> ",
+                type_name_from_userdata(inner),
+                type_userdata_stringify(inner)?,
+            ))
+        } else {
+            Err(LuaError::external("failed to get inner type userdata."))
+        }
+    }
+
+    // Return void*
+    pub fn get_type() -> Type {
+        Type::pointer()
+    }
+}
+
+impl LuaUserData for CPtr {
+    fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) {
+        fields.add_field_method_get("size", |_, _| Ok(size_of::<usize>()));
+        fields.add_field_function_get("inner", |lua, this| {
+            let inner = get_association(lua, POINTER_INNER, this)?
+                .ok_or(LuaError::external("inner type not found"))?;
+            Ok(inner)
+        });
+    }
+
+    fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
+        methods.add_function("ptr", |lua, this: LuaAnyUserData| {
+            let pointer = CPtr::from_lua_userdata(lua, &this)?;
+            Ok(pointer)
+        });
+        methods.add_function("arr", |lua, (this, length): (LuaAnyUserData, usize)| {
+            let carr = CArr::from_lua_userdata(lua, &this, length)?;
+            Ok(carr)
+        });
+        methods.add_meta_function(LuaMetaMethod::ToString, |_, this: LuaAnyUserData| {
+            let name: Result<String, LuaError> = CPtr::stringify(&this);
+            Ok(name)
+        });
+    }
+}

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

@@ -9,9 +9,13 @@ use libffi::{
 };
 use mlua::prelude::*;
 
-use crate::association::{get_association, set_association};
-use crate::ctype::{libffi_types_from_table, type_name_from_userdata, CType};
+use crate::ctype::{libffi_types_from_table, type_userdata_stringify, CType};
 use crate::FFI_STATUS_NAMES;
+use crate::{
+    association::{get_association, set_association},
+    ctype::type_name_from_userdata,
+};
+use crate::{carr::CArr, cptr::CPtr};
 
 pub struct CStruct {
     libffi_cif: Cif,
@@ -78,20 +82,30 @@ impl CStruct {
         if field.is_table() {
             let table = field
                 .as_table()
-                .ok_or(LuaError::external("failed to get inner table."))?;
-
+                .ok_or(LuaError::external("failed to get inner type table."))?;
             // iterate for field
             let mut result = String::from(" ");
             for i in 0..table.raw_len() {
                 let child: LuaAnyUserData = table.raw_get(i + 1)?;
-                result.push_str(format!("{}, ", type_name_from_userdata(&child)?).as_str());
+                if child.is::<CType>() {
+                    result.push_str(format!("{}, ", type_userdata_stringify(&child)?).as_str());
+                } else {
+                    result.push_str(
+                        format!(
+                            "<{}({})>, ",
+                            type_name_from_userdata(&child),
+                            type_userdata_stringify(&child)?
+                        )
+                        .as_str(),
+                    );
+                }
             }
 
             // size of
             result.push_str(format!("size = {} ", userdata.borrow::<CStruct>()?.size).as_str());
             Ok(result)
         } else {
-            Ok(String::from("unnamed"))
+            Err(LuaError::external("failed to get inner type table."))
         }
     }
 
@@ -124,15 +138,20 @@ impl LuaUserData for CStruct {
             Ok(table)
         });
     }
+
     fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
         methods.add_method("offset", |_, this, index: usize| {
             let offset = this.offset(index)?;
             Ok(offset)
         });
         methods.add_function("ptr", |lua, this: LuaAnyUserData| {
-            let pointer = CType::pointer(lua, &this)?;
+            let pointer = CPtr::from_lua_userdata(lua, &this)?;
             Ok(pointer)
         });
+        methods.add_function("arr", |lua, (this, length): (LuaAnyUserData, usize)| {
+            let carr = CArr::from_lua_userdata(lua, &this, length)?;
+            Ok(carr)
+        });
         methods.add_meta_function(LuaMetaMethod::ToString, |_, this: LuaAnyUserData| {
             let result = CStruct::stringify(&this)?;
             Ok(result)