Skip to content

Commit c372d38

Browse files
skirpichevsunmy2019
authored and
miss-islington
committed
pythongh-148464: Add missing __ctype_le/be__ attributes for complex types in the ctype module (pythonGH-148485)
(cherry picked from commit 769cc83) Co-authored-by: Sergey B Kirpichev <skirpichev@gmail.com> Co-authored-by: sunmy2019 <59365878+sunmy2019@users.noreply.github.com>
1 parent 2fdccb3 commit c372d38

4 files changed

Lines changed: 154 additions & 14 deletions

File tree

‎Lib/test/test_ctypes/test_byteswap.py‎

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -166,6 +166,48 @@ def test_endian_double(self):
166166
self.assertEqual(s.value, math.pi)
167167
self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s))
168168

169+
@unittest.skipUnless(hasattr(ctypes, 'c_float_complex'), "No complex types")
170+
def test_endian_float_complex(self):
171+
c_float_complex = ctypes.c_float_complex
172+
if sys.byteorder == "little":
173+
self.assertIs(c_float_complex.__ctype_le__, c_float_complex)
174+
self.assertIs(c_float_complex.__ctype_be__.__ctype_le__,
175+
c_float_complex)
176+
else:
177+
self.assertIs(c_float_complex.__ctype_be__, c_float_complex)
178+
self.assertIs(c_float_complex.__ctype_le__.__ctype_be__,
179+
c_float_complex)
180+
s = c_float_complex(math.pi+1j)
181+
self.assertEqual(bin(struct.pack("F", math.pi+1j)), bin(s))
182+
self.assertAlmostEqual(s.value, math.pi+1j, places=6)
183+
s = c_float_complex.__ctype_le__(math.pi+1j)
184+
self.assertAlmostEqual(s.value, math.pi+1j, places=6)
185+
self.assertEqual(bin(struct.pack("<F", math.pi+1j)), bin(s))
186+
s = c_float_complex.__ctype_be__(math.pi+1j)
187+
self.assertAlmostEqual(s.value, math.pi+1j, places=6)
188+
self.assertEqual(bin(struct.pack(">F", math.pi+1j)), bin(s))
189+
190+
@unittest.skipUnless(hasattr(ctypes, 'c_double_complex'), "No complex types")
191+
def test_endian_double_complex(self):
192+
c_double_complex = ctypes.c_double_complex
193+
if sys.byteorder == "little":
194+
self.assertIs(c_double_complex.__ctype_le__, c_double_complex)
195+
self.assertIs(c_double_complex.__ctype_be__.__ctype_le__,
196+
c_double_complex)
197+
else:
198+
self.assertIs(c_double_complex.__ctype_be__, c_double_complex)
199+
self.assertIs(c_double_complex.__ctype_le__.__ctype_be__,
200+
c_double_complex)
201+
s = c_double_complex(math.pi+1j)
202+
self.assertEqual(bin(struct.pack("D", math.pi+1j)), bin(s))
203+
self.assertAlmostEqual(s.value, math.pi+1j, places=6)
204+
s = c_double_complex.__ctype_le__(math.pi+1j)
205+
self.assertAlmostEqual(s.value, math.pi+1j, places=6)
206+
self.assertEqual(bin(struct.pack("<D", math.pi+1j)), bin(s))
207+
s = c_double_complex.__ctype_be__(math.pi+1j)
208+
self.assertAlmostEqual(s.value, math.pi+1j, places=6)
209+
self.assertEqual(bin(struct.pack(">D", math.pi+1j)), bin(s))
210+
169211
def test_endian_other(self):
170212
self.assertIs(c_byte.__ctype_le__, c_byte)
171213
self.assertIs(c_byte.__ctype_be__, c_byte)

‎Misc/NEWS.d/next/Library/2026-04-13-06-22-27.gh-issue-148464.Bj_NZy.rst‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,3 @@
1+
Add missing ``__ctype_le/be__`` attributes for
2+
:class:`~ctypes.c_float_complex` and :class:`~ctypes.c_double_complex`. Patch
3+
by Sergey B Kirpichev.

