Update Lib/ctypes/__init__.py from cpython3.13.9

Author: youknowone

Lib/ctypes/__init__.py

@@ -347,6 +347,19 @@ def __init__(self, name, mode=DEFAULT_MODE, handle=None,
                  use_errno=False,
                  use_last_error=False,
                  winmode=None):
+        if name:
+            name = _os.fspath(name)
+
+            # If the filename that has been provided is an iOS/tvOS/watchOS
+            # .fwork file, dereference the location to the true origin of the
+            # binary.
+            if name.endswith(".fwork"):
+                with open(name) as f:
+                    name = _os.path.join(
+                        _os.path.dirname(_sys.executable),
+                        f.read().strip()
+                    )
+
         self._name = name
         flags = self._func_flags_
         if use_errno:
@@ -467,6 +480,8 @@ def LoadLibrary(self, name):
 
 if _os.name == "nt":
     pythonapi = PyDLL("python dll", None, _sys.dllhandle)
+elif _sys.platform == "android":
+    pythonapi = PyDLL("libpython%d.%d.so" % _sys.version_info[:2])
 elif _sys.platform == "cygwin":
     pythonapi = PyDLL("libpython%d.%d.dll" % _sys.version_info[:2])
 else:
@@ -498,15 +513,14 @@ def WinError(code=None, descr=None):
     c_ssize_t = c_longlong
 
 # functions
+
 from _ctypes import _memmove_addr, _memset_addr, _string_at_addr, _cast_addr
 
 ## void *memmove(void *, const void *, size_t);
-# XXX: RUSTPYTHON
-# memmove = CFUNCTYPE(c_void_p, c_void_p, c_void_p, c_size_t)(_memmove_addr)
+memmove = CFUNCTYPE(c_void_p, c_void_p, c_void_p, c_size_t)(_memmove_addr)
 
 ## void *memset(void *, int, size_t)
-# XXX: RUSTPYTHON
-# memset = CFUNCTYPE(c_void_p, c_void_p, c_int, c_size_t)(_memset_addr)
+memset = CFUNCTYPE(c_void_p, c_void_p, c_int, c_size_t)(_memset_addr)
 
 def PYFUNCTYPE(restype, *argtypes):
     class CFunctionType(_CFuncPtr):
@@ -515,30 +529,27 @@ class CFunctionType(_CFuncPtr):
         _flags_ = _FUNCFLAG_CDECL | _FUNCFLAG_PYTHONAPI
     return CFunctionType
 
-# XXX: RUSTPYTHON
-# _cast = PYFUNCTYPE(py_object, c_void_p, py_object, py_object)(_cast_addr)
+_cast = PYFUNCTYPE(py_object, c_void_p, py_object, py_object)(_cast_addr)
 def cast(obj, typ):
     return _cast(obj, obj, typ)
 
-# XXX: RUSTPYTHON
-# _string_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_string_at_addr)
+_string_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_string_at_addr)
 def string_at(ptr, size=-1):
-    """string_at(addr[, size]) -> string
+    """string_at(ptr[, size]) -> string
 
-    Return the string at addr."""
+    Return the byte string at void *ptr."""
     return _string_at(ptr, size)
 
 try:
     from _ctypes import _wstring_at_addr
 except ImportError:
     pass
 else:
-    # XXX: RUSTPYTHON
-    # _wstring_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_wstring_at_addr)
+    _wstring_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_wstring_at_addr)
     def wstring_at(ptr, size=-1):
-        """wstring_at(addr[, size]) -> string
+        """wstring_at(ptr[, size]) -> string
 
-        Return the string at addr."""
+        Return the wide-character string at void *ptr."""
         return _wstring_at(ptr, size)
 
 

crates/vm/src/stdlib/ctypes/function.rs

@@ -1,6 +1,6 @@
 // spell-checker:disable
 
-use crate::builtins::{PyStr, PyTupleRef, PyTypeRef};
+use crate::builtins::{PyStr, PyTypeRef};
 use crate::convert::ToPyObject;
 use crate::function::FuncArgs;
 use crate::stdlib::ctypes::PyCData;
@@ -142,27 +142,61 @@ impl Debug for PyCFuncPtr {
 }
 
 impl Constructor for PyCFuncPtr {
-    type Args = (PyTupleRef, FuncArgs);
-
-    fn py_new(_cls: PyTypeRef, (tuple, _args): Self::Args, vm: &VirtualMachine) -> PyResult {
-        let name = tuple
-            .first()
-            .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements"))?
-            .downcast_ref::<PyStr>()
-            .ok_or(vm.new_type_error("Expected a string"))?
-            .to_string();
-        let handler = tuple
-            .into_iter()
-            .nth(1)
-            .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements"))?
-            .clone();
-        Ok(Self {
-            _flags_: AtomicCell::new(0),
-            name: PyRwLock::new(name),
-            _restype_: PyRwLock::new(None),
-            handler,
+    type Args = FuncArgs;
+
+    fn py_new(_cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+        // Handle different argument forms like CPython:
+        // 1. One integer argument: function address
+        // 2. Tuple argument: (name, dll) form
+
+        if args.args.is_empty() {
+            // Empty args - create uninitialized
+            return Ok(Self {
+                _flags_: AtomicCell::new(0),
+                name: PyRwLock::new(String::new()),
+                _restype_: PyRwLock::new(None),
+                handler: vm.ctx.none(),
+            }
+            .to_pyobject(vm));
+        }
+
+        let first_arg = &args.args[0];
+
+        // Check if first argument is an integer (function address)
+        if let Ok(addr) = first_arg.try_int(vm) {
+            let ptr = addr.as_bigint().to_usize().unwrap_or(0);
+            return Ok(Self {
+                _flags_: AtomicCell::new(0),
+                name: PyRwLock::new(format!("CFuncPtr@{:#x}", ptr)),
+                _restype_: PyRwLock::new(None),
+                handler: vm.ctx.new_int(ptr).into(),
+            }
+            .to_pyobject(vm));
+        }
+
+        // Check if first argument is a tuple (name, dll) form
+        if let Some(tuple) = first_arg.downcast_ref::<crate::builtins::PyTuple>() {
+            let name = tuple
+                .first()
+                .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements"))?
+                .downcast_ref::<PyStr>()
+                .ok_or(vm.new_type_error("Expected a string"))?
+                .to_string();
+            let handler = tuple
+                .iter()
+                .nth(1)
+                .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements"))?
+                .clone();
+            return Ok(Self {
+                _flags_: AtomicCell::new(0),
+                name: PyRwLock::new(name),
+                _restype_: PyRwLock::new(None),
+                handler,
+            }
+            .to_pyobject(vm));
         }
-        .to_pyobject(vm))
+
+        Err(vm.new_type_error("Expected an integer address or a tuple"))
     }
 }