add more classes

arihant2math · arihant2math · commit 1bfe8fb427d1 · 2025-04-10T17:59:17.000-07:00
diff --git a/vm/src/stdlib/ctypes.rs b/vm/src/stdlib/ctypes.rs
@@ -2,11 +2,13 @@
 
 pub(crate) mod array;
 pub(crate) mod base;
+pub(crate) mod field;
 pub(crate) mod function;
 pub(crate) mod library;
 pub(crate) mod pointer;
 pub(crate) mod structure;
 pub(crate) mod union;
+pub(crate) mod util;
 
 use crate::builtins::PyModule;
 use crate::class::PyClassImpl;
diff --git a/vm/src/stdlib/ctypes/field.rs b/vm/src/stdlib/ctypes/field.rs
@@ -0,0 +1,68 @@
+use crate::builtins::PyType;
+
+#[pyclass(name = "PyCFieldType", base = "PyType", module = "_ctypes")]
+#[derive(PyPayload)]
+pub struct PyCFieldType {
+    pub(super) inner: PyCField,
+}
+
+#[pyclass]
+impl PyCFieldType {}
+
+#[pyclass(
+    name = "CField",
+    base = "PyCData",
+    metaclass = "PyCFieldType",
+    module = "_ctypes"
+)]
+pub struct PyCField {
+    byte_offset: usize,
+    byte_size: usize,
+    index: usize,
+    proto: PyTypeRef,
+    anonymous: bool,
+    bitfield_size: bool,
+    bit_offset: u8,
+    name: String,
+}
+
+impl Representable for PyCFuncPtr {
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        let field = zelf.inner.read();
+        let tp_name = field.proto.name().to_string();
+        if field.bitfield_size != 0 {
+            Ok(format!(
+                "<{} {} type={}, ofs={}, bit_size={}, bit_offset={}",
+                field.name, tp_name, field.byte_offset, field.bitfield_size, field.bit_offset
+            ))
+        } else {
+            Ok(format!(
+                "<{} {} type={}, ofs={}, size={}",
+                field.name, tp_name, field.byte_offset, field.byte_size
+            ))
+        }
+    }
+}
+
+#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Representable))]
+impl PyCField {
+    #[pygetset]
+    fn size(&self) -> usize {
+        self.byte_size
+    }
+
+    #[pygetset]
+    fn bit_size(&self) -> u8 {
+        self.bitfield_size
+    }
+
+    #[pygetset]
+    fn is_bitfield(&self) -> bool {
+        self.bitfield_size
+    }
+
+    #[pygetset]
+    fn is_anonymous(&self) -> bool {
+        self.anonymous
+    }
+}
diff --git a/vm/src/stdlib/ctypes/function.rs b/vm/src/stdlib/ctypes/function.rs
@@ -13,16 +13,37 @@ use libffi::middle::{Arg, Cif, CodePtr, Type};
 use libloading::Symbol;
 use num_traits::ToPrimitive;
 use rustpython_common::lock::PyRwLock;
+use std::ffi;
 use std::fmt::Debug;
 
 // https://github.com/python/cpython/blob/4f8bb3947cfbc20f970ff9d9531e1132a9e95396/Modules/_ctypes/callproc.c#L15
 
+/// Returns none if the `_type_` attribute cannot be found/converted to a string
+fn get_type_char(ty: PyTypeRef) -> Option<String> {
+    // PyTypeRef could be c_int, c_float, c_double, etc., we need to get the _type_ attribute
+    // and convert it to a Type
+    let type_str = ty.get_attr("_type_")?;
+    let type_str = type_str.downcast_ref::<PyStr>()?.to_string();
+    Some(type_str)
+}
+
+fn type_ref_to_type(ty: PyTypeRef) -> Type {
+    // PyTypeRef could be c_int, c_float, c_double, etc., we need to get the _type_ attribute
+    // and convert it to a Type
+    unimplemented!()
+}
+
+fn obj_from_type_ref_and_data(data: ffi::c_void, ty: PyTypeRef) -> PyObjectRef {
+    unimplemented!()
+}
+
 #[derive(Debug)]
 pub struct Function {
     args: Vec<Type>,
     // TODO: no protection from use-after-free
     pointer: CodePtr,
     cif: Cif,
+    return_type: Option<PyTypeRef>,
 }
 
 unsafe impl Send for Function {}
@@ -85,7 +106,7 @@ impl Function {
                 .map_err(|err| vm.new_attribute_error(err))?
         };
         let code_ptr = CodePtr(*pointer as *mut _);
-        let return_type = match ret_type {
+        let return_type = match ret_type.clone() {
             // TODO: Fix this
             Some(_t) => {
                 return Err(vm.new_not_implemented_error("Return type not implemented".to_string()));
@@ -97,6 +118,7 @@ impl Function {
             args,
             cif,
             pointer: code_ptr,
+            return_type: ret_type,
         })
     }
 
@@ -119,8 +141,7 @@ impl Function {
                 Err(vm.new_type_error("Expected a ctypes simple type".to_string()))
             })
             .collect::<PyResult<Vec<Arg>>>()?;
-        // TODO: FIX return
-        let result: i32 = unsafe { self.cif.call(self.pointer, &args) };
+        let result: ffi::c_void = unsafe { self.cif.call(self.pointer, &args) };
         Ok(vm.ctx.new_int(result).into())
     }
 }
diff --git a/vm/src/stdlib/ctypes/pointer.rs b/vm/src/stdlib/ctypes/pointer.rs
@@ -1,4 +1,4 @@
-crate::builtins::PyType;
+use crate::builtins::PyType;
 
 #[pyclass(name = "PyCPointerType", base = "PyType", module = "_ctypes")]
 #[derive(PyPayload)]
@@ -9,7 +9,12 @@ pub struct PyCPointerType {
 #[pyclass]
 impl PyCPointerType {}
 
-#[pyclass(name = "_Pointer", base = "PyCData", metaclass = "PyCPointerType", module = "_ctypes")]
+#[pyclass(
+    name = "_Pointer",
+    base = "PyCData",
+    metaclass = "PyCPointerType",
+    module = "_ctypes"
+)]
 pub struct PyCPointer {}
 
 #[pyclass(flags(BASETYPE, IMMUTABLETYPE))]
diff --git a/vm/src/stdlib/ctypes/util.rs b/vm/src/stdlib/ctypes/util.rs
@@ -0,0 +1,22 @@
+#[pyclass]
+#[derive(Debug, PyPayload)]
+pub struct StgInfo {
+    initialized: i32,
+    size: usize,   // number of bytes
+    align: usize,  // alignment requirements
+    length: usize, // number of fields
+    ffi_type_pointer: ffi::ffi_type,
+    proto: PyObjectRef,           // Only for Pointer/ArrayObject
+    setfunc: Option<PyObjectRef>, // Only for simple objects
+    getfunc: Option<PyObjectRef>, // Only for simple objects
+    paramfunc: Option<PyObjectRef>,
+
+    /* Following fields only used by PyCFuncPtrType_Type instances */
+    argtypes: Option<PyObjectRef>,   // tuple of CDataObjects
+    converters: Option<PyObjectRef>, // tuple([t.from_param for t in argtypes])
+    restype: Option<PyObjectRef>,    // CDataObject or NULL
+    checker: Option<PyObjectRef>,
+    module: Option<PyObjectRef>,
+    flags: i32, // calling convention and such
+    dict_final: u8,
+}