‎Modules/_ctypes/_ctypes.c‎

Lines changed: 31 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -2232,6 +2232,31 @@ c_void_p_from_param_impl(PyObject *type, PyTypeObject *cls, PyObject *value)
22322232
return NULL;
22332233
}
22342234

2235+
static int
2236+
set_stginfo_ffi_type_pointer(StgInfo *stginfo, struct fielddesc *fmt)
2237+
{
2238+
if (!fmt->pffi_type->elements) {
2239+
stginfo->ffi_type_pointer = *fmt->pffi_type;
2240+
}
2241+
else {
2242+
/* From primitive types - only complex types have the elements
2243+
struct field as non-NULL (two element array). */
2244+
assert(fmt->pffi_type->type == FFI_TYPE_COMPLEX);
2245+
const size_t els_size = 2 * sizeof(ffi_type *);
2246+
stginfo->ffi_type_pointer.size = fmt->pffi_type->size;
2247+
stginfo->ffi_type_pointer.alignment = fmt->pffi_type->alignment;
2248+
stginfo->ffi_type_pointer.type = fmt->pffi_type->type;
2249+
stginfo->ffi_type_pointer.elements = PyMem_Malloc(els_size);
2250+
if (!stginfo->ffi_type_pointer.elements) {
2251+
PyErr_NoMemory();
2252+
return -1;
2253+
}
2254+
memcpy(stginfo->ffi_type_pointer.elements,
2255+
fmt->pffi_type->elements, els_size);
2256+
}
2257+
return 0;
2258+
}
2259+
22352260
static PyMethodDef c_void_p_methods[] = {C_VOID_P_FROM_PARAM_METHODDEF {0}};
22362261
static PyMethodDef c_char_p_methods[] = {C_CHAR_P_FROM_PARAM_METHODDEF {0}};
22372262
static PyMethodDef c_wchar_p_methods[] = {C_WCHAR_P_FROM_PARAM_METHODDEF {0}};
@@ -2276,8 +2301,10 @@ static PyObject *CreateSwappedType(ctypes_state *st, PyTypeObject *type,
22762301
Py_DECREF(result);
22772302
return NULL;
22782303
}
2279-
2280-
stginfo->ffi_type_pointer = *fmt->pffi_type;
2304+
if (set_stginfo_ffi_type_pointer(stginfo, fmt)) {
2305+
Py_DECREF(result);
2306+
return NULL;
2307+
}
22812308
stginfo->align = fmt->pffi_type->alignment;
22822309
stginfo->length = 0;
22832310
stginfo->size = fmt->pffi_type->size;
@@ -2372,18 +2399,8 @@ PyCSimpleType_init(PyObject *self, PyObject *args, PyObject *kwds)
23722399
if (!stginfo) {
23732400
goto error;
23742401
}
2375-
2376-
if (!fmt->pffi_type->elements) {
2377-
stginfo->ffi_type_pointer = *fmt->pffi_type;
2378-
}
2379-
else {
2380-
const size_t els_size = sizeof(fmt->pffi_type->elements);
2381-
stginfo->ffi_type_pointer.size = fmt->pffi_type->size;
2382-
stginfo->ffi_type_pointer.alignment = fmt->pffi_type->alignment;
2383-
stginfo->ffi_type_pointer.type = fmt->pffi_type->type;
2384-
stginfo->ffi_type_pointer.elements = PyMem_Malloc(els_size);
2385-
memcpy(stginfo->ffi_type_pointer.elements,
2386-
fmt->pffi_type->elements, els_size);
2402+
if (set_stginfo_ffi_type_pointer(stginfo, fmt)) {
2403+
goto error;
23872404
}
23882405
stginfo->align = fmt->pffi_type->alignment;
23892406
stginfo->length = 0;

‎Modules/_ctypes/cfield.c‎

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -792,6 +792,44 @@ D_get(void *ptr, Py_ssize_t size)
792792
return PyComplex_FromDoubles(x[0], x[1]);
793793
}
794794

