Adding metaclass

RustPython · rodrigocam · Aug 7, 2021 · Oct 29, 2020 · Oct 31, 2020 · Oct 31, 2020
commit d7888f9202cf1cdb0177d12bc555a694ea9998c8
diff --git a/vm/src/stdlib/ctypes/basics.rs b/vm/src/stdlib/ctypes/basics.rs
@@ -1,28 +1,83 @@
 use crate::builtins::PyTypeRef;
-use crate::pyobject::{PyRef, PyResult, PyValue, StaticType};
+use crate::pyobject::{PyObjectRc, PyRef, PyResult, PyValue, StaticType};
 use crate::VirtualMachine;
 
+use crate::stdlib::ctypes::common::PyCData_as_buffer;
+
 // This class is the equivalent of PyCData_Type on tp_base for
-// PyCStructType_Type, UnionType_Type, PyCPointerType_Type
-// PyCArrayType_Type, PyCSimpleType_Type, PyCFuncPtrType_Type
+// Struct_Type, Union_Type, PyCPointer_Type
+// PyCArray_Type, PyCSimple_Type, PyCFuncPtr_Type
+
 #[pyclass(module = false, name = "_CData")]
 #[derive(Debug)]
-pub struct PyCData {}
+pub struct PyCData {
+    _objects: Vec<PyObjectRc>,
+}
 
 impl PyValue for PyCData {
     fn class(_vm: &VirtualMachine) -> &PyTypeRef {
-        Self::static_baseclass()
+        Self::init_bare_type()
     }
 }
 
-#[pyimpl(flags(BASETYPE))]
+#[pyimpl]
 impl PyCData {
+    // Methods here represent PyCData_methods
+
+    #[pymethod]
+    pub fn __ctypes_from_outparam__() {}
+
+    #[pymethod]
+    pub fn __reduce__() {}
+
+    #[pymethod]
+    pub fn __setstate__() {}
+}
+
+// #[pyimpl]
+// impl PyCData_as_buffer for PyCData {
+
+// }
+
+// This class has no attributes and we care about it's methods
+#[pyclass(module = false, name = "_CDataMeta")]
+#[derive(Debug)]
+pub struct PyCDataMeta;
+
+impl PyValue for PyCDataMeta {
+    fn class(_vm: &VirtualMachine) -> &PyTypeRef {
+        Self::static_baseclass()
+    }
+}
+
+#[pyimpl]
+impl PyCDataMeta {
     // A lot of the logic goes in this trait
     // There's also other traits that should have different implementations for some functions
     // present here
 
-    // #[pyslot]
-    // fn tp_new(cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-    //     PyCData {}.into_ref_with_type(vm, cls)
-    // }
+    // The default methods (representing CDataType_methods) here are for:
+    // StructType_Type
+    // UnionType_Type
+    // PyCArrayType_Type
+    // PyCFuncPtrType_Type
+
+    #[pymethod]
+    pub fn from_param() {}
+
+    #[pymethod]
+    pub fn from_address() {}
+
+    #[pymethod]
+    pub fn from_buffer() {}
+
+    #[pymethod]
+    pub fn from_buffer_copy() {}
+
+    #[pymethod]
+    pub fn in_dll() {}
 }
+
+// CDataType_as_sequence methods are default for all types inherinting from PyCDataMeta
+// Basically the sq_repeat slot is CDataType_repeat
+// which transforms into a Array
diff --git a/vm/src/stdlib/ctypes/common.rs b/vm/src/stdlib/ctypes/common.rs
@@ -2,273 +2,22 @@ extern crate lazy_static;
 extern crate libffi;
 extern crate libloading;
 
-use ::std::{collections::HashMap, os::raw::*, ptr};
+use ::std::{collections::HashMap, os::raw::c_void};
 
-use libffi::low::{
-    call as ffi_call, ffi_abi_FFI_DEFAULT_ABI as ABI, ffi_cif, ffi_type, prep_cif, CodePtr,
-    Error as FFIError,
-};
-use libffi::middle;
 use libloading::Library;
