# HG changeset patch
# User Pauli Virtanen <pav@iki.fi>
# Date 1292888028 -3600
# Branch py3k
# Node ID 552e05fc2efbfa0600f53a310bf0aec9aab30990
# Parent  dd49a99921679e986b171747826ec5e962c0816e
ctypes: Fix PEP 3118 type codes for c_long and c_bool

diff -r dd49a9992167 -r 552e05fc2efb Lib/ctypes/test/test_pep3118.py
--- a/Lib/ctypes/test/test_pep3118.py	Mon Dec 20 23:03:47 2010 +0100
+++ b/Lib/ctypes/test/test_pep3118.py	Tue Dec 21 00:33:48 2010 +0100
@@ -103,11 +103,31 @@
 PComplete = POINTER(Complete)
 Complete._fields_ = [("a", c_long)]
 
+def fmt_code(fmt):
+    """Adjust the PEP 3118 type code according to the platform"""
+    import ctypes
+    if ctypes.sizeof(ctypes.c_long) == 8:
+        fmt = fmt.replace('<l', '<q')
+        fmt = fmt.replace('<L', '<Q')
+        fmt = fmt.replace('>l', '>q')
+        fmt = fmt.replace('>L', '>Q')
+    if ctypes.sizeof(ctypes.c_bool) == 2:
+        fmt = fmt.replace('<?', '<H')
+        fmt = fmt.replace('>?', '>H')
+    if ctypes.sizeof(ctypes.c_bool) == 4:
+        fmt = fmt.replace('<?', '<L')
+        fmt = fmt.replace('>?', '>L')
+    if ctypes.sizeof(ctypes.c_bool) == 8:
+        fmt = fmt.replace('<?', '<Q')
+        fmt = fmt.replace('>?', '>Q')
+    return fmt
+
 ################################################################
 #
 # This table contains format strings as they look on little endian
 # machines.  The test replaces '<' with '>' on big endian machines.
 #
+
 native_types = [
     # type                      format                  shape           calc itemsize
 
@@ -123,8 +143,8 @@
     #(c_int,                     "<i",                   None,           c_int),
     #(c_uint,                    "<I",                   None,           c_uint),
 
-    (c_long,                    "<l",                   None,           c_long),
-    (c_ulong,                   "<L",                   None,           c_ulong),
+    (c_long,                    fmt_code("<l"),         None,           c_long),
+    (c_ulong,                   fmt_code("<L"),         None,           c_ulong),
 
     # c_longlong and c_ulonglong are aliases on 64-bit platforms
     #(c_longlong,                "<q",                   None,           c_longlong),
@@ -134,13 +154,13 @@
     (c_double,                  "<d",                   None,           c_double),
     # c_longdouble may be an alias to c_double
 
-    (c_bool,                    "<?",                   None,           c_bool),
+    (c_bool,                    fmt_code("<?"),         None,           c_bool),
     (py_object,                 "<O",                   None,           py_object),
 
     ## pointers
 
     (POINTER(c_byte),           "&<b",                  None,           POINTER(c_byte)),
-    (POINTER(POINTER(c_long)),  "&&<l",                 None,           POINTER(POINTER(c_long))),
+    (POINTER(POINTER(c_long)),  fmt_code("&&<l"),       None,           POINTER(POINTER(c_long))),
 
     ## arrays and pointers
 
@@ -152,16 +172,16 @@
 
     ## structures and unions
 
-    (Point,                     "T{<l:x:<l:y:}",        None,           Point),
+    (Point,                     fmt_code("T{<l:x:<l:y:}"), None,           Point),
     # packed structures do not implement the pep
     (PackedPoint,               "B",                    None,           PackedPoint),
-    (Point2,                    "T{<l:x:<l:y:}",        None,           Point2),
+    (Point2,                    fmt_code("T{<l:x:<l:y:}"), None,           Point2),
     (EmptyStruct,               "T{}",                  None,           EmptyStruct),
     # the pep does't support unions
     (aUnion,                    "B",                    None,           aUnion),
     # structure with sub-arrays
-    (StructWithArrays,          "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}", None,  StructWithArrays),
-    (StructWithArrays * 3,      "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}", (3,),  StructWithArrays),
+    (StructWithArrays,          fmt_code("T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}"), None,  StructWithArrays),
+    (StructWithArrays * 3,      fmt_code("T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}"), (3,),  StructWithArrays),
 
     ## pointer to incomplete structure
     (Incomplete,                "B",                    None,           Incomplete),
@@ -169,7 +189,7 @@
 
     # 'Complete' is a structure that starts incomplete, but is completed after the
     # pointer type to it has been created.
-    (Complete,                  "T{<l:a:}",             None,           Complete),
+    (Complete,                  fmt_code("T{<l:a:}"),   None,           Complete),
     # Unfortunately the pointer format string is not fixed...
     (POINTER(Complete),         "&B",                   None,           POINTER(Complete)),
 
@@ -192,10 +212,10 @@
 # and little endian machines.
 #
 endian_types = [
-    (BEPoint,                   "T{>l:x:>l:y:}",        None,           BEPoint),
-    (LEPoint,                   "T{<l:x:<l:y:}",        None,           LEPoint),
-    (POINTER(BEPoint),          "&T{>l:x:>l:y:}",       None,           POINTER(BEPoint)),
-    (POINTER(LEPoint),          "&T{<l:x:<l:y:}",       None,           POINTER(LEPoint)),
+    (BEPoint,          fmt_code("T{>l:x:>l:y:}"),        None,           BEPoint),
+    (LEPoint,          fmt_code("T{<l:x:<l:y:}"),        None,           LEPoint),
+    (POINTER(BEPoint), fmt_code("&T{>l:x:>l:y:}"),       None,           POINTER(BEPoint)),
+    (POINTER(LEPoint), fmt_code("&T{<l:x:<l:y:}"),       None,           POINTER(LEPoint)),
     ]
 
 if __name__ == "__main__":
diff -r dd49a9992167 -r 552e05fc2efb Modules/_ctypes/_ctypes.c
--- a/Modules/_ctypes/_ctypes.c	Mon Dec 20 23:03:47 2010 +0100
+++ b/Modules/_ctypes/_ctypes.c	Tue Dec 21 00:33:48 2010 +0100
@@ -258,6 +258,55 @@
 }
 
 /******************************************************************/
