May 2, 2025 · Mar 15, 2025 · Mar 15, 2025 · Mar 15, 2025 · Mar 15, 2025 · Mar 15, 2025
diff --git a/Doc/whatsnew/3.14.rst b/Doc/whatsnew/3.14.rst
  loaded by the current process.
  (Contributed by Brian Ward in :gh:`119349`.)

 * Move :func:`ctypes.POINTER` types cache from the global ``_pointer_type_cache``
  to the corresponding :mod:`ctypes` types. This will stop the cache from
  growing without limits in some situations.
  (Contributed by Sergey Miryanov in :gh:`100926`).

 datetime
 --------

diff --git a/Lib/ctypes/__init__.py b/Lib/ctypes/__init__.py
    warnings._deprecated("ctypes.SetPointerType", remove=(3, 15))
    if _pointer_type_cache.get(cls, None) is not None:
        raise RuntimeError("This type already exists in the cache")
    if id(pointer) not in _pointer_type_cache:
        raise RuntimeError("What's this???")

    pointer.set_type(cls)
    _pointer_type_cache[cls] = pointer
    del _pointer_type_cache[id(pointer)]

 def ARRAY(typ, len):
    return typ * len
diff --git a/Lib/test/test_ctypes/test_byteswap.py b/Lib/test/test_ctypes/test_byteswap.py
                self.assertEqual(len(data), sizeof(TestStructure))
                ptr = POINTER(TestStructure)
                s = cast(data, ptr)[0]
                del ctypes._pointer_type_cache[TestStructure]
                self.assertEqual(s.point.x, 1)
                self.assertEqual(s.point.y, 2)

                self.assertEqual(len(data), sizeof(TestUnion))
                ptr = POINTER(TestUnion)
                s = cast(data, ptr)[0]
                del ctypes._pointer_type_cache[TestUnion]
                self.assertEqual(s.point.x, 1)
                self.assertEqual(s.point.y, 2)

diff --git a/Lib/test/test_ctypes/test_keeprefs.py b/Lib/test/test_ctypes/test_keeprefs.py
 import unittest
 from ctypes import (Structure, POINTER, pointer,  _pointer_type_cache,
                    c_char_p, c_int)
 from ctypes import (Structure, POINTER, pointer, c_char_p, c_int)


 class SimpleTestCase(unittest.TestCase):
        r.a[0].x = 42
        r.a[0].y = 99

        # to avoid leaking when tests are run several times
        # clean up the types left in the cache.
        del _pointer_type_cache[POINT]


 if __name__ == "__main__":
    unittest.main()
diff --git a/Lib/test/test_ctypes/test_pointers.py b/Lib/test/test_ctypes/test_pointers.py
 import sys
 import unittest
 from ctypes import (CDLL, CFUNCTYPE, Structure,
                    POINTER, pointer, _Pointer, _pointer_type_cache,
                    POINTER, pointer, _Pointer,
                    byref, sizeof,
                    c_void_p, c_char_p,
                    c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,

        pt.contents.c = 33

        del _pointer_type_cache[Table]

    def test_basic(self):
        p = pointer(c_int(42))
        # Although a pointer can be indexed, it has no length
        LargeNamedType = type('T' * 2 ** 25, (Structure,), {})
        self.assertTrue(POINTER(LargeNamedType))

        # to not leak references, we must clean _pointer_type_cache
        del _pointer_type_cache[LargeNamedType]

    def test_pointer_type_str_name(self):
        large_string = 'T' * 2 ** 25
        P = POINTER(large_string)
        self.assertTrue(P)

        # to not leak references, we must clean _pointer_type_cache
        del _pointer_type_cache[id(P)]

    def test_abstract(self):
        self.assertRaises(TypeError, _Pointer.set_type, 42)

diff --git a/Lib/test/test_ctypes/test_values.py b/Lib/test/test_ctypes/test_values.py
 import sys
 import unittest
 from ctypes import (Structure, CDLL, POINTER, pythonapi,
                    _pointer_type_cache,
                    c_ubyte, c_char_p, c_int)
 from test.support import import_helper

                         "_PyImport_FrozenBootstrap example "
                         "in Doc/library/ctypes.rst may be out of date")

        del _pointer_type_cache[struct_frozen]

    def test_undefined(self):
        self.assertRaises(ValueError, c_int.in_dll, pythonapi,
                          "Undefined_Symbol")
