RustPython
diff --git a/‎vm/src/stdlib/ctypes.rs
Lines changed: 3 additions & 0 deletions b/‎vm/src/stdlib/ctypes.rs
Lines changed: 3 additions & 0 deletions
diff --git a/‎vm/src/stdlib/ctypes/field.rs
Lines changed: 75 additions & 11 deletions b/‎vm/src/stdlib/ctypes/field.rs
Lines changed: 75 additions & 11 deletions
@@ -7,6 +7,7 @@ pub(crate) mod function;
 pub(crate) mod library;
 pub(crate) mod pointer;
 pub(crate) mod structure;
+pub(crate) mod thunk;
 pub(crate) mod union;
 pub(crate) mod util;
 
@@ -23,11 +24,13 @@ pub fn extend_module_nodes(vm: &VirtualMachine, module: &Py<PyModule>) {
         "_CData" => PyCData::make_class(ctx),
         "_SimpleCData" => PyCSimple::make_class(ctx),
         "Array" => array::PyCArray::make_class(ctx),
+        "CField" => field::PyCField::make_class(ctx),
         "CFuncPtr" => function::PyCFuncPtr::make_class(ctx),
         "PyCPointerType" => pointer::PyCPointerType::make_class(ctx),
         "_Pointer" => pointer::PyCPointer::make_class(ctx),
         "_pointer_type_cache" => ctx.new_dict(),
         "Structure" => structure::PyCStructure::make_class(ctx),
+        "CThunkObject" => thunk::PyCThunk::make_class(ctx), 
         "Union" => union::PyCUnion::make_class(ctx),
     })
 }
 
@@ -1,7 +1,12 @@
 use crate::builtins::PyType;
+use crate::builtins::PyTypeRef;
+use crate::stdlib::ctypes::PyCData;
+use crate::types::Constructor;
+use crate::types::Representable;
+use crate::{Py, PyResult, VirtualMachine};
 
 #[pyclass(name = "PyCFieldType", base = "PyType", module = "_ctypes")]
-#[derive(PyPayload)]
+#[derive(PyPayload, Debug)]
 pub struct PyCFieldType {
     pub(super) inner: PyCField,
 }
@@ -15,6 +20,7 @@ impl PyCFieldType {}
     metaclass = "PyCFieldType",
     module = "_ctypes"
 )]
+#[derive(Debug, PyPayload)]
 pub struct PyCField {
     byte_offset: usize,
     byte_size: usize,
@@ -26,33 +32,53 @@ pub struct PyCField {
     name: String,
 }
 
-impl Representable for PyCFuncPtr {
+impl Representable for PyCField {
     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 {
+        let tp_name = zelf.proto.name().to_string();
+        if zelf.bitfield_size != false {
             Ok(format!(
-                "<{} {} type={}, ofs={}, bit_size={}, bit_offset={}",
-                field.name, tp_name, field.byte_offset, field.bitfield_size, field.bit_offset
+                "<{} type={}, ofs={byte_offset}, bit_size={bitfield_size}, bit_offset={bit_offset}",
+                zelf.name,
+                tp_name,
+                byte_offset = zelf.byte_offset,
+                bitfield_size = zelf.bitfield_size,
+                bit_offset = zelf.bit_offset
             ))
         } else {
             Ok(format!(
-                "<{} {} type={}, ofs={}, size={}",
-                field.name, tp_name, field.byte_offset, field.byte_size
+                "<{} type={tp_name}, ofs={}, size={}",
+                zelf.name, zelf.byte_offset, zelf.byte_size
             ))
         }
     }
 }
 
-#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Representable))]
+#[derive(Debug, FromArgs)]
+struct PyCFieldConstructorArgs {
+    // PyObject *name, PyObject *proto,
+    //               Py_ssize_t byte_size, Py_ssize_t byte_offset,
+    //               Py_ssize_t index, int _internal_use,
+    //               PyObject *bit_size_obj, PyObject *bit_offset_obj
+    
+}
+
+impl Constructor for PyCField {
+    type Args = PyCFieldConstructorArgs;
+
+    fn py_new(_cls: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
+        Err(vm.new_type_error("Cannot instantiate a PyCField".to_string()))
+    }
+}
+
+#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Constructor, Representable))]
 impl PyCField {
     #[pygetset]
     fn size(&self) -> usize {
         self.byte_size
     }
 
     #[pygetset]
-    fn bit_size(&self) -> u8 {
+    fn bit_size(&self) -> bool {
         self.bitfield_size
     }
 
@@ -65,4 +91,42 @@ impl PyCField {
     fn is_anonymous(&self) -> bool {
         self.anonymous
     }
+
+    #[pygetset]
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    #[pygetset(name = "type")]
+    fn type_(&self) -> PyTypeRef {
+        self.proto.clone()
+    }
+
+    #[pygetset]
+    fn offset(&self) -> usize {
+        self.byte_offset
+    }
+
+    #[pygetset]
+    fn byte_offset(&self) -> usize {
+        self.byte_offset
+    }
+
+    #[pygetset]
+    fn byte_size(&self) -> usize {
+        self.byte_size
+    }
+
+    #[pygetset]
+    fn bit_offset(&self) -> u8 {
+        self.bit_offset
+    }
+}
+
+pub(crate) fn low_bit(offset: usize) -> usize {
+    offset & 0xFFFF
+}
+
+pub(crate) fn high_bit(offset: usize) -> usize {
+    offset >> 16
 }