-use num_bigint::BigInt;
 
 use crate::builtins::PyTypeRef;
 use crate::common::lock::PyRwLock;
-use crate::pyobject::{PyObjectRc, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject};
+use crate::pyobject::{PyRef, PyValue};
+use crate::slots::BufferProtocol;
 use crate::VirtualMachine;
 
-macro_rules! ffi_type {
-    ($name: ident) => {
-        middle::Type::$name().as_raw_ptr()
-    };
+// This trait will be used by all types
+pub trait PyCData_as_buffer: BufferProtocol {
+    // @TODO: Translate PyCData_NewGetBuffer
+    // fn get_buffer(zelf: &PyRef<Self>, vm: &VirtualMachine) -> PyResult<Box<dyn Buffer>>;
 }
 
-macro_rules! match_ffi_type {
-    (
-        $pointer: expr,
-
-        $(
-            $($type: ident)|+ => $body: expr
-        )+
-    ) => {
-        match $pointer {
-            $(
-                $(
-                    t if t == ffi_type!($type) => { $body }
-                )+
-            )+
-            _ => unreachable!()
-        }
-    };
-    (
-        $kind: expr,
-
-        $(
-            $($type: tt)|+ => $body: ident
-        )+
-    ) => {
-        match $kind {
-            $(
-                $(
-                    t if t == $type => { ffi_type!($body) }
-                )+
-            )+
-            _ => unreachable!()
-        }
-    }
-}
-
-pub fn str_to_type(ty: &str) -> *mut ffi_type {
-    match_ffi_type!(
-        ty,
-        "c" => c_schar
-        "u" => c_int
-        "b" => i8
-        "h" => c_short
-        "H" => c_ushort
-        "i" => c_int
-        "I" => c_uint
-        "l" => c_long
-        "q" => c_longlong
-        "L" => c_ulong
-        "Q" => c_ulonglong
-        "f" => f32
-        "d" => f64
-        "g" => longdouble
-        "?" | "B" => c_uchar
-        "z" | "Z" => pointer
-        "P" => void
-    )
-}
-
-fn py_to_ffi(ty: *mut *mut ffi_type, obj: PyObjectRef, vm: &VirtualMachine) -> *mut c_void {
-    match_ffi_type!(
-        unsafe { *ty },
-        c_schar => {
-            let mut r = i8::try_from_object(vm, obj).unwrap();
-            &mut r as *mut _ as *mut c_void
-        }
-        c_int => {
-            let mut r = i32::try_from_object(vm, obj).unwrap();
-            &mut r as *mut _ as *mut c_void
-        }
-        c_short => {
-            let mut r = i16::try_from_object(vm, obj).unwrap();
-            &mut r as *mut _ as *mut c_void
-        }
-        c_ushort => {
-            let mut r = u16::try_from_object(vm, obj).unwrap();
-            &mut r as *mut _ as *mut c_void
-        }
-        c_uint => {
-            let mut r = u32::try_from_object(vm, obj).unwrap();
-            &mut r as *mut _ as *mut c_void
-        }
-        //@ TODO: Convert c*longlong from BigInt?
-        c_long | c_longlong => {
-            let mut r = i64::try_from_object(vm, obj).unwrap();
-            &mut r as *mut _ as *mut c_void
-        }
-        c_ulong | c_ulonglong => {
-            let mut r = u64::try_from_object(vm, obj).unwrap();
-            &mut r as *mut _ as *mut c_void
-        }
-        f32 => {
-            let mut r = f32::try_from_object(vm, obj).unwrap();
-            &mut r as *mut _ as *mut c_void
-        }
-        f64 | longdouble=> {
-            let mut r = f64::try_from_object(vm, obj).unwrap();
-            &mut r as *mut _ as *mut c_void
-        }
-        c_uchar => {
-            let mut r = u8::try_from_object(vm, obj).unwrap();
-            &mut r as *mut _ as *mut c_void
-        }
-        pointer => {
-            usize::try_from_object(vm, obj).unwrap() as *mut c_void
-        }
-        void => {
-            ptr::null_mut()
-        }
-    )
-}
-
-#[derive(Debug)]
-pub struct Function {
-    pointer: *const c_void,
-    cif: ffi_cif,
-    arguments: Vec<*mut ffi_type>,
-    return_type: Box<*mut ffi_type>,
-}
-
-impl Function {
-    pub fn new(fn_ptr: *const c_void, arguments: Vec<String>, return_type: &str) -> Function {
-        Function {
-            pointer: fn_ptr,
-            cif: Default::default(),
-            arguments: arguments.iter().map(|s| str_to_type(s.as_str())).collect(),
-
-            return_type: Box::new(str_to_type(return_type)),
-        }
-    }
-    pub fn set_args(&mut self, args: Vec<String>) {
-        self.arguments.clear();
-        self.arguments
-            .extend(args.iter().map(|s| str_to_type(s.as_str())));
-    }
-
-    pub fn set_ret(&mut self, ret: &str) {
-        (*self.return_type.as_mut()) = str_to_type(ret);
-        // mem::replace(self.return_type.as_mut(), str_to_type(ret));
-    }
-
-    pub fn call(
-        &mut self,
-        arg_ptrs: Vec<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyObjectRc> {
-        let return_type: *mut ffi_type = &mut unsafe { self.return_type.read() };
-
-        let result = unsafe {
-            prep_cif(
-                &mut self.cif,
-                ABI,
-                self.arguments.len(),
-                return_type,
-                self.arguments.as_mut_ptr(),
-            )
-        };
-
-        if let Err(FFIError::Typedef) = result {
-            return Err(vm.new_runtime_error(
-                "The type representation is invalid or unsupported".to_string(),
-            ));
-        } else if let Err(FFIError::Abi) = result {
-            return Err(vm.new_runtime_error("The ABI is invalid or unsupported".to_string()));
-        }
-
-        let mut argument_pointers: Vec<*mut c_void> = arg_ptrs
-            .iter()
-            .zip(self.arguments.iter_mut())
-            .map(|(o, t)| {
-                let tt: *mut *mut ffi_type = t;
-                py_to_ffi(tt, o.clone(), vm)
-            })
-            .collect();
-
-        let cif_ptr = &self.cif as *const _ as *mut _;
-        let fun_ptr = CodePtr::from_ptr(self.pointer);
-        let args_ptr = argument_pointers.as_mut_ptr();
-
-        let ret_ptr = unsafe {
-            match_ffi_type!(
-                return_type,
-                c_schar => {
-                    let r: c_schar = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as i8)
-                }
-                c_int => {
-                    let r: c_int = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as i32)
-                }
-                c_short => {
-                    let r: c_short = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as i16)
-                }
-                c_ushort => {
-                    let r: c_ushort = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as u16)
-                }
-                c_uint => {
-                    let r: c_uint = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as u32)
-                }
-                c_long => {
-                    let r: c_long = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as i64)
-                }
-                c_longlong => {
-                    let r: c_longlong = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(BigInt::from(r as i128))
-                }
-                c_ulong => {
-                    let r: c_ulong = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as u64)
-                }
-                c_ulonglong => {
-                    let r: c_ulonglong = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(BigInt::from(r as u128))
-                }
-                f32 => {
-                    let r: c_float = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as f32)
-                }
-                f64 | longdouble => {
-                    let r: c_double = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as f64)
-                }
-                c_uchar => {
-                    let r: c_uchar = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as u8)
-                }
-                pointer => {
-                    let r: *mut c_void = ffi_call(cif_ptr, fun_ptr, args_ptr);
-                    vm.new_pyobj(r as *const _ as usize)
-                }
-                void => {
-                    vm.ctx.none()
-                }
-            )
-        };
-
-        Ok(ret_ptr)
-    }
-}
-
-unsafe impl Send for Function {}
-unsafe impl Sync for Function {}
-
 #[derive(Debug)]
 pub struct SharedLibrary {
     path_name: String,