+
+/*
+  Allocate a memory block for a pep3118 format string, filled with
+  a suitable PEP 3118 type code corresponding to the given ctypes
+  type. Returns NULL on failure, with the error indicator set.
+
+  This produces type codes in the standard size mode (cf. struct module),
+  since the endianness may need to be swapped to a non-native one
+  later on.
+ */
+char *
+_ctypes_alloc_format_string_for_type(char code, int big_endian)
+{
+    char *result;
+    char pep_code = '\0';
+
+    switch (code) {
+#if SIZEOF_LONG == 8
+    case 'l': pep_code = 'q'; break;
+    case 'L': pep_code = 'Q'; break;
+#elif SIZEOF_LONG == 4
+#else
+# error
+#endif /* SIZEOF_LONG */
+#if SIZEOF__BOOL == 1
+    case '?': pep_code = '?'; break;
+#elif SIZEOF__BOOL == 2
+    case '?': pep_code = 'H'; break;
+#elif SIZEOF__BOOL == 4
+    case '?': pep_code = 'L'; break;
+#elif SIZEOF__BOOL == 8
+    case '?': pep_code = 'Q'; break;
+#endif /* SIZEOF__BOOL */
+    default:
+        /* fall-through */
+        pep_code = code;
+        break;
+    }
+
+    result = PyMem_Malloc(3);
+    if (result == NULL)
+        return NULL;
+
+    result[0] = big_endian ? '>' : '<';
+    result[1] = pep_code;
+    result[2] = '\0';
+    return result;
+}
+
 /*
   Allocate a memory block for a pep3118 format string, copy prefix (if
   non-null) and suffix into it.  Returns NULL on failure, with the error
@@ -1910,9 +1959,9 @@
     stgdict->setfunc = fmt->setfunc;
     stgdict->getfunc = fmt->getfunc;
 #ifdef WORDS_BIGENDIAN
-    stgdict->format = _ctypes_alloc_format_string(">", proto_str);
+    stgdict->format = _ctypes_alloc_format_string_for_type(proto_str[0], 1);
 #else
-    stgdict->format = _ctypes_alloc_format_string("<", proto_str);
+    stgdict->format = _ctypes_alloc_format_string_for_type(proto_str[0], 0);
 #endif
     if (stgdict->format == NULL) {
         Py_DECREF(result);