Revert to calling through ctypes to get c_void_p conversion seman…

…tics. Improve tests and docs.
python · encukou · Jan 3, 2025 · Nov 13, 2023 · Nov 13, 2023 · Jan 18, 2024
commit 3a6b559e08a2d0c53b93d5fda58dd5ff76e3a0d3
diff --git a/Doc/library/ctypes.rst b/Doc/library/ctypes.rst
@@ -2164,21 +2164,22 @@ Utility functions
    .. audit-event:: ctypes.wstring_at ptr,size ctypes.wstring_at
 
 
-.. function:: memoryview_at(address, size, readonly=False)
+.. function:: memoryview_at(ptr, size, readonly=False)
 
-   This function returns a :class:`memoryview` object that references the
-   memory starting at *address* up to (but not including) *address +
-   size*.  If *readonly* is set to a truthy value then the
-   :class:`!memoryview` object is immutable.
+   This function returns a :class:`memoryview` object of length *size* that
+   references the memory starting at *void \*ptr*, .
+   If *readonly* is true then the :class:`!memoryview` object is immutable.
 
    This function is similar to :func:`string_at` with the key
-   difference of not making a copy of the specified memory. It is a
-   semantically equivalent (but more efficient) alternative to
-   ``memoryview((c_byte * size).from_address(address))``
+   difference of not making a copy of the specified memory.
+   It is a semantically equivalent (but more efficient) alternative to
+   ``memoryview((c_byte * size).from_address(ptr))``.
+   (While :meth:`~_CData.from_address` only takes integer, *ptr* can also
+   be given as a :class:`ctypes.POINTER` or a :func:`~ctypes.byref` object.)
 
    .. audit-event:: ctypes.memoryview_at address,size,readonly ctypes.buffer_at
 
-   .. versionadded:: 3.13
+   .. versionadded:: next
 
 
 .. _ctypes-data-types:

diff --git a/Lib/ctypes/__init__.py b/Lib/ctypes/__init__.py
@@ -12,7 +12,6 @@
 from _ctypes import RTLD_LOCAL, RTLD_GLOBAL
 from _ctypes import ArgumentError
 from _ctypes import SIZEOF_TIME_T
-from _ctypes import memoryview_at
 
 from struct import calcsize as _calcsize
 
@@ -525,6 +524,7 @@ def WinError(code=None, descr=None):
 # functions
 
 from _ctypes import _memmove_addr, _memset_addr, _string_at_addr, _cast_addr
+from _ctypes import _memoryview_at_addr
 
 ## void *memmove(void *, const void *, size_t);
 memmove = CFUNCTYPE(c_void_p, c_void_p, c_void_p, c_size_t)(_memmove_addr)