diff --git a/Lib/test/test_ctypes/test_win32.py b/Lib/test/test_ctypes/test_win32.py
 import sys
 import unittest
 from ctypes import (CDLL, Structure, POINTER, pointer, sizeof, byref,
                    _pointer_type_cache,
                    c_void_p, c_char, c_int, c_long)
 from test import support
 from test.support import import_helper
            self.assertEqual(ret.top, top.value)
            self.assertEqual(ret.bottom, bottom.value)

 # to not leak references, we must clean _pointer_type_cache
 del _pointer_type_cache[RECT]
 self.assertEqual(id(PointInRect.argtypes[0]), id(ReturnRect.argtypes[2]))
 self.assertEqual(id(PointInRect.argtypes[0]), id(ReturnRect.argtypes[5]))


 if __name__ == '__main__':
diff --git a/Misc/NEWS.d/next/Library/2025-03-17-23-07-57.gh-issue-100926.B8gcbz.rst b/Misc/NEWS.d/next/Library/2025-03-17-23-07-57.gh-issue-100926.B8gcbz.rst
 Move :func:`ctypes.POINTER` types cache from the global ``_pointer_type_cache``
 to the corresponding :mod:`ctypes` types to avoid unlimited growth of the cache.
diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
        Py_VISIT(info->restype);
        Py_VISIT(info->checker);
        Py_VISIT(info->module);
        Py_VISIT(info->pointer_type);
    }
    Py_VISIT(Py_TYPE(self));
    return PyType_Type.tp_traverse(self, visit, arg);
    Py_CLEAR(info->restype);
    Py_CLEAR(info->checker);
    Py_CLEAR(info->module);
    Py_CLEAR(info->pointer_type);
 }

 static int
diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c
 {
    PyObject *result;
    PyTypeObject *typ;
    PyObject *key;

    assert(module);
    ctypes_state *st = get_module_state(module);
    StgInfo *info = NULL;
    if (PyType_Check(cls)) {
        if (PyStgInfo_FromType(st, cls, &info) < 0) {
            return NULL;
        }
        if (info && info->pointer_type) {
            return Py_NewRef(info->pointer_type);
        }
    }

    if (PyDict_GetItemRef(st->_ctypes_ptrtype_cache, cls, &result) != 0) {
        // found or error
        return result;
    }

    // not found
    if (PyUnicode_CheckExact(cls)) {
        PyObject *name = PyUnicode_FromFormat("LP_%U", cls);
                                       st->PyCPointer_Type);
        if (result == NULL)
            return result;
        key = PyLong_FromVoidPtr(result);
        if (key == NULL) {
            Py_DECREF(result);
            return NULL;
        }
    } else if (PyType_Check(cls)) {
        typ = (PyTypeObject *)cls;
        PyObject *name = PyUnicode_FromFormat("LP_%s", typ->tp_name);
                                       "_type_", cls);
        if (result == NULL)
            return result;
        key = Py_NewRef(cls);
    } else {
        PyErr_SetString(PyExc_TypeError, "must be a ctypes type");
        return NULL;
    }
    if (PyDict_SetItem(st->_ctypes_ptrtype_cache, key, result) < 0) {
        Py_DECREF(result);
        Py_DECREF(key);
        return NULL;

    if (info) {
        info->pointer_type = Py_NewRef(result);
    }
    Py_DECREF(key);

    return result;
 }

    PyObject *result;
    PyObject *typ;

 ctypes_state *st = get_module_state(module);
    if (PyDict_GetItemRef(st->_ctypes_ptrtype_cache, (PyObject *)Py_TYPE(arg), &typ) < 0) {
 typ = create_pointer_type(module, (PyObject *)Py_TYPE(arg));
    if (typ == NULL)
        return NULL;
    }
    if (typ == NULL) {
        typ = create_pointer_type(module, (PyObject *)Py_TYPE(arg));
        if (typ == NULL)
            return NULL;
    }

    result = PyObject_CallOneArg(typ, arg);
    Py_DECREF(typ);
    return result;
diff --git a/Modules/_ctypes/ctypes.h b/Modules/_ctypes/ctypes.h
    Py_ssize_t *shape;
 /*      Py_ssize_t *strides;    */ /* unused in ctypes */
 /*      Py_ssize_t *suboffsets; */ /* unused in ctypes */
    PyObject *pointer_type;
 } StgInfo;

 extern int PyCStgInfo_clone(StgInfo *dst_info, StgInfo *src_info);
        return NULL;
    }
    info->module = Py_NewRef(module);
    info->pointer_type = NULL;

    info->initialized = 1;
    return info;
