long long support for array module

Modules/arraymodule.c

 /* Array object implementation */
 
 /* An array is a uniform list -- all items have the same type.
    The item type is restricted to simple C types like int or float */
 
 #define PY_SSIZE_T_CLEAN
 #include "Python.h"
 #include "structmember.h"
 
 #ifdef STDC_HEADERS
@@ skipping 335 matching lines @@
 
     }
     if (x > ULONG_MAX) {
         PyErr_SetString(PyExc_OverflowError,
             "unsigned long is greater than maximum");
         return -1;
     }
 
     if (i >= 0)
         ((unsigned long *)ap->ob_item)[i] = x;
+    return 0;
+}
+
+#ifdef HAVE_LONG_LONG
+
+static PyObject *
+q_getitem(arrayobject *ap, int i)

[skrah, 2011/09/11 10:53:59]

'int i' should be 'Py_ssize_t i' (also in other places).

[meadori, 2011/09/11 16:43:38]

Fixed.

+{
+    return PyLong_FromLongLong(((PY_LONG_LONG *)ap->ob_item)[i]);
+}
+
+static int
+q_setitem(arrayobject *ap, int i, PyObject *v)
+{
+    PY_LONG_LONG x;
+    if (!PyArg_Parse(v, "L;array item must be integer", &x))

[skrah, 2011/09/11 10:53:59]

Why not use PyLong_AsLongLong() directly. I see that existing code also uses
PyArg_Parse(), perhaps new code shouldn't.

[meadori, 2011/09/11 16:43:38]

The only reason that I can see is that 'PyArg_Parse' is more strict.  For
example, for the integer types implicit conversions from float are *not*
allowed.  If this code was changed to use 'PyLong_AsLongLong', then things like:
would work, which we don't want.

+        return -1;
+    if (i >= 0)
+        ((PY_LONG_LONG *)ap->ob_item)[i] = x;
     return 0;
 }
 
 static PyObject *
+QQ_getitem(arrayobject *ap, int i)
+{
+    return PyLong_FromUnsignedLongLong(
+        ((unsigned PY_LONG_LONG *)ap->ob_item)[i]);
+}
+
+static int
+QQ_setitem(arrayobject *ap, int i, PyObject *v)
+{
+    unsigned PY_LONG_LONG x;
+    if (PyLong_Check(v)) {
+        x = PyLong_AsUnsignedLongLong(v);
+        if (x == (unsigned PY_LONG_LONG) -1 && PyErr_Occurred())
+            return -1;
+    }
+    else {

[skrah, 2011/09/11 10:53:59]

All PyArg_Parse() does in the test suite is raise a TypeError. Is there a reason
in py3k for not raising TypeError directly in the else clause?

[This isn't a complaint, I see that it is also done in existing code.]

[meadori, 2011/09/11 16:43:38]

Maybe the tests needed extending.  Replacing this code with a TypeError would
not handle the following case correctly:

class T(object):
    def __init__(self, value):
        self.value = value

    def __int__(self):
        return self.value

array.array('Q', [T(187)])

+        PY_LONG_LONG y;
+        if (!PyArg_Parse(v, "L;array item must be integer", &y))
+            return -1;
+        if (y < 0) {
+            PyErr_SetString(PyExc_OverflowError,
+                "unsigned long long is less than minimum");
+            return -1;
+        }
+        x = (unsigned PY_LONG_LONG)y;
+    }
+
+    if (i >= 0)
+        ((unsigned PY_LONG_LONG *)ap->ob_item)[i] = x;
+    return 0;
+}
+#endif
+
+static PyObject *
 f_getitem(arrayobject *ap, Py_ssize_t i)
 {
     return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]);
 }
 
 static int
 f_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
     float x;
     if (!PyArg_Parse(v, "f;array item must be float", &x))