@@ -550,6 +550,13 @@ def string_at(ptr, size=-1):
     Return the byte string at void *ptr."""
     return _string_at(ptr, size)
 
+_memoryview_at = PYFUNCTYPE(py_object, c_void_p, c_int, c_int)(_memoryview_at_addr)
+def memoryview_at(ptr, size, readonly=False):
+    """memoryview_at(ptr[, size]) -> memoryview
+
+    Return a memoryview representing the memory at addr."""
+    return _memoryview_at(ptr, size, bool(readonly))
+
 try:
     from _ctypes import _wstring_at_addr
 except ImportError:

diff --git a/Lib/test/test_ctypes/test_memfunctions.py b/Lib/test/test_ctypes/test_memfunctions.py
@@ -6,7 +6,8 @@
                     create_unicode_buffer, wstring_at,
                     memmove, memset,
                     memoryview_at, c_void_p,
-                    c_char_p, c_byte, c_ubyte, c_wchar)
+                    c_char_p, c_byte, c_ubyte, c_wchar,
+                    addressof, byref)
 
 
 class MemFunctionsTest(unittest.TestCase):
@@ -83,20 +84,29 @@ def test_memoryview_at(self):
 
         foreign_ptr = cast(b, c_void_p)
         foreign_ptr_size = len(b)
-
-        # memoryview_at() is normally used with pointers given to us
-        # by C APIs. It's an efficient way to get a buffer
-        # representing a dynamically-sized memory region without having
-        # to create an array type first.
-        v = memoryview_at(foreign_ptr, foreign_ptr_size)
-
-        # test that writes to source buffer get reflected in memoryview
-        b[:] = b"0123456789"
-        self.assertEqual(bytes(v), b"0123456789")
-
-        # test that writes to memoryview get reflected in source buffer
-        v[:] = b"9876543210"
-        self.assertEqual(bytes(b), b"9876543210")
+        for foreign_ptr in (
+            b,
+            cast(b, c_void_p),
+            byref(b),
+            addressof(b)
+        ):
+            with self.subTest(foreign_ptr=type(foreign_ptr).__name__):
+                v = memoryview_at(foreign_ptr, foreign_ptr_size)
+                self.assertIsInstance(v, memoryview)
+
+                # test that writes to source buffer get reflected in memoryview
+                b[:] = b"0123456789"
+                self.assertEqual(bytes(v), b"0123456789")
+
+                # test that writes to memoryview get reflected in source buffer
+                v[:] = b"9876543210"
+                self.assertEqual(bytes(b), b"9876543210")
+
+                with self.assertRaises(ValueError):
+                    memoryview_at(foreign_ptr, -1)
+
+                v0 = memoryview_at(foreign_ptr, 0)
+                self.assertEqual(bytes(v0), b'')
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
@@ -5741,34 +5741,18 @@ wstring_at(const wchar_t *ptr, int size)
     return PyUnicode_FromWideChar(ptr, ssize);
 }
 
-/*[clinic input]
-_ctypes.memoryview_at
-
-    obj: object
-    /
-    size: Py_ssize_t
-    readonly: bool = False
-
-Return a memoryview representing the memory at addr.
-[clinic start generated code]*/
-
 static PyObject *
-_ctypes_memoryview_at_impl(PyObject *module, PyObject *obj, Py_ssize_t size,
-                           int readonly)
-/*[clinic end generated code: output=c89fdda64bd9901d input=c960c5a2b3ccb9fb]*/
+memoryview_at(void *ptr, int size, int readonly)
 {
-    ctypes_state *st = get_module_state(module);
-    if (!CDataObject_Check(st, obj)) {
-        PyErr_SetString(PyExc_TypeError, "invalid type");
+    Py_ssize_t ssize = size;
+    if (PySys_Audit("ctypes.memoryview_at", "nni",
+                    (Py_ssize_t)ptr, ssize, readonly) < 0) {
         return NULL;
     }
-    void *ptr = ((CDataObject *)obj)->b_ptr;
-
-    if (PySys_Audit("ctypes.memoryview_at", "nni", (Py_ssize_t)ptr, size,
-                    readonly) < 0) {
+    if (ssize < 0) {
+        PyErr_SetString(PyExc_ValueError, "size must not be negative");
         return NULL;
     }
-
     return PyMemoryView_FromMemory(ptr, size,
                                    readonly ? PyBUF_READ : PyBUF_WRITE);
 }
@@ -5900,6 +5884,7 @@ _ctypes_add_objects(PyObject *mod)
     MOD_ADD("_string_at_addr", PyLong_FromVoidPtr(string_at));
     MOD_ADD("_cast_addr", PyLong_FromVoidPtr(cast));
     MOD_ADD("_wstring_at_addr", PyLong_FromVoidPtr(wstring_at));
+    MOD_ADD("_memoryview_at_addr", PyLong_FromVoidPtr(memoryview_at));
 
 /* If RTLD_LOCAL is not defined (Windows!), set it to zero. */
 #if !HAVE_DECL_RTLD_LOCAL
@@ -5920,12 +5905,6 @@ _ctypes_add_objects(PyObject *mod)
 #undef MOD_ADD
 }
 
-// Most ctypes methods are defined in callproc.c.
-// Here is the rest.
-static PyMethodDef module_methods[] = {
-    _CTYPES_MEMORYVIEW_AT_METHODDEF
-    {NULL,      NULL}        /* Sentinel */
-};
 
 static int
 _ctypes_mod_exec(PyObject *mod)
@@ -5953,9 +5932,6 @@ _ctypes_mod_exec(PyObject *mod)
     if (_ctypes_add_objects(mod) < 0) {
         return -1;
     }
-    if (PyModule_AddFunctions(mod, module_methods) < 0) {
-        return -1;
-    }
 
     return 0;
 }

diff --git a/Modules/_ctypes/clinic/_ctypes.c.h b/Modules/_ctypes/clinic/_ctypes.c.h