diff --git a/Modules/_ctypes/stgdict.c b/Modules/_ctypes/stgdict.c
    Py_XINCREF(dst_info->restype);
    Py_XINCREF(dst_info->checker);
    Py_XINCREF(dst_info->module);
    Py_XINCREF(dst_info->pointer_type);

    if (src_info->format) {
        dst_info->format = PyMem_Malloc(strlen(src_info->format) + 1);
Original file line number	Diff line number	Diff line change
Expand Up		@@ -510,6 +510,11 @@ ctypes
		loaded by the current process.
		(Contributed by Brian Ward in :gh:`119349`.)

		* Move :func:`ctypes.POINTER` types cache from the global ``_pointer_type_cache``
		to the corresponding :mod:`ctypes` types. This will stop the cache from
		growing without limits in some situations.
		(Contributed by Sergey Miryanov in :gh:`100926`).
sergey-miryanov marked this conversation as resolved. Show resolvedHide resolved

		datetime
		--------

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -319,11 +319,9 @@ def SetPointerType(pointer, cls):
		warnings._deprecated("ctypes.SetPointerType", remove=(3, 15))
		if _pointer_type_cache.get(cls, None) is not None:
		raise RuntimeError("This type already exists in the cache")
		if id(pointer) not in _pointer_type_cache:
		raise RuntimeError("What's this???")

		pointer.set_type(cls)
		_pointer_type_cache[cls] = pointer
sergey-miryanov marked this conversation as resolved. Show resolvedHide resolved
		del _pointer_type_cache[id(pointer)]

		def ARRAY(typ, len):
		return typ * len
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -226,7 +226,6 @@ class TestStructure(parent):
		self.assertEqual(len(data), sizeof(TestStructure))
		ptr = POINTER(TestStructure)
		s = cast(data, ptr)[0]
		del ctypes._pointer_type_cache[TestStructure]
		self.assertEqual(s.point.x, 1)
		self.assertEqual(s.point.y, 2)

Expand DownExpand Up		@@ -359,7 +358,6 @@ class TestUnion(parent):
		self.assertEqual(len(data), sizeof(TestUnion))
		ptr = POINTER(TestUnion)
		s = cast(data, ptr)[0]
		del ctypes._pointer_type_cache[TestUnion]
		self.assertEqual(s.point.x, 1)
		self.assertEqual(s.point.y, 2)

Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,6 +1,5 @@
		import unittest
		from ctypes import (Structure, POINTER, pointer, _pointer_type_cache,
		c_char_p, c_int)
		from ctypes import (Structure, POINTER, pointer, c_char_p, c_int)


		class SimpleTestCase(unittest.TestCase):
Expand DownExpand Up		@@ -115,10 +114,6 @@ class RECT(Structure):
		r.a[0].x = 42
		r.a[0].y = 99

		# to avoid leaking when tests are run several times
		# clean up the types left in the cache.
		del _pointer_type_cache[POINT]


		if __name__ == "__main__":
		unittest.main()
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,7 +3,7 @@
		import sys
		import unittest
		from ctypes import (CDLL, CFUNCTYPE, Structure,
		POINTER, pointer, _Pointer, _pointer_type_cache,
		POINTER, pointer, _Pointer,
		byref, sizeof,
		c_void_p, c_char_p,
		c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
Expand DownExpand Up		@@ -141,8 +141,6 @@ class Table(Structure):

		pt.contents.c = 33

		del _pointer_type_cache[Table]

		def test_basic(self):
		p = pointer(c_int(42))
		# Although a pointer can be indexed, it has no length
Expand DownExpand Up		@@ -210,17 +208,11 @@ def test_pointer_type_name(self):
		LargeNamedType = type('T' * 2 ** 25, (Structure,), {})
		self.assertTrue(POINTER(LargeNamedType))

		# to not leak references, we must clean _pointer_type_cache
		del _pointer_type_cache[LargeNamedType]

		def test_pointer_type_str_name(self):
		large_string = 'T' * 2 ** 25
		P = POINTER(large_string)
		self.assertTrue(P)

		# to not leak references, we must clean _pointer_type_cache
		del _pointer_type_cache[id(P)]

		def test_abstract(self):
		self.assertRaises(TypeError, _Pointer.set_type, 42)

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -7,7 +7,6 @@
		import sys
		import unittest
		from ctypes import (Structure, CDLL, POINTER, pythonapi,
		_pointer_type_cache,
		c_ubyte, c_char_p, c_int)
		from test.support import import_helper

Expand DownExpand Up		@@ -96,8 +95,6 @@ class struct_frozen(Structure):
		"_PyImport_FrozenBootstrap example "
		"in Doc/library/ctypes.rst may be out of date")

		del _pointer_type_cache[struct_frozen]

		def test_undefined(self):
		self.assertRaises(ValueError, c_int.in_dll, pythonapi,
		"Undefined_Symbol")
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -5,7 +5,6 @@
		import sys
		import unittest
		from ctypes import (CDLL, Structure, POINTER, pointer, sizeof, byref,
		_pointer_type_cache,
		c_void_p, c_char, c_int, c_long)
		from test import support
		from test.support import import_helper
Expand DownExpand Up		@@ -145,8 +144,8 @@ class RECT(Structure):
		self.assertEqual(ret.top, top.value)
		self.assertEqual(ret.bottom, bottom.value)

		# to not leak references, we must clean _pointer_type_cache
		del _pointer_type_cache[RECT]
		self.assertEqual(id(PointInRect.argtypes[0]), id(ReturnRect.argtypes[2]))
		self.assertEqual(id(PointInRect.argtypes[0]), id(ReturnRect.argtypes[5]))
sergey-miryanov marked this conversation as resolved. Show resolvedHide resolved


		if __name__ == '__main__':
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		Move :func:`ctypes.POINTER` types cache from the global ``_pointer_type_cache``
		to the corresponding :mod:`ctypes` types to avoid unlimited growth of the cache.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -474,6 +474,7 @@ CType_Type_traverse(PyObject self, visitproc visit, void arg)
		Py_VISIT(info->restype);
		Py_VISIT(info->checker);
		Py_VISIT(info->module);
		Py_VISIT(info->pointer_type);
		}
		Py_VISIT(Py_TYPE(self));
		return PyType_Type.tp_traverse(self, visit, arg);
