#endif
PyAPI_FUNC(PyObject *) PyInt_FromLong(long);
PyAPI_FUNC(long) PyInt_AsLong(PyObject *);
+PyAPI_FUNC(unsigned long) PyInt_AsUnsignedLongMask(PyObject *);
+#ifdef HAVE_LONG_LONG
+PyAPI_FUNC(unsigned PY_LONG_LONG) PyInt_AsUnsignedLongLongMask(PyObject *);
+#endif
+
PyAPI_FUNC(long) PyInt_GetMax(void);
/* Macro, trading safety for speed */
PyAPI_FUNC(PyObject *) PyLong_FromDouble(double);
PyAPI_FUNC(long) PyLong_AsLong(PyObject *);
PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLong(PyObject *);
+PyAPI_FUNC(unsigned long) PyLong_AsUnsignedLongMask(PyObject *);
/* _PyLong_AsScaledDouble returns a double x and an exponent e such that
the true value is approximately equal to x * 2**(SHIFT*e). e is >= 0.
PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG);
PyAPI_FUNC(PY_LONG_LONG) PyLong_AsLongLong(PyObject *);
PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLong(PyObject *);
+PyAPI_FUNC(unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLongMask(PyObject *);
#endif /* HAVE_LONG_LONG */
PyAPI_FUNC(PyObject *) PyLong_FromString(char *, char **, int);
--- /dev/null
+import unittest
+from test import test_support
+import sys
+
+import warnings, re
+warnings.filterwarnings("ignore", category=DeprecationWarning, module=__name__)
+
+"""
+> How about the following counterproposal. This also changes some of
+> the other format codes to be a little more regular.
+>
+> Code C type Range check
+>
+> b unsigned char 0..UCHAR_MAX
+> h unsigned short 0..USHRT_MAX
+> B unsigned char none **
+> H unsigned short none **
+> k * unsigned long none
+> I * unsigned int 0..UINT_MAX
+
+
+> i int INT_MIN..INT_MAX
+> l long LONG_MIN..LONG_MAX
+
+> K * unsigned long long none
+> L long long LLONG_MIN..LLONG_MAX
+
+> Notes:
+>
+> * New format codes.
+>
+> ** Changed from previous "range-and-a-half" to "none"; the
+> range-and-a-half checking wasn't particularly useful.
+
+Plus a C API or two, e.g. PyInt_AsLongMask() ->
+unsigned long and PyInt_AsLongLongMask() -> unsigned
+long long (if that exists).
+"""
+
+LARGE = 0x7FFFFFFF
+VERY_LARGE = 0xFF0000121212121212121242L
+
+from _testcapi import UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, INT_MAX, \
+ INT_MIN, LONG_MIN, LONG_MAX
+
+from _testcapi import getargs_ul as ul_convert
+from _testcapi import getargs_l as l_convert
+try:
+ from _testcapi import getargs_ll as ll_convert
+ from _testcapi import getargs_ull as ull_convert
+except ImportError:
+ pass
+
+# fake, they are not defined in Python's header files
+LLONG_MAX = 2**63-1
+LLONG_MIN = -2**63
+ULLONG_MAX = 2**64-1
+
+class Long:
+ def __int__(self):
+ return 99L
+
+class Int:
+ def __int__(self):
+ return 99
+
+class Unsigned_TestCase(unittest.TestCase):
+ def test_b(self):
+ # b returns 'unsigned char', and does range checking (0 ... UCHAR_MAX)
+ self.failUnlessEqual(3, ul_convert("b", 3.14))
+ self.failUnlessEqual(99, ul_convert("b", Long()))
+ self.failUnlessEqual(99, ul_convert("b", Int()))
+
+ self.assertRaises(OverflowError, ul_convert, "b", -1)
+ self.failUnlessEqual(0, ul_convert("b", 0))
+ self.failUnlessEqual(UCHAR_MAX, ul_convert("b", UCHAR_MAX))
+ self.assertRaises(OverflowError, ul_convert, "b", UCHAR_MAX + 1)
+
+ self.failUnlessEqual(42, ul_convert("b", 42))
+ self.failUnlessEqual(42, ul_convert("b", 42L))
+ self.assertRaises(OverflowError, ul_convert, "b", VERY_LARGE)
+
+ def test_h(self):
+ # h returns 'unsigned short', and does range checking (0 ... USHRT_MAX)
+ self.failUnlessEqual(3, ul_convert("h", 3.14))
+ self.failUnlessEqual(99, ul_convert("h", Long()))
+ self.failUnlessEqual(99, ul_convert("h", Int()))
+
+ self.assertRaises(OverflowError, ul_convert, "h", -1)
+ self.failUnlessEqual(0, ul_convert("h", 0))
+ self.failUnlessEqual(USHRT_MAX, ul_convert("h", USHRT_MAX))
+ self.assertRaises(OverflowError, ul_convert, "h", USHRT_MAX+1)
+
+ self.failUnlessEqual(42, ul_convert("h", 42))
+ self.failUnlessEqual(42, ul_convert("h", 42L))
+ self.assertRaises(OverflowError, ul_convert, "h", VERY_LARGE)
+
+ def test_B(self):
+ # B returns 'unsigned char', no range checking
+ self.failUnless(3 == ul_convert("B", 3.14))
+ self.failUnlessEqual(99, ul_convert("B", Long()))
+ self.failUnlessEqual(99, ul_convert("B", Int()))
+
+ self.failUnlessEqual(UCHAR_MAX, ul_convert("B", -1))
+ self.failUnlessEqual(UCHAR_MAX, ul_convert("B", -1L))
+ self.failUnlessEqual(0, ul_convert("B", 0))
+ self.failUnlessEqual(UCHAR_MAX, ul_convert("B", UCHAR_MAX))
+ self.failUnlessEqual(0, ul_convert("B", UCHAR_MAX+1))
+
+ self.failUnlessEqual(42, ul_convert("B", 42))
+ self.failUnlessEqual(42, ul_convert("B", 42L))
+ self.failUnlessEqual(UCHAR_MAX & VERY_LARGE, ul_convert("B", VERY_LARGE))
+
+ def test_H(self):
+ # H returns 'unsigned short', no range checking
+ self.failUnlessEqual(3, ul_convert("H", 3.14))
+ self.failUnlessEqual(99, ul_convert("H", Long()))
+ self.failUnlessEqual(99, ul_convert("H", Int()))
+
+ self.failUnlessEqual(USHRT_MAX, ul_convert("H", -1))
+ self.failUnlessEqual(0, ul_convert("H", 0))
+ self.failUnlessEqual(USHRT_MAX, ul_convert("H", USHRT_MAX))
+ self.failUnlessEqual(0, ul_convert("H", USHRT_MAX+1))
+
+ self.failUnlessEqual(42, ul_convert("H", 42))
+ self.failUnlessEqual(42, ul_convert("H", 42L))
+
+ self.failUnlessEqual(VERY_LARGE & USHRT_MAX, ul_convert("H", VERY_LARGE))
+
+ def test_I(self):
+ # I returns 'unsigned int', no range checking
+ self.failUnlessEqual(3, ul_convert("I", 3.14))
+ self.failUnlessEqual(99, ul_convert("I", Long()))
+ self.failUnlessEqual(99, ul_convert("I", Int()))
+
+ self.failUnlessEqual(UINT_MAX, ul_convert("I", -1))
+ self.failUnlessEqual(0, ul_convert("I", 0))
+ self.failUnlessEqual(UINT_MAX, ul_convert("I", UINT_MAX))
+ self.failUnlessEqual(0, ul_convert("I", UINT_MAX+1))
+
+ self.failUnlessEqual(42, ul_convert("I", 42))
+ self.failUnlessEqual(42, ul_convert("I", 42L))
+
+ self.failUnlessEqual(VERY_LARGE & UINT_MAX, ul_convert("I", VERY_LARGE))
+
+ def test_k(self):
+ # k returns 'unsigned long', no range checking
+ # it does not accept float, or instances with __int__
+ self.assertRaises(TypeError, ul_convert, "k", 3.14)
+ self.assertRaises(TypeError, ul_convert, "k", Long())
+ self.assertRaises(TypeError, ul_convert, "k", Int())
+
+ self.failUnlessEqual(ULONG_MAX, ul_convert("k", -1))
+ self.failUnlessEqual(0, ul_convert("k", 0))
+ self.failUnlessEqual(ULONG_MAX, ul_convert("k", ULONG_MAX))
+ self.failUnlessEqual(0, ul_convert("k", ULONG_MAX+1))
+
+ self.failUnlessEqual(42, ul_convert("k", 42))
+ self.failUnlessEqual(42, ul_convert("k", 42L))
+
+ self.failUnlessEqual(VERY_LARGE & ULONG_MAX, ul_convert("k", VERY_LARGE))
+
+class Signed_TestCase(unittest.TestCase):
+ def test_i(self):
+ # i returns 'int', and does range checking (INT_MIN ... INT_MAX)
+ self.failUnlessEqual(3, l_convert("i", 3.14))
+ self.failUnlessEqual(99, l_convert("i", Long()))
+ self.failUnlessEqual(99, l_convert("i", Int()))
+
+ self.assertRaises(OverflowError, l_convert, "i", INT_MIN-1)
+ self.failUnlessEqual(INT_MIN, l_convert("i", INT_MIN))
+ self.failUnlessEqual(INT_MAX, l_convert("i", INT_MAX))
+ self.assertRaises(OverflowError, l_convert, "i", INT_MAX+1)
+
+ self.failUnlessEqual(42, l_convert("i", 42))
+ self.failUnlessEqual(42, l_convert("i", 42L))
+ self.assertRaises(OverflowError, l_convert, "i", VERY_LARGE)
+
+ def test_l(self):
+ # l returns 'long', and does range checking (LONG_MIN ... LONG_MAX)
+ self.failUnlessEqual(3, l_convert("l", 3.14))
+ self.failUnlessEqual(99, l_convert("l", Long()))
+ self.failUnlessEqual(99, l_convert("l", Int()))
+
+ self.assertRaises(OverflowError, l_convert, "l", LONG_MIN-1)
+ self.failUnlessEqual(LONG_MIN, l_convert("l", LONG_MIN))
+ self.failUnlessEqual(LONG_MAX, l_convert("l", LONG_MAX))
+ self.assertRaises(OverflowError, l_convert, "l", LONG_MAX+1)
+
+ self.failUnlessEqual(42, l_convert("l", 42))
+ self.failUnlessEqual(42, l_convert("l", 42L))
+ self.assertRaises(OverflowError, l_convert, "l", VERY_LARGE)
+
+
+class LongLong_TestCase(unittest.TestCase):
+ def test_L(self):
+ # L returns 'long long', and does range checking (LLONG_MIN ... LLONG_MAX)
+
+ # XXX There's a bug in getargs.c, format code "L":
+ # If you pass something else than a Python long, you
+ # get "Bad argument to internal function".
+
+ # So these three tests are commented out:
+
+## self.failUnlessEqual(3, ll_convert("L", 3.14))
+## self.failUnlessEqual(99, ll_convert("L", Long()))
+## self.failUnlessEqual(99, ll_convert("L", Int()))
+
+ self.assertRaises(OverflowError, ll_convert, "L", LLONG_MIN-1)
+ self.failUnlessEqual(LLONG_MIN, ll_convert("L", LLONG_MIN))
+ self.failUnlessEqual(LLONG_MAX, ll_convert("L", LLONG_MAX))
+ self.assertRaises(OverflowError, ll_convert, "L", LLONG_MAX+1)
+
+ self.failUnlessEqual(42, ll_convert("L", 42))
+ self.failUnlessEqual(42, ll_convert("L", 42L))
+ self.assertRaises(OverflowError, ll_convert, "L", VERY_LARGE)
+
+ def test_K(self):
+ # K return 'unsigned long long', no range checking
+ self.assertRaises(TypeError, ull_convert, "K", 3.14)
+ self.assertRaises(TypeError, ull_convert, "K", Long())
+ self.assertRaises(TypeError, ull_convert, "K", Int())
+ self.failUnlessEqual(ULLONG_MAX, ull_convert("K", ULLONG_MAX))
+ self.failUnlessEqual(0, ull_convert("K", 0))
+ self.failUnlessEqual(0, ull_convert("K", ULLONG_MAX+1))
+
+ self.failUnlessEqual(42, ull_convert("K", 42))
+ self.failUnlessEqual(42, ull_convert("K", 42L))
+
+ self.failUnlessEqual(VERY_LARGE & ULLONG_MAX, ull_convert("K", VERY_LARGE))
+
+def test_main():
+ suite = unittest.TestSuite()
+ suite.addTest(unittest.makeSuite(Signed_TestCase))
+ suite.addTest(unittest.makeSuite(Unsigned_TestCase))
+ try:
+ ll_convert
+ except NameError:
+ pass # PY_LONG_LONG not available
+ else:
+ suite.addTest(unittest.makeSuite(LongLong_TestCase))
+ test_support.run_suite(suite)
+
+if __name__ == "__main__":
+ test_main()
#endif /* ifdef HAVE_LONG_LONG */
+/* Call PyArg_ParseTuple, and return the result as unsigned long */
+static PyObject *
+getargs_ul(PyObject *self, PyObject *args)
+{
+ PyObject *ob, *result = NULL, *argtuple;
+ char *fmt;
+ unsigned long value = 0;
+
+ if (!PyArg_ParseTuple(args, "sO", &fmt, &ob))
+ return NULL;
+ argtuple = PyTuple_New(1);
+ Py_INCREF(ob);
+ PyTuple_SET_ITEM(argtuple, 0, ob);
+ if (PyArg_ParseTuple(argtuple, fmt, &value))
+ result = PyLong_FromUnsignedLong(value);
+ Py_DECREF(argtuple);
+ return result;
+}
+
+/* Call PyArg_ParseTuple, and return the result as signed long */
+static PyObject *
+getargs_l(PyObject *self, PyObject *args)
+{
+ PyObject *ob, *result = NULL, *argtuple;
+ char *fmt;
+ long value = 0;
+
+ if (!PyArg_ParseTuple(args, "sO", &fmt, &ob))
+ return NULL;
+ argtuple = PyTuple_New(1);
+ Py_INCREF(ob);
+ PyTuple_SET_ITEM(argtuple, 0, ob);
+ if (PyArg_ParseTuple(argtuple, fmt, &value))
+ result = PyLong_FromLong(value);
+ Py_DECREF(argtuple);
+ return result;
+}
+
+#ifdef HAVE_LONG_LONG
+/* Call PyArg_ParseTuple, and return the result as signed long long */
+static PyObject *
+getargs_ll(PyObject *self, PyObject *args)
+{
+ PyObject *ob, *result = NULL, *argtuple;
+ char *fmt;
+ PY_LONG_LONG value = 0;
+
+ if (!PyArg_ParseTuple(args, "sO", &fmt, &ob))
+ return NULL;
+ argtuple = PyTuple_New(1);
+ Py_INCREF(ob);
+ PyTuple_SET_ITEM(argtuple, 0, ob);
+ if (PyArg_ParseTuple(argtuple, fmt, &value))
+ result = PyLong_FromLongLong(value);
+ Py_DECREF(argtuple);
+ return result;
+}
+
+/* Call PyArg_ParseTuple, and return the result as unsigned long long */
+static PyObject *
+getargs_ull(PyObject *self, PyObject *args)
+{
+ PyObject *ob, *result = NULL, *argtuple;
+ char *fmt;
+ unsigned PY_LONG_LONG value = 0;
+
+ if (!PyArg_ParseTuple(args, "sO", &fmt, &ob))
+ return NULL;
+ argtuple = PyTuple_New(1);
+ Py_INCREF(ob);
+ PyTuple_SET_ITEM(argtuple, 0, ob);
+ if (PyArg_ParseTuple(argtuple, fmt, &value))
+ result = PyLong_FromUnsignedLongLong(value);
+ Py_DECREF(argtuple);
+ return result;
+}
+#endif
+
+/* This function not only tests the 'k' getargs code, but also the
+ PyInt_AsUnsignedLongMask() and PyInt_AsUnsignedLongMask() functions. */
+static PyObject *
+test_k_code(PyObject *self)
+{
+ PyObject *tuple, *num;
+ unsigned long value;
+
+ tuple = PyTuple_New(1);
+ if (tuple == NULL)
+ return NULL;
+
+ /* a number larger than UINT_MAX even on 64-bit platforms */
+ num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
+ if (num == NULL)
+ return NULL;
+
+ value = PyInt_AsUnsignedLongMask(num);
+ if (value != UINT_MAX)
+ return raiseTestError("test_k_code",
+ "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
+
+ PyTuple_SET_ITEM(tuple, 0, num);
+
+ value = -1;
+ if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
+ return NULL;
+ if (value != UINT_MAX)
+ return raiseTestError("test_k_code",
+ "k code returned wrong value for long 0xFFF...FFF");
+
+ Py_DECREF(num);
+ num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);
+ if (num == NULL)
+ return NULL;
+
+ value = PyInt_AsUnsignedLongMask(num);
+ if (value != (unsigned long)-0x42)
+ return raiseTestError("test_k_code",
+ "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
+
+ PyTuple_SET_ITEM(tuple, 0, num);
+
+ value = -1;
+ if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
+ return NULL;
+ if (value != (unsigned long)-0x42)
+ return raiseTestError("test_k_code",
+ "k code returned wrong value for long -0xFFF..000042");
+
+ Py_DECREF(tuple);
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
#ifdef Py_USING_UNICODE
/* Test the u and u# codes for PyArg_ParseTuple. May leak memory in case
{"test_dict_iteration", (PyCFunction)test_dict_iteration,METH_NOARGS},
{"test_long_api", (PyCFunction)test_long_api, METH_NOARGS},
{"test_long_numbits", (PyCFunction)test_long_numbits, METH_NOARGS},
+ {"test_k_code", (PyCFunction)test_k_code, METH_NOARGS},
+ {"getargs_ul", (PyCFunction)getargs_ul, METH_VARARGS},
+ {"getargs_l", (PyCFunction)getargs_l, METH_VARARGS},
#ifdef HAVE_LONG_LONG
+ {"getargs_ll", (PyCFunction)getargs_ll, METH_VARARGS},
+ {"getargs_ull", (PyCFunction)getargs_ull, METH_VARARGS},
{"test_longlong_api", (PyCFunction)test_longlong_api, METH_NOARGS},
{"test_L_code", (PyCFunction)test_L_code, METH_NOARGS},
#endif
{NULL, NULL} /* sentinel */
};
+#define AddSym(d, n, f, v) {PyObject *o = f(v); PyDict_SetItemString(d, n, o); Py_DECREF(o);}
+
PyMODINIT_FUNC
init_testcapi(void)
{
m = Py_InitModule("_testcapi", TestMethods);
+ PyModule_AddObject(m, "UCHAR_MAX", PyInt_FromLong(UCHAR_MAX));
+ PyModule_AddObject(m, "USHRT_MAX", PyInt_FromLong(USHRT_MAX));
+ PyModule_AddObject(m, "UINT_MAX", PyLong_FromUnsignedLong(UINT_MAX));
+ PyModule_AddObject(m, "ULONG_MAX", PyLong_FromUnsignedLong(ULONG_MAX));
+ PyModule_AddObject(m, "INT_MIN", PyInt_FromLong(INT_MIN));
+ PyModule_AddObject(m, "LONG_MIN", PyInt_FromLong(LONG_MIN));
+ PyModule_AddObject(m, "INT_MAX", PyInt_FromLong(INT_MAX));
+ PyModule_AddObject(m, "LONG_MAX", PyInt_FromLong(LONG_MAX));
+
TestError = PyErr_NewException("_testcapi.error", NULL, NULL);
Py_INCREF(TestError);
PyModule_AddObject(m, "error", TestError);
}
else
{
+ Py_DECREF(io);
+ PyErr_SetString(PyExc_TypeError,
+ "nb_int should return int object");
+ return -1;
+ }
+ }
+
+ val = PyInt_AS_LONG(io);
+ Py_DECREF(io);
+
+ return val;
+}
+
+unsigned long
+PyInt_AsUnsignedLongMask(register PyObject *op)
+{
+ PyNumberMethods *nb;
+ PyIntObject *io;
+ unsigned long val;
+
+ if (op && PyInt_Check(op))
+ return PyInt_AS_LONG((PyIntObject*) op);
+ if (op && PyLong_Check(op))
+ return PyLong_AsUnsignedLongMask(op);
+
+ if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
+ nb->nb_int == NULL) {
+ PyErr_SetString(PyExc_TypeError, "an integer is required");
+ return -1;
+ }
+
+ io = (PyIntObject*) (*nb->nb_int) (op);
+ if (io == NULL)
+ return -1;
+ if (!PyInt_Check(io)) {
+ if (PyLong_Check(io)) {
+ val = PyLong_AsUnsignedLongMask((PyObject *)io);
+ Py_DECREF(io);
+ if (PyErr_Occurred())
+ return -1;
+ return val;
+ }
+ else
+ {
+ Py_DECREF(io);
PyErr_SetString(PyExc_TypeError,
"nb_int should return int object");
return -1;
return val;
}
+#ifdef HAVE_LONG_LONG
+unsigned PY_LONG_LONG
+PyInt_AsUnsignedLongLongMask(register PyObject *op)
+{
+ PyNumberMethods *nb;
+ PyIntObject *io;
+ unsigned PY_LONG_LONG val;
+
+ if (op && PyInt_Check(op))
+ return PyInt_AS_LONG((PyIntObject*) op);
+ if (op && PyLong_Check(op))
+ return PyLong_AsUnsignedLongLongMask(op);
+
+ if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
+ nb->nb_int == NULL) {
+ PyErr_SetString(PyExc_TypeError, "an integer is required");
+ return -1;
+ }
+
+ io = (PyIntObject*) (*nb->nb_int) (op);
+ if (io == NULL)
+ return -1;
+ if (!PyInt_Check(io)) {
+ if (PyLong_Check(io)) {
+ val = PyLong_AsUnsignedLongLongMask((PyObject *)io);
+ Py_DECREF(io);
+ if (PyErr_Occurred())
+ return -1;
+ return val;
+ }
+ else
+ {
+ Py_DECREF(io);
+ PyErr_SetString(PyExc_TypeError,
+ "nb_int should return int object");
+ return -1;
+ }
+ }
+
+ val = PyInt_AS_LONG(io);
+ Py_DECREF(io);
+
+ return val;
+}
+#endif
+
PyObject *
PyInt_FromString(char *s, char **pend, int base)
{
return x;
}
+/* Get a C unsigned long int from a long int object, ignoring the high bits.
+ Returns -1 and sets an error condition if an error occurs. */
+
+unsigned long
+PyLong_AsUnsignedLongMask(PyObject *vv)
+{
+ register PyLongObject *v;
+ unsigned long x;
+ int i, sign;
+
+ if (vv == NULL || !PyLong_Check(vv)) {
+ PyErr_BadInternalCall();
+ return (unsigned long) -1;
+ }
+ v = (PyLongObject *)vv;
+ i = v->ob_size;
+ sign = 1;
+ x = 0;
+ if (i < 0) {
+ sign = -1;
+ i = -i;
+ }
+ while (--i >= 0) {
+ x = (x << SHIFT) + v->ob_digit[i];
+ }
+ return x * sign;
+}
+
int
_PyLong_Sign(PyObject *vv)
{
return bytes;
}
+/* Get a C unsigned long int from a long int object, ignoring the high bits.
+ Returns -1 and sets an error condition if an error occurs. */
+
+unsigned PY_LONG_LONG
+PyLong_AsUnsignedLongLongMask(PyObject *vv)
+{
+ register PyLongObject *v;
+ unsigned PY_LONG_LONG x;
+ int i, sign;
+
+ if (vv == NULL || !PyLong_Check(vv)) {
+ PyErr_BadInternalCall();
+ return (unsigned long) -1;
+ }
+ v = (PyLongObject *)vv;
+ i = v->ob_size;
+ sign = 1;
+ x = 0;
+ if (i < 0) {
+ sign = -1;
+ i = -i;
+ }
+ while (--i >= 0) {
+ x = (x << SHIFT) + v->ob_digit[i];
+ }
+ return x * sign;
+}
#undef IS_LITTLE_ENDIAN
#endif /* HAVE_LONG_LONG */
long ival;
if (float_argument_error(arg))
return NULL;
- ival = PyInt_AsLong(arg);
+ ival = PyInt_AsUnsignedLongMask(arg);
if (ival == -1 && PyErr_Occurred())
- return converterr("integer<b>", arg, msgbuf, bufsize);
- else if (ival < SCHAR_MIN) {
- PyErr_SetString(PyExc_OverflowError,
- "byte-sized integer bitfield is less than minimum");
return converterr("integer<B>", arg, msgbuf, bufsize);
- }
- else if (ival > (int)UCHAR_MAX) {
- PyErr_SetString(PyExc_OverflowError,
- "byte-sized integer bitfield is greater than maximum");
- return converterr("integer<B>", arg, msgbuf, bufsize);
- }
else
*p = (unsigned char) ival;
break;
}
- case 'h': {/* signed short int */
+ case 'h': {/* unsigned short int */
short *p = va_arg(*p_va, short *);
long ival;
if (float_argument_error(arg))
ival = PyInt_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<h>", arg, msgbuf, bufsize);
- else if (ival < SHRT_MIN) {
+ else if (ival < 0) {
PyErr_SetString(PyExc_OverflowError,
- "signed short integer is less than minimum");
+ "unsigned short integer is less than minimum");
return converterr("integer<h>", arg, msgbuf, bufsize);
}
- else if (ival > SHRT_MAX) {
+ else if (ival > USHRT_MAX) {
PyErr_SetString(PyExc_OverflowError,
- "signed short integer is greater than maximum");
+ "unsigned short integer is greater than maximum");
return converterr("integer<h>", arg, msgbuf, bufsize);
}
else
long ival;
if (float_argument_error(arg))
return NULL;
- ival = PyInt_AsLong(arg);
+ ival = PyInt_AsUnsignedLongMask(arg);
if (ival == -1 && PyErr_Occurred())
return converterr("integer<H>", arg, msgbuf, bufsize);
- else if (ival < SHRT_MIN) {
- PyErr_SetString(PyExc_OverflowError,
- "short integer bitfield is less than minimum");
- return converterr("integer<H>", arg, msgbuf, bufsize);
- }
- else if (ival > USHRT_MAX) {
- PyErr_SetString(PyExc_OverflowError,
- "short integer bitfield is greater than maximum");
- return converterr("integer<H>", arg, msgbuf, bufsize);
- }
else
*p = (unsigned short) ival;
break;
break;
}
+ case 'I': { /* int sized bitfield, both signed and
+ unsigned allowed */
+ unsigned int *p = va_arg(*p_va, unsigned int *);
+ unsigned int ival;
+ if (float_argument_error(arg))
+ return NULL;
+ ival = PyInt_AsUnsignedLongMask(arg);
+ if (ival == -1 && PyErr_Occurred())
+ return converterr("integer<I>", arg, msgbuf, bufsize);
+ else
+ *p = ival;
+ break;
+ }
+
case 'l': {/* long int */
long *p = va_arg(*p_va, long *);
long ival;
*p = ival;
break;
}
+
+ case 'k': { /* long sized bitfield */
+ unsigned long *p = va_arg(*p_va, unsigned long *);
+ unsigned long ival;
+ if (PyInt_Check(arg))
+ ival = PyInt_AsUnsignedLongMask(arg);
+ else if (PyLong_Check(arg))
+ ival = PyLong_AsUnsignedLongMask(arg);
+ else
+ return converterr("integer<k>", arg, msgbuf, bufsize);
+ *p = ival;
+ break;
+ }
#ifdef HAVE_LONG_LONG
case 'L': {/* PY_LONG_LONG */
}
break;
}
+
+ case 'K': { /* long long sized bitfield */
+ unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *);
+ unsigned PY_LONG_LONG ival;
+ if (float_argument_error(arg))
+ return NULL;
+ if (PyInt_Check(arg))
+ ival = PyInt_AsUnsignedLongMask(arg);
+ else if (PyLong_Check(arg))
+ ival = PyLong_AsUnsignedLongLongMask(arg);
+ else
+ return converterr("integer<K>", arg, msgbuf, bufsize);
+ *p = ival;
+ break;
+ }
#endif
case 'f': {/* float */
projects / python / commitdiff