@@ skipping 29 matching lines @@
 static struct arraydescr descriptors[] = {
     {'b', 1, b_getitem, b_setitem, "b", 1, 1},
     {'B', 1, BB_getitem, BB_setitem, "B", 1, 0},
     {'u', sizeof(Py_UNICODE), u_getitem, u_setitem, "u", 0, 0},
     {'h', sizeof(short), h_getitem, h_setitem, "h", 1, 1},
     {'H', sizeof(short), HH_getitem, HH_setitem, "H", 1, 0},
     {'i', sizeof(int), i_getitem, i_setitem, "i", 1, 1},
     {'I', sizeof(int), II_getitem, II_setitem, "I", 1, 0},
     {'l', sizeof(long), l_getitem, l_setitem, "l", 1, 1},
     {'L', sizeof(long), LL_getitem, LL_setitem, "L", 1, 0},
+#ifdef HAVE_LONG_LONG
+    {'q', sizeof(PY_LONG_LONG), q_getitem, q_setitem, "q", 1, 1},
+    {'Q', sizeof(PY_LONG_LONG), QQ_getitem, QQ_setitem, "Q", 1, 0},
+#endif
     {'f', sizeof(float), f_getitem, f_setitem, "f", 0, 0},
     {'d', sizeof(double), d_getitem, d_setitem, "d", 0, 0},
     {'\0', 0, 0, 0, 0, 0, 0} /* Sentinel */
 };
 
 /****************************************************************************
 Implementations of array object methods.
 ****************************************************************************/
 
 static PyObject *
@@ skipping 1229 matching lines @@
         is_signed = 0;
         break;
     case 'l':
         intsize = sizeof(long);
         is_signed = 1;
         break;
     case 'L':
         intsize = sizeof(long);
         is_signed = 0;
         break;
+#if HAVE_LONG_LONG
+    case 'q':
+        intsize = sizeof(PY_LONG_LONG);
+        is_signed = 1;
+        break;
+    case 'Q':
+        intsize = sizeof(PY_LONG_LONG);
+        is_signed = 0;
+        break;
+#endif 
     default:
         return UNKNOWN_FORMAT;
     }
     switch (intsize) {
     case 2:
         return UNSIGNED_INT16_LE + is_big_endian + (2 * is_signed);
     case 4:
         return UNSIGNED_INT32_LE + is_big_endian + (2 * is_signed);
     case 8:
         return UNSIGNED_INT64_LE + is_big_endian + (2 * is_signed);
@@ skipping 826 matching lines @@
                     Py_DECREF(it);
                     Py_DECREF(a);
                     return NULL;
                 }
                 Py_DECREF(it);
             }
             return a;
         }
     }
     PyErr_SetString(PyExc_ValueError,
+#ifdef HAVE_LONG_LONG
+        "bad typecode (must be b, B, u, h, H, i, I, l, L, q, Q, f or d)");
+#else
         "bad typecode (must be b, B, u, h, H, i, I, l, L, f or d)");
+#endif
     return NULL;
 }
 
 
 PyDoc_STRVAR(module_doc,
 "This module defines an object type which can efficiently represent\n\
 an array of basic values: characters, integers, floating point\n\
 numbers.  Arrays are sequence types and behave very much like lists,\n\
 except that the type of objects stored in them is constrained.  The\n\
 type is specified at object creation time by using a type code, which\n\
 is a single character.  The following type codes are defined:\n\
 \n\
     Type code   C Type             Minimum size in bytes \n\
     'b'         signed integer     1 \n\
     'B'         unsigned integer   1 \n\
     'u'         Unicode character  2 (see note) \n\
     'h'         signed integer     2 \n\
     'H'         unsigned integer   2 \n\
     'i'         signed integer     2 \n\
     'I'         unsigned integer   2 \n\
     'l'         signed integer     4 \n\
     'L'         unsigned integer   4 \n\
+    'q'         signed integer     8 (see note) \n\
+    'Q'         unsigned integer   8 (see note) \n\
     'f'         floating point     4 \n\
     'd'         floating point     8 \n\
 \n\
-NOTE: The 'u' typecode corresponds to Python's unicode character. On \n\
+NOTE: The 'u' type code corresponds to Python's unicode character. On \n\
 narrow builds this is 2-bytes on wide builds this is 4-bytes.\n\
+\n\
+NOTE: The 'q' and 'Q' type codes are only available if the platform \n\
+C compiler used to build Python supports 'long long', or, on Windows, \n\
+'__int64'.\n\
 \n\
 The constructor is:\n\
 \n\
 array(typecode [, initializer]) -- create a new array\n\
 ");
 
 PyDoc_STRVAR(arraytype_doc,
 "array(typecode [, initializer]) -> array\n\
 \n\
 Return a new array whose items are restricted by typecode, and\n\
@@ skipping 219 matching lines @@
     }
 
     PyModule_AddObject(m, "typecodes", (PyObject *)typecodes);
 
     if (PyErr_Occurred()) {
         Py_DECREF(m);
         m = NULL;
     }
     return m;
 }