Expand All		@@ -489,6 +490,7 @@ ctype_clear_stginfo(StgInfo *info)
		Py_CLEAR(info->restype);
		Py_CLEAR(info->checker);
		Py_CLEAR(info->module);
		Py_CLEAR(info->pointer_type);
sergey-miryanov marked this conversation as resolved. Show resolvedHide resolved
		}

		static int
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1990,14 +1990,24 @@ create_pointer_type(PyObject module, PyObject cls)
		{
		PyObject *result;
		PyTypeObject *typ;
		PyObject *key;

		assert(module);
		ctypes_state *st = get_module_state(module);
		StgInfo *info = NULL;
		if (PyType_Check(cls)) {
		if (PyStgInfo_FromType(st, cls, &info) < 0) {
		return NULL;
		}
		if (info && info->pointer_type) {
		return Py_NewRef(info->pointer_type);
		}
		}

		if (PyDict_GetItemRef(st->_ctypes_ptrtype_cache, cls, &result) != 0) {
		// found or error
		return result;
		}

		// not found
		if (PyUnicode_CheckExact(cls)) {
		PyObject *name = PyUnicode_FromFormat("LP_%U", cls);
Expand All		@@ -2007,11 +2017,6 @@ create_pointer_type(PyObject module, PyObject cls)
		st->PyCPointer_Type);
		if (result == NULL)
		return result;
		key = PyLong_FromVoidPtr(result);
		if (key == NULL) {
		Py_DECREF(result);
		return NULL;
		}
sergey-miryanov marked this conversation as resolved. Show resolvedHide resolved
		} else if (PyType_Check(cls)) {
		typ = (PyTypeObject *)cls;
		PyObject *name = PyUnicode_FromFormat("LP_%s", typ->tp_name);
Expand All		@@ -2022,17 +2027,15 @@ create_pointer_type(PyObject module, PyObject cls)
		"_type_", cls);
		if (result == NULL)
		return result;
		key = Py_NewRef(cls);
		} else {
		PyErr_SetString(PyExc_TypeError, "must be a ctypes type");
		return NULL;
		}
		if (PyDict_SetItem(st->_ctypes_ptrtype_cache, key, result) < 0) {
		Py_DECREF(result);
		Py_DECREF(key);
		return NULL;

		if (info) {
		info->pointer_type = Py_NewRef(result);
		}
sergey-miryanov marked this conversation as resolved. Show resolvedHide resolved
		Py_DECREF(key);

		return result;
		}

Expand All		@@ -2056,15 +2059,10 @@ create_pointer_inst(PyObject module, PyObject arg)
		PyObject *result;
		PyObject *typ;

		ctypes_state *st = get_module_state(module);
		if (PyDict_GetItemRef(st->_ctypes_ptrtype_cache, (PyObject *)Py_TYPE(arg), &typ) < 0) {
		typ = create_pointer_type(module, (PyObject *)Py_TYPE(arg));
		if (typ == NULL)
		return NULL;
		}
		if (typ == NULL) {
		typ = create_pointer_type(module, (PyObject *)Py_TYPE(arg));
		if (typ == NULL)
		return NULL;
		}

		result = PyObject_CallOneArg(typ, arg);
		Py_DECREF(typ);
		return result;
Expand Down