address review: use native types

Author: skirpichev

Lib/test/test_ctypes/test_pep3118.py

@@ -119,15 +119,15 @@ class Complete(Structure):
 #
 
 # Platform-specific type codes
-s_bool = {1: '?', 2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_bool)]
-s_short = {2: 'h', 4: 'l', 8: 'q'}[sizeof(c_short)]
-s_ushort = {2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_ushort)]
-s_int = {2: 'h', 4: 'i', 8: 'q'}[sizeof(c_int)]
-s_uint = {2: 'H', 4: 'I', 8: 'Q'}[sizeof(c_uint)]
-s_long = {4: 'l', 8: 'q'}[sizeof(c_long)]
-s_ulong = {4: 'L', 8: 'Q'}[sizeof(c_ulong)]
-s_longlong = "q"
-s_ulonglong = "Q"
+s_bool = c_bool._type_
+s_short = c_short._type_
+s_ushort = c_ushort._type_
+s_int = c_int._type_
+s_uint = c_uint._type_
+s_long = c_long._type_
+s_ulong = c_ulong._type_
+s_longlong = c_longlong._type_
+s_ulonglong = c_ulonglong._type_
 s_float = "f"
 s_double = "d"
 s_longdouble = "g"
@@ -194,9 +194,9 @@ class Complete(Structure):
     (Point,                     "T{l:x:l:y:}".replace('l', s_long),   (),  Point),
     (PackedPoint,               "T{l:x:l:y:}".replace('l', s_long),   (),  PackedPoint),
     (PointMidPad,               "T{b:x:3xI:y:}".replace('I', s_uint), (),  PointMidPad),
-    (PackedPointMidPad,         "T{b:x:xQ:y:}",                       (),  PackedPointMidPad),
+    (PackedPointMidPad,         "T{b:x:xQ:y:}".replace('Q', s_ulonglong),                       (),  PackedPointMidPad),
     (PointEndPad,               "T{I:x:b:y:3x}".replace('I', s_uint), (),  PointEndPad),
-    (PackedPointEndPad,         "T{Q:x:b:y:x}",                       (),  PackedPointEndPad),
+    (PackedPointEndPad,         "T{Q:x:b:y:x}".replace('Q', s_ulonglong),                       (),  PackedPointEndPad),
     (EmptyStruct,               "T{}",                                (),  EmptyStruct),
     # the pep doesn't support unions
     (aUnion,                    "B",                                  (),  aUnion),
@@ -229,21 +229,24 @@ class LEPoint(LittleEndianStructure):
     _fields_ = [("x", c_long), ("y", c_long)]
 
 
+s_long2 = {4: 'l', 8: 'q'}[sizeof(c_long)]
+
+
 # This table contains format strings as they really look, on both big
 # and little endian machines.
 if sys.byteorder == "little":
     endian_types = [
-            (BEPoint, "T{>l:x:>l:y:}".replace('l', s_long), (), BEPoint),
-            (LEPoint * 1, "T{l:x:l:y:}".replace('l', s_long), (1,), LEPoint),
-            (POINTER(BEPoint), "&T{>l:x:>l:y:}".replace('l', s_long), (), POINTER(BEPoint)),
-            (POINTER(LEPoint), "&T{l:x:l:y:}".replace('l', s_long), (), POINTER(LEPoint)),
+            (BEPoint, "T{>l:x:>l:y:}".replace('l', s_long2), (), BEPoint),
+            (LEPoint * 1, "T{l:x:l:y:}", (1,), LEPoint),
+            (POINTER(BEPoint), "&T{>l:x:>l:y:}".replace('l', s_long2), (), POINTER(BEPoint)),
+            (POINTER(LEPoint), "&T{l:x:l:y:}", (), POINTER(LEPoint)),
             ]
 else:
     endian_types = [
-            (BEPoint * 1, "T{l:x:l:y:}".replace('l', s_long), (1,), BEPoint),
-            (LEPoint, "T{<l:x:<l:y:}".replace('l', s_long), (), LEPoint),
-            (POINTER(BEPoint), "&T{l:x:l:y:}".replace('l', s_long), (), POINTER(BEPoint)),
-            (POINTER(LEPoint), "&T{<l:x:<l:y:}".replace('l', s_long), (), POINTER(LEPoint)),
+            (BEPoint * 1, "T{l:x:l:y:}", (1,), BEPoint),
+            (LEPoint, "T{<l:x:<l:y:}".replace('l', s_long2), (), LEPoint),
+            (POINTER(BEPoint), "&T{l:x:l:y:}", (), POINTER(BEPoint)),
+            (POINTER(LEPoint), "&T{<l:x:<l:y:}".replace('l', s_long2), (), POINTER(LEPoint)),
             ]
 
 

Modules/_ctypes/_ctypes.c

@@ -267,7 +267,7 @@ _PyDict_GetItemProxy(PyObject *dict, PyObject *key, PyObject **presult)
   later on.
  */
 static char *
-_ctypes_alloc_format_string_for_type(const char *code)
+_ctypes_alloc_format_string_for_type(const char *code, int big_endian)
 {
     const char *pep_code = NULL;
 
@@ -310,13 +310,14 @@ _ctypes_alloc_format_string_for_type(const char *code)
         break;
     }
 
-    char *result = PyMem_Malloc(1 + strlen(pep_code));
+    char *result = PyMem_Malloc(1 + strlen(pep_code) + 1);
     if (result == NULL) {
         PyErr_NoMemory();
         return NULL;
     }
 
-    strcpy(result, pep_code);
+    result[0] = big_endian ? '>' : '<';
+    strcpy(result + 1, pep_code);
     return result;
 }
 
@@ -2404,11 +2405,12 @@ PyCSimpleType_init(PyObject *self, PyObject *args, PyObject *kwds)
     stginfo->size = fmt->pffi_type->size;
     stginfo->setfunc = fmt->setfunc;
     stginfo->getfunc = fmt->getfunc;
-    stginfo->format = _ctypes_alloc_format_string_for_type(proto_str);
+    stginfo->format = PyMem_Malloc(1 + strlen(proto_str));
     if (stginfo->format == NULL) {
         Py_DECREF(proto);
         return -1;
     }
+    strcpy(stginfo->format, proto_str);
 
     stginfo->paramfunc = PyCSimpleType_paramfunc;
 /*
@@ -2499,14 +2501,14 @@ PyCSimpleType_init(PyObject *self, PyObject *args, PyObject *kwds)
         PyObject_SetAttrString(swapped, "__ctype_be__", self);
         PyObject_SetAttrString(swapped, "__ctype_le__", swapped);
         /* We are creating the type for the OTHER endian */
-        sw_info->format = _ctypes_alloc_format_string("<", stginfo->format);
+        sw_info->format = _ctypes_alloc_format_string_for_type(stginfo->format, 0);
 #else
         PyObject_SetAttrString(self, "__ctype_be__", swapped);
         PyObject_SetAttrString(self, "__ctype_le__", self);
         PyObject_SetAttrString(swapped, "__ctype_le__", self);
         PyObject_SetAttrString(swapped, "__ctype_be__", swapped);
         /* We are creating the type for the OTHER endian */
-        sw_info->format = _ctypes_alloc_format_string(">", stginfo->format);
+        sw_info->format = _ctypes_alloc_format_string_for_type(stginfo->format, 1);
 #endif
         Py_DECREF(swapped);
         if (PyErr_Occurred()) {