795+
static PyObject *
796+
D_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
797+
{
798+
assert(NUM_BITS(size) || (size == 2*sizeof(double)));
799+
Py_complex c = PyComplex_AsCComplex(value);
800+
801+
if (c.real == -1 && PyErr_Occurred()) {
802+
return NULL;
803+
}
804+
#ifdef WORDS_BIGENDIAN
805+
if (PyFloat_Pack8(c.real, ptr, 1)
806+
|| PyFloat_Pack8(c.imag, ptr + sizeof(double), 1))
807+
{
808+
return NULL;
809+
}
810+
#else
811+
if (PyFloat_Pack8(c.real, ptr, 0)
812+
|| PyFloat_Pack8(c.imag, ptr + sizeof(double), 0))
813+
{
814+
return NULL;
815+
}
816+
#endif
817+
_RET(value);
818+
}
819+
820+
static PyObject *
821+
D_get_sw(void *ptr, Py_ssize_t size)
822+
{
823+
assert(NUM_BITS(size) || (size == 2*sizeof(double)));
824+
#ifdef WORDS_BIGENDIAN
825+
return PyComplex_FromDoubles(PyFloat_Unpack8(ptr, 1),
826+
PyFloat_Unpack8(ptr + sizeof(double), 1));
827+
#else
828+
return PyComplex_FromDoubles(PyFloat_Unpack8(ptr, 0),
829+
PyFloat_Unpack8(ptr + sizeof(double), 0));
830+
#endif
831+
}
832+
795833
/* F: float complex */
796834
static PyObject *
797835
F_set(void *ptr, PyObject *value, Py_ssize_t size)
@@ -817,6 +855,44 @@ F_get(void *ptr, Py_ssize_t size)
817855
return PyComplex_FromDoubles(x[0], x[1]);
818856
}
819857

858+
static PyObject *
859+
F_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
860+
{
861+
assert(NUM_BITS(size) || (size == 2*sizeof(float)));
862+
Py_complex c = PyComplex_AsCComplex(value);
863+
864+
if (c.real == -1 && PyErr_Occurred()) {
865+
return NULL;
866+
}
867+
#ifdef WORDS_BIGENDIAN
868+
if (PyFloat_Pack4(c.real, ptr, 1)
869+
|| PyFloat_Pack4(c.imag, ptr + sizeof(float), 1))
870+
{
871+
return NULL;
872+
}
873+
#else
874+
if (PyFloat_Pack4(c.real, ptr, 0)
875+
|| PyFloat_Pack4(c.imag, ptr + sizeof(float), 0))
876+
{
877+
return NULL;
878+
}
879+
#endif
880+
_RET(value);
881+
}
882+
883+
static PyObject *
884+
F_get_sw(void *ptr, Py_ssize_t size)
885+
{
886+
assert(NUM_BITS(size) || (size == 2*sizeof(float)));
887+
#ifdef WORDS_BIGENDIAN
888+
return PyComplex_FromDoubles(PyFloat_Unpack4(ptr, 1),
889+
PyFloat_Unpack4(ptr + sizeof(float), 1));
890+
#else
891+
return PyComplex_FromDoubles(PyFloat_Unpack4(ptr, 0),
892+
PyFloat_Unpack4(ptr + sizeof(float), 0));
893+
#endif
894+
}
895+
820896
/* G: long double complex */
821897
static PyObject *
822898
G_set(void *ptr, PyObject *value, Py_ssize_t size)
@@ -1602,7 +1678,9 @@ for base_code, base_c_type in [
16021678
#if defined(_Py_FFI_SUPPORT_C_COMPLEX)
16031679
if (Py_FFI_COMPLEX_AVAILABLE) {
16041680
TABLE_ENTRY(D, &ffi_type_complex_double);
1681+
TABLE_ENTRY_SW(D, &ffi_type_complex_double);
16051682
TABLE_ENTRY(F, &ffi_type_complex_float);
1683+
TABLE_ENTRY_SW(F, &ffi_type_complex_float);
16061684
TABLE_ENTRY(G, &ffi_type_complex_longdouble);
16071685
}
16081686
#endif

0 commit comments

Comments
 (0)
⚡