lune-org/lune
1
1
Fork 0
mirror of https://github.com/lune-org/lune.git synced 2025-04-04 10:30:54 +01:00
Code Issues Projects Releases Packages Wiki Activity

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

Browse source
This commit is contained in:
qwreey 2024-08-24 06:33:29 +00:00
parent 8c38aef32d
commit b36948cf1b
No known key found for this signature in database
GPG key ID: D28DB79297A214BD
5 changed files with 230 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

78
crates/lune-std-ffi/src/carr.rs
View file

@ -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)
});
}
}

78
crates/lune-std-ffi/src/cptr.rs Normal file
View file

@ -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)
});
}
}

33
crates/lune-std-ffi/src/cstruct.rs
View file

@ -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)

105
crates/lune-std-ffi/src/ctype.rs
View file

@ -12,6 +12,8 @@ use lune_utils::fmt::{pretty_format_value, ValueFormatConfig};
use mlua::prelude::*;
use crate::association::{get_association, set_association};
use crate::carr::CArr;
use crate::cptr::CPtr;
use crate::cstruct::CStruct;
use crate::FFI_STATUS_NAMES;
// use libffi::raw::{ffi_cif, ffi_ptrarray_to_raw};
@ -26,47 +28,21 @@ pub struct CType {
}
impl CType {
pub fn new(libffi_type: Type, name: Option<String>) -> Self {
pub fn new(libffi_type: Type, name: Option<String>) -> LuaResult<Self> {
let libffi_cfi = Cif::new(vec![libffi_type.clone()], Type::void());
let size = unsafe { (*libffi_type.as_raw_ptr()).size };
Self {
let size = libffi_type_ensured_size(libffi_type.as_raw_ptr())?;
Ok(Self {
libffi_cif: libffi_cfi,
libffi_type,
size,
name,
}
})
}
pub fn get_type(&self) -> Type {
self.libffi_type.clone()
}
pub fn pointer<'lua>(lua: &'lua Lua, inner: &LuaAnyUserData) -> LuaResult<LuaValue<'lua>> {
let value = Self {
libffi_cif: Cif::new(vec![Type::pointer()], Type::void()),
libffi_type: Type::pointer(),
size: size_of::<usize>(),
name: Some(format!(
"Ptr<{}({})>",
{
if inner.is::<CStruct>() {
"CStruct"
} else if inner.is::<CType>() {
"CType"
} else {
"unnamed"
}
},
type_name_from_userdata(inner)?
)),
}
.into_lua(lua)?;
set_association(lua, POINTER_INNER, value.borrow(), inner)?;
Ok(value)
}
pub fn stringify(&self) -> String {
match &self.name {
Some(t) => t.to_owned(),
@ -78,21 +54,17 @@ impl CType {
impl LuaUserData for CType {
fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) {
fields.add_field_method_get("size", |_, this| Ok(this.size));
fields.add_field_function_get("inner", |lua, this| {
let inner = get_association(lua, POINTER_INNER, this)?;
match inner {
Some(t) => Ok(t),
None => Ok(LuaNil),
}
});
}
fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
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_method(LuaMetaMethod::ToString, |_, this, ()| {
let name = this.stringify();
Ok(name)
@ -105,47 +77,47 @@ pub fn create_all_types(lua: &Lua) -> LuaResult<Vec<(&'static str, LuaValue)>> {
Ok(vec![
(
"u8",
CType::new(Type::u8(), Some(String::from("u8"))).into_lua(lua)?,
CType::new(Type::u8(), Some(String::from("u8")))?.into_lua(lua)?,
),
(
"u16",
CType::new(Type::u16(), Some(String::from("u16"))).into_lua(lua)?,
CType::new(Type::u16(), Some(String::from("u16")))?.into_lua(lua)?,
),
(
"u32",
CType::new(Type::u32(), Some(String::from("u32"))).into_lua(lua)?,
CType::new(Type::u32(), Some(String::from("u32")))?.into_lua(lua)?,
),
(
"u64",
CType::new(Type::u64(), Some(String::from("u64"))).into_lua(lua)?,
CType::new(Type::u64(), Some(String::from("u64")))?.into_lua(lua)?,
),
(
"i8",
CType::new(Type::i8(), Some(String::from("i8"))).into_lua(lua)?,
CType::new(Type::i8(), Some(String::from("i8")))?.into_lua(lua)?,
),
(
"i16",
CType::new(Type::i16(), Some(String::from("i16"))).into_lua(lua)?,
CType::new(Type::i16(), Some(String::from("i16")))?.into_lua(lua)?,
),
(
"i32",
CType::new(Type::i32(), Some(String::from("i32"))).into_lua(lua)?,
CType::new(Type::i32(), Some(String::from("i32")))?.into_lua(lua)?,
),
(
"i64",
CType::new(Type::i64(), Some(String::from("i64"))).into_lua(lua)?,
CType::new(Type::i64(), Some(String::from("i64")))?.into_lua(lua)?,
),
(
"f32",
CType::new(Type::f32(), Some(String::from("f32"))).into_lua(lua)?,
CType::new(Type::f32(), Some(String::from("f32")))?.into_lua(lua)?,
),
(
"f64",
CType::new(Type::f64(), Some(String::from("f64"))).into_lua(lua)?,
CType::new(Type::f64(), Some(String::from("f64")))?.into_lua(lua)?,
),
(
"void",
CType::new(Type::void(), Some(String::from("void"))).into_lua(lua)?,
CType::new(Type::void(), Some(String::from("void")))?.into_lua(lua)?,
),
])
}
@ -174,15 +146,19 @@ pub fn libffi_types_from_table(table: &LuaTable) -> LuaResult<Vec<Type>> {
Ok(fields)
}
// get libffi_type from any c-types userdata
// get libffi_type from any c-type userdata
pub fn libffi_type_from_userdata(userdata: &LuaAnyUserData) -> LuaResult<Type> {
if userdata.is::<CStruct>() {
Ok(userdata.borrow::<CStruct>()?.get_type())
} else if userdata.is::<CType>() {
Ok(userdata.borrow::<CType>()?.get_type())
} else if userdata.is::<CArr>() {
Ok(userdata.borrow::<CArr>()?.get_type())
} else if userdata.is::<CPtr>() {
Ok(CPtr::get_type())
} else {
Err(LuaError::external(format!(
"Unexpected field. CStruct, CType or CArr is required for element but got {}",
"Unexpected field. CStruct, CType, CString or CArr is required for element but got {}",
pretty_format_value(
// Since the data is in the Lua location,
// there is no problem with the clone.
@ -193,19 +169,40 @@ pub fn libffi_type_from_userdata(userdata: &LuaAnyUserData) -> LuaResult<Type> {
}
}
// stringify any c-types userdata (for recursive)
pub fn type_name_from_userdata(userdata: &LuaAnyUserData) -> LuaResult<String> {
// stringify any c-type userdata (for recursive)
pub fn type_userdata_stringify(userdata: &LuaAnyUserData) -> LuaResult<String> {
if userdata.is::<CType>() {
let name = userdata.borrow::<CType>()?.stringify();
Ok(name)
} else if userdata.is::<CStruct>() {
let name = CStruct::stringify(userdata)?;
Ok(name)
} else if userdata.is::<CArr>() {
let name = CArr::stringify(userdata)?;
Ok(name)
} else if userdata.is::<CPtr>() {
let name: String = CPtr::stringify(userdata)?;
Ok(name)
} else {
Ok(String::from("unnamed"))
}
}
// get name tag for any c-type userdata
pub fn type_name_from_userdata(userdata: &LuaAnyUserData) -> String {
if userdata.is::<CStruct>() {
String::from("CStruct")
} else if userdata.is::<CType>() {
String::from("CType")
} else if userdata.is::<CArr>() {
String::from("CArr")
} else if userdata.is::<CPtr>() {
String::from("CPtr")
} else {
String::from("unnamed")
}
}
// Ensure sizeof c-type (raw::libffi_type)
// See: http://www.chiark.greenend.org.uk/doc/libffi-dev/html/Size-and-Alignment.html
pub fn libffi_type_ensured_size(ffi_type: *mut raw::ffi_type) -> LuaResult<usize> {

1
crates/lune-std-ffi/src/lib.rs
View file

@ -6,6 +6,7 @@ use mlua::prelude::*;
mod association;
mod carr;
mod cfn;
mod cptr;
mod cstring;
mod cstruct;
mod ctype;