diff options
Diffstat (limited to 'Objects/longobject.c')
| -rw-r--r-- | Objects/longobject.c | 3743 |
1 files changed, 1158 insertions, 2585 deletions
diff --git a/Objects/longobject.c b/Objects/longobject.c index bc87fb2..c05f67c 100644 --- a/Objects/longobject.c +++ b/Objects/longobject.c @@ -4,105 +4,15 @@ #include "Python.h" #include "longintrepr.h" +#include "structseq.h" #include <float.h> #include <ctype.h> #include <stddef.h> -#include "clinic/longobject.c.h" -/*[clinic input] -class int "PyObject *" "&PyLong_Type" -[clinic start generated code]*/ -/*[clinic end generated code: output=da39a3ee5e6b4b0d input=ec0275e3422a36e3]*/ - -#ifndef NSMALLPOSINTS -#define NSMALLPOSINTS 257 -#endif -#ifndef NSMALLNEGINTS -#define NSMALLNEGINTS 5 -#endif - -_Py_IDENTIFIER(little); -_Py_IDENTIFIER(big); - -/* convert a PyLong of size 1, 0 or -1 to an sdigit */ -#define MEDIUM_VALUE(x) (assert(-1 <= Py_SIZE(x) && Py_SIZE(x) <= 1), \ - Py_SIZE(x) < 0 ? -(sdigit)(x)->ob_digit[0] : \ - (Py_SIZE(x) == 0 ? (sdigit)0 : \ - (sdigit)(x)->ob_digit[0])) - -PyObject *_PyLong_Zero = NULL; -PyObject *_PyLong_One = NULL; - -#if NSMALLNEGINTS + NSMALLPOSINTS > 0 -/* Small integers are preallocated in this array so that they - can be shared. - The integers that are preallocated are those in the range - -NSMALLNEGINTS (inclusive) to NSMALLPOSINTS (not inclusive). -*/ -static PyLongObject* small_ints[NSMALLNEGINTS + NSMALLPOSINTS] = {0}; - -#define IS_SMALL_INT(ival) (-NSMALLNEGINTS <= (ival) && (ival) < NSMALLPOSINTS) -#define IS_SMALL_UINT(ival) ((ival) < NSMALLPOSINTS) - -#ifdef COUNT_ALLOCS -Py_ssize_t _Py_quick_int_allocs, _Py_quick_neg_int_allocs; -#endif - -static PyObject * -get_small_int(sdigit ival) -{ - assert(IS_SMALL_INT(ival)); - PyObject *v = (PyObject*)small_ints[ival + NSMALLNEGINTS]; - Py_INCREF(v); -#ifdef COUNT_ALLOCS - if (ival >= 0) - _Py_quick_int_allocs++; - else - _Py_quick_neg_int_allocs++; -#endif - return v; -} - -static PyLongObject * -maybe_small_long(PyLongObject *v) -{ - if (v && Py_ABS(Py_SIZE(v)) <= 1) { - sdigit ival = MEDIUM_VALUE(v); - if (IS_SMALL_INT(ival)) { - Py_DECREF(v); - return (PyLongObject *)get_small_int(ival); - } - } - return v; -} -#else -#define IS_SMALL_INT(ival) 0 -#define IS_SMALL_UINT(ival) 0 -#define get_small_int(ival) (Py_UNREACHABLE(), NULL) -#define maybe_small_long(val) (val) -#endif - -/* If a freshly-allocated int is already shared, it must - be a small integer, so negating it must go to PyLong_FromLong */ -Py_LOCAL_INLINE(void) -_PyLong_Negate(PyLongObject **x_p) -{ - PyLongObject *x; - - x = (PyLongObject *)*x_p; - if (Py_REFCNT(x) == 1) { - Py_SIZE(x) = -Py_SIZE(x); - return; - } - - *x_p = (PyLongObject *)PyLong_FromLong(-MEDIUM_VALUE(x)); - Py_DECREF(x); -} - -/* For int multiplication, use the O(N**2) school algorithm unless +/* For long multiplication, use the O(N**2) school algorithm unless * both operands contain more than KARATSUBA_CUTOFF digits (this - * being an internal Python int digit, in base BASE). + * being an internal Python long digit, in base PyLong_BASE). */ #define KARATSUBA_CUTOFF 70 #define KARATSUBA_SQUARE_CUTOFF (2 * KARATSUBA_CUTOFF) @@ -114,19 +24,29 @@ _PyLong_Negate(PyLongObject **x_p) */ #define FIVEARY_CUTOFF 8 -#define SIGCHECK(PyTryBlock) \ - do { \ - if (PyErr_CheckSignals()) PyTryBlock \ +#define ABS(x) ((x) < 0 ? -(x) : (x)) + +#undef MIN +#undef MAX +#define MAX(x, y) ((x) < (y) ? (y) : (x)) +#define MIN(x, y) ((x) > (y) ? (y) : (x)) + +#define SIGCHECK(PyTryBlock) \ + do { \ + if (--_Py_Ticker < 0) { \ + _Py_Ticker = _Py_CheckInterval; \ + if (PyErr_CheckSignals()) PyTryBlock \ + } \ } while(0) -/* Normalize (remove leading zeros from) an int object. +/* Normalize (remove leading zeros from) a long int object. Doesn't attempt to free the storage--in most cases, due to the nature of the algorithms used, this could save at most be one word anyway. */ static PyLongObject * -long_normalize(PyLongObject *v) +long_normalize(register PyLongObject *v) { - Py_ssize_t j = Py_ABS(Py_SIZE(v)); + Py_ssize_t j = ABS(Py_SIZE(v)); Py_ssize_t i = j; while (i > 0 && v->ob_digit[i-1] == 0) @@ -136,124 +56,7 @@ long_normalize(PyLongObject *v) return v; } -/* _PyLong_FromNbInt: Convert the given object to a PyLongObject - using the nb_int slot, if available. Raise TypeError if either the - nb_int slot is not available or the result of the call to nb_int - returns something not of type int. -*/ -PyObject * -_PyLong_FromNbInt(PyObject *integral) -{ - PyNumberMethods *nb; - PyObject *result; - - /* Fast path for the case that we already have an int. */ - if (PyLong_CheckExact(integral)) { - Py_INCREF(integral); - return integral; - } - - nb = Py_TYPE(integral)->tp_as_number; - if (nb == NULL || nb->nb_int == NULL) { - PyErr_Format(PyExc_TypeError, - "an integer is required (got type %.200s)", - Py_TYPE(integral)->tp_name); - return NULL; - } - - /* Convert using the nb_int slot, which should return something - of exact type int. */ - result = nb->nb_int(integral); - if (!result || PyLong_CheckExact(result)) - return result; - if (!PyLong_Check(result)) { - PyErr_Format(PyExc_TypeError, - "__int__ returned non-int (type %.200s)", - result->ob_type->tp_name); - Py_DECREF(result); - return NULL; - } - /* Issue #17576: warn if 'result' not of exact type int. */ - if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - result->ob_type->tp_name)) { - Py_DECREF(result); - return NULL; - } - return result; -} - -/* Convert the given object to a PyLongObject using the nb_index or - nb_int slots, if available (the latter is deprecated). - Raise TypeError if either nb_index and nb_int slots are not - available or the result of the call to nb_index or nb_int - returns something not of type int. - Should be replaced with PyNumber_Index after the end of the - deprecation period. -*/ -PyObject * -_PyLong_FromNbIndexOrNbInt(PyObject *integral) -{ - PyNumberMethods *nb; - PyObject *result; - - /* Fast path for the case that we already have an int. */ - if (PyLong_CheckExact(integral)) { - Py_INCREF(integral); - return integral; - } - - nb = Py_TYPE(integral)->tp_as_number; - if (nb == NULL || (nb->nb_index == NULL && nb->nb_int == NULL)) { - PyErr_Format(PyExc_TypeError, - "an integer is required (got type %.200s)", - Py_TYPE(integral)->tp_name); - return NULL; - } - - if (nb->nb_index) { - /* Convert using the nb_index slot, which should return something - of exact type int. */ - result = nb->nb_index(integral); - if (!result || PyLong_CheckExact(result)) - return result; - if (!PyLong_Check(result)) { - PyErr_Format(PyExc_TypeError, - "__index__ returned non-int (type %.200s)", - result->ob_type->tp_name); - Py_DECREF(result); - return NULL; - } - /* Issue #17576: warn if 'result' not of exact type int. */ - if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__index__ returned non-int (type %.200s). " - "The ability to return an instance of a strict subclass of int " - "is deprecated, and may be removed in a future version of Python.", - result->ob_type->tp_name)) - { - Py_DECREF(result); - return NULL; - } - return result; - } - - result = _PyLong_FromNbInt(integral); - if (result && PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "an integer is required (got type %.200s). " - "Implicit conversion to integers using __int__ is deprecated, " - "and may be removed in a future version of Python.", - Py_TYPE(integral)->tp_name)) - { - Py_DECREF(result); - return NULL; - } - return result; -} - - -/* Allocate a new int object with size digits. +/* Allocate a new long int object with size digits. Return NULL and set exception if we run out of memory. */ #define MAX_LONG_DIGITS \ @@ -262,24 +65,15 @@ _PyLong_FromNbIndexOrNbInt(PyObject *integral) PyLongObject * _PyLong_New(Py_ssize_t size) { - PyLongObject *result; - /* Number of bytes needed is: offsetof(PyLongObject, ob_digit) + - sizeof(digit)*size. Previous incarnations of this code used - sizeof(PyVarObject) instead of the offsetof, but this risks being - incorrect in the presence of padding between the PyVarObject header - and the digits. */ if (size > (Py_ssize_t)MAX_LONG_DIGITS) { PyErr_SetString(PyExc_OverflowError, "too many digits in integer"); return NULL; } - result = PyObject_MALLOC(offsetof(PyLongObject, ob_digit) + - size*sizeof(digit)); - if (!result) { - PyErr_NoMemory(); - return NULL; - } - return (PyLongObject*)PyObject_INIT_VAR(result, &PyLong_Type, size); + /* coverity[ampersand_in_size] */ + /* XXX(nnorwitz): PyObject_NEW_VAR / _PyObject_VAR_SIZE need to detect + overflow */ + return PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size); } PyObject * @@ -292,12 +86,6 @@ _PyLong_Copy(PyLongObject *src) i = Py_SIZE(src); if (i < 0) i = -(i); - if (i < 2) { - sdigit ival = MEDIUM_VALUE(src); - if (IS_SMALL_INT(ival)) { - return get_small_int(ival); - } - } result = _PyLong_New(i); if (result != NULL) { Py_SIZE(result) = Py_SIZE(src); @@ -307,7 +95,7 @@ _PyLong_Copy(PyLongObject *src) return (PyObject *)result; } -/* Create a new int object from a C long int */ +/* Create a new long int object from a C long int */ PyObject * PyLong_FromLong(long ival) @@ -316,50 +104,23 @@ PyLong_FromLong(long ival) unsigned long abs_ival; unsigned long t; /* unsigned so >> doesn't propagate sign bit */ int ndigits = 0; - int sign; - - if (IS_SMALL_INT(ival)) { - return get_small_int((sdigit)ival); - } + int negative = 0; if (ival < 0) { - /* negate: can't write this as abs_ival = -ival since that - invokes undefined behaviour when ival is LONG_MIN */ - abs_ival = 0U-(unsigned long)ival; - sign = -1; + /* if LONG_MIN == -LONG_MAX-1 (true on most platforms) then + ANSI C says that the result of -ival is undefined when ival + == LONG_MIN. Hence the following workaround. */ + abs_ival = (unsigned long)(-1-ival) + 1; + negative = 1; } else { abs_ival = (unsigned long)ival; - sign = ival == 0 ? 0 : 1; } - /* Fast path for single-digit ints */ - if (!(abs_ival >> PyLong_SHIFT)) { - v = _PyLong_New(1); - if (v) { - Py_SIZE(v) = sign; - v->ob_digit[0] = Py_SAFE_DOWNCAST( - abs_ival, unsigned long, digit); - } - return (PyObject*)v; - } - -#if PyLong_SHIFT==15 - /* 2 digits */ - if (!(abs_ival >> 2*PyLong_SHIFT)) { - v = _PyLong_New(2); - if (v) { - Py_SIZE(v) = 2*sign; - v->ob_digit[0] = Py_SAFE_DOWNCAST( - abs_ival & PyLong_MASK, unsigned long, digit); - v->ob_digit[1] = Py_SAFE_DOWNCAST( - abs_ival >> PyLong_SHIFT, unsigned long, digit); - } - return (PyObject*)v; - } -#endif - - /* Larger numbers: loop to determine number of digits */ + /* Count the number of Python digits. + We used to pick 5 ("big enough for anything"), but that's a + waste of time and space given that 5*15 = 75 bits are rarely + needed. */ t = abs_ival; while (t) { ++ndigits; @@ -368,66 +129,44 @@ PyLong_FromLong(long ival) v = _PyLong_New(ndigits); if (v != NULL) { digit *p = v->ob_digit; - Py_SIZE(v) = ndigits*sign; + Py_SIZE(v) = negative ? -ndigits : ndigits; t = abs_ival; while (t) { - *p++ = Py_SAFE_DOWNCAST( - t & PyLong_MASK, unsigned long, digit); + *p++ = (digit)(t & PyLong_MASK); t >>= PyLong_SHIFT; } } return (PyObject *)v; } -#define PYLONG_FROM_UINT(INT_TYPE, ival) \ - do { \ - if (IS_SMALL_UINT(ival)) { \ - return get_small_int((sdigit)(ival)); \ - } \ - /* Count the number of Python digits. */ \ - Py_ssize_t ndigits = 0; \ - INT_TYPE t = (ival); \ - while (t) { \ - ++ndigits; \ - t >>= PyLong_SHIFT; \ - } \ - PyLongObject *v = _PyLong_New(ndigits); \ - if (v == NULL) { \ - return NULL; \ - } \ - digit *p = v->ob_digit; \ - while ((ival)) { \ - *p++ = (digit)((ival) & PyLong_MASK); \ - (ival) >>= PyLong_SHIFT; \ - } \ - return (PyObject *)v; \ - } while(0) - -/* Create a new int object from a C unsigned long int */ +/* Create a new long int object from a C unsigned long int */ PyObject * PyLong_FromUnsignedLong(unsigned long ival) { - PYLONG_FROM_UINT(unsigned long, ival); -} - -/* Create a new int object from a C unsigned long long int. */ - -PyObject * -PyLong_FromUnsignedLongLong(unsigned long long ival) -{ - PYLONG_FROM_UINT(unsigned long long, ival); -} - -/* Create a new int object from a C size_t. */ + PyLongObject *v; + unsigned long t; + int ndigits = 0; -PyObject * -PyLong_FromSize_t(size_t ival) -{ - PYLONG_FROM_UINT(size_t, ival); + /* Count the number of Python digits. */ + t = (unsigned long)ival; + while (t) { + ++ndigits; + t >>= PyLong_SHIFT; + } + v = _PyLong_New(ndigits); + if (v != NULL) { + digit *p = v->ob_digit; + Py_SIZE(v) = ndigits; + while (ival) { + *p++ = (digit)(ival & PyLong_MASK); + ival >>= PyLong_SHIFT; + } + } + return (PyObject *)v; } -/* Create a new int object from a C double */ +/* Create a new long int object from a C double */ PyObject * PyLong_FromDouble(double dval) @@ -481,21 +220,19 @@ PyLong_FromDouble(double dval) #define PY_ABS_LONG_MIN (0-(unsigned long)LONG_MIN) #define PY_ABS_SSIZE_T_MIN (0-(size_t)PY_SSIZE_T_MIN) -/* Get a C long int from an int object or any object that has an __int__ - method. - - On overflow, return -1 and set *overflow to 1 or -1 depending on the sign of - the result. Otherwise *overflow is 0. +/* Get a C long int from a Python long or Python int object. + On overflow, returns -1 and sets *overflow to 1 or -1 depending + on the sign of the result. Otherwise *overflow is 0. - For other errors (e.g., TypeError), return -1 and set an error condition. - In this case *overflow will be 0. + For other errors (e.g., type error), returns -1 and sets an error + condition. */ long PyLong_AsLongAndOverflow(PyObject *vv, int *overflow) { /* This version by Tim Peters */ - PyLongObject *v; + register PyLongObject *v; unsigned long x, prev; long res; Py_ssize_t i; @@ -508,17 +245,35 @@ PyLong_AsLongAndOverflow(PyObject *vv, int *overflow) return -1; } - if (PyLong_Check(vv)) { - v = (PyLongObject *)vv; - } - else { - v = (PyLongObject *)_PyLong_FromNbIndexOrNbInt(vv); - if (v == NULL) + if(PyInt_Check(vv)) + return PyInt_AsLong(vv); + + if (!PyLong_Check(vv)) { + PyNumberMethods *nb; + nb = vv->ob_type->tp_as_number; + if (nb == NULL || nb->nb_int == NULL) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + return -1; + } + vv = (*nb->nb_int) (vv); + if (vv == NULL) return -1; do_decref = 1; + if(PyInt_Check(vv)) { + res = PyInt_AsLong(vv); + goto exit; + } + if (!PyLong_Check(vv)) { + Py_DECREF(vv); + PyErr_SetString(PyExc_TypeError, + "nb_int should return int object"); + return -1; + } } res = -1; + v = (PyLongObject *)vv; i = Py_SIZE(v); switch (i) { @@ -540,7 +295,7 @@ PyLong_AsLongAndOverflow(PyObject *vv, int *overflow) } while (--i >= 0) { prev = x; - x = (x << PyLong_SHIFT) | v->ob_digit[i]; + x = (x << PyLong_SHIFT) + v->ob_digit[i]; if ((x >> PyLong_SHIFT) != prev) { *overflow = sign; goto exit; @@ -562,13 +317,13 @@ PyLong_AsLongAndOverflow(PyObject *vv, int *overflow) } exit: if (do_decref) { - Py_DECREF(v); + Py_DECREF(vv); } return res; } -/* Get a C long int from an int object or any object that has an __int__ - method. Return -1 and set an error if overflow occurs. */ +/* Get a C long int from a long int object. + Returns -1 and sets an error condition if overflow occurs. */ long PyLong_AsLong(PyObject *obj) @@ -584,7 +339,7 @@ PyLong_AsLong(PyObject *obj) return result; } -/* Get a C int from an int object or any object that has an __int__ +/* Get a C int from a long int object or any object that has an __int__ method. Return -1 and set an error if overflow occurs. */ int @@ -602,32 +357,22 @@ _PyLong_AsInt(PyObject *obj) return (int)result; } -/* Get a Py_ssize_t from an int object. +/* Get a Py_ssize_t from a long int object. Returns -1 and sets an error condition if overflow occurs. */ Py_ssize_t PyLong_AsSsize_t(PyObject *vv) { - PyLongObject *v; + register PyLongObject *v; size_t x, prev; Py_ssize_t i; int sign; - if (vv == NULL) { + if (vv == NULL || !PyLong_Check(vv)) { PyErr_BadInternalCall(); return -1; } - if (!PyLong_Check(vv)) { - PyErr_SetString(PyExc_TypeError, "an integer is required"); - return -1; - } - v = (PyLongObject *)vv; i = Py_SIZE(v); - switch (i) { - case -1: return -(sdigit)v->ob_digit[0]; - case 0: return 0; - case 1: return v->ob_digit[0]; - } sign = 1; x = 0; if (i < 0) { @@ -653,118 +398,73 @@ PyLong_AsSsize_t(PyObject *vv) { overflow: PyErr_SetString(PyExc_OverflowError, - "Python int too large to convert to C ssize_t"); + "long int too large to convert to int"); return -1; } -/* Get a C unsigned long int from an int object. +/* Get a C unsigned long int from a long int object. Returns -1 and sets an error condition if overflow occurs. */ unsigned long PyLong_AsUnsignedLong(PyObject *vv) { - PyLongObject *v; + register PyLongObject *v; unsigned long x, prev; Py_ssize_t i; - if (vv == NULL) { + if (vv == NULL || !PyLong_Check(vv)) { + if (vv != NULL && PyInt_Check(vv)) { + long val = PyInt_AsLong(vv); + if (val < 0) { + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value " + "to unsigned long"); + return (unsigned long) -1; + } + return val; + } PyErr_BadInternalCall(); - return (unsigned long)-1; - } - if (!PyLong_Check(vv)) { - PyErr_SetString(PyExc_TypeError, "an integer is required"); - return (unsigned long)-1; + return (unsigned long) -1; } - v = (PyLongObject *)vv; i = Py_SIZE(v); x = 0; if (i < 0) { PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to unsigned int"); + "can't convert negative value to unsigned long"); return (unsigned long) -1; } - switch (i) { - case 0: return 0; - case 1: return v->ob_digit[0]; - } while (--i >= 0) { prev = x; x = (x << PyLong_SHIFT) | v->ob_digit[i]; if ((x >> PyLong_SHIFT) != prev) { PyErr_SetString(PyExc_OverflowError, - "Python int too large to convert " - "to C unsigned long"); + "long int too large to convert"); return (unsigned long) -1; } } return x; } -/* Get a C size_t from an int object. Returns (size_t)-1 and sets - an error condition if overflow occurs. */ - -size_t -PyLong_AsSize_t(PyObject *vv) -{ - PyLongObject *v; - size_t x, prev; - Py_ssize_t i; - - if (vv == NULL) { - PyErr_BadInternalCall(); - return (size_t) -1; - } - if (!PyLong_Check(vv)) { - PyErr_SetString(PyExc_TypeError, "an integer is required"); - return (size_t)-1; - } - - v = (PyLongObject *)vv; - i = Py_SIZE(v); - x = 0; - if (i < 0) { - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to size_t"); - return (size_t) -1; - } - switch (i) { - case 0: return 0; - case 1: return v->ob_digit[0]; - } - while (--i >= 0) { - prev = x; - x = (x << PyLong_SHIFT) | v->ob_digit[i]; - if ((x >> PyLong_SHIFT) != prev) { - PyErr_SetString(PyExc_OverflowError, - "Python int too large to convert to C size_t"); - return (size_t) -1; - } - } - return x; -} - -/* Get a C unsigned long int from an int object, ignoring the high bits. +/* 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. */ -static unsigned long -_PyLong_AsUnsignedLongMask(PyObject *vv) +unsigned long +PyLong_AsUnsignedLongMask(PyObject *vv) { - PyLongObject *v; + register PyLongObject *v; unsigned long x; Py_ssize_t i; int sign; if (vv == NULL || !PyLong_Check(vv)) { + if (vv != NULL && PyInt_Check(vv)) + return PyInt_AsUnsignedLongMask(vv); PyErr_BadInternalCall(); return (unsigned long) -1; } v = (PyLongObject *)vv; i = Py_SIZE(v); - switch (i) { - case 0: return 0; - case 1: return v->ob_digit[0]; - } sign = 1; x = 0; if (i < 0) { @@ -777,30 +477,6 @@ _PyLong_AsUnsignedLongMask(PyObject *vv) return x * sign; } -unsigned long -PyLong_AsUnsignedLongMask(PyObject *op) -{ - PyLongObject *lo; - unsigned long val; - - if (op == NULL) { - PyErr_BadInternalCall(); - return (unsigned long)-1; - } - - if (PyLong_Check(op)) { - return _PyLong_AsUnsignedLongMask(op); - } - - lo = (PyLongObject *)_PyLong_FromNbIndexOrNbInt(op); - if (lo == NULL) - return (unsigned long)-1; - - val = _PyLong_AsUnsignedLongMask((PyObject *)lo); - Py_DECREF(lo); - return val; -} - int _PyLong_Sign(PyObject *vv) { @@ -812,52 +488,34 @@ _PyLong_Sign(PyObject *vv) return Py_SIZE(v) == 0 ? 0 : (Py_SIZE(v) < 0 ? -1 : 1); } -/* bits_in_digit(d) returns the unique integer k such that 2**(k-1) <= d < - 2**k if d is nonzero, else 0. */ - -static const unsigned char BitLengthTable[32] = { - 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 -}; - -static int -bits_in_digit(digit d) -{ - int d_bits = 0; - while (d >= 32) { - d_bits += 6; - d >>= 6; - } - d_bits += (int)BitLengthTable[d]; - return d_bits; -} - size_t _PyLong_NumBits(PyObject *vv) { PyLongObject *v = (PyLongObject *)vv; size_t result = 0; Py_ssize_t ndigits; - int msd_bits; assert(v != NULL); assert(PyLong_Check(v)); - ndigits = Py_ABS(Py_SIZE(v)); + ndigits = ABS(Py_SIZE(v)); assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0); if (ndigits > 0) { digit msd = v->ob_digit[ndigits - 1]; - if ((size_t)(ndigits - 1) > SIZE_MAX / (size_t)PyLong_SHIFT) - goto Overflow; - result = (size_t)(ndigits - 1) * (size_t)PyLong_SHIFT; - msd_bits = bits_in_digit(msd); - if (SIZE_MAX - msd_bits < result) + + result = (ndigits - 1) * PyLong_SHIFT; + if (result / PyLong_SHIFT != (size_t)(ndigits - 1)) goto Overflow; - result += msd_bits; + do { + ++result; + if (result == 0) + goto Overflow; + msd >>= 1; + } while (msd); } return result; Overflow: - PyErr_SetString(PyExc_OverflowError, "int has too many bits " + PyErr_SetString(PyExc_OverflowError, "long has too many bits " "to express in a platform size_t"); return (size_t)-1; } @@ -870,7 +528,7 @@ _PyLong_FromByteArray(const unsigned char* bytes, size_t n, int incr; /* direction to move pstartbyte */ const unsigned char* pendbyte; /* MSB of bytes */ size_t numsignificantbytes; /* number of bytes that matter */ - Py_ssize_t ndigits; /* number of Python int digits */ + Py_ssize_t ndigits; /* number of Python long digits */ PyLongObject* v; /* result */ Py_ssize_t idigit = 0; /* next free index in v->ob_digit */ @@ -914,8 +572,8 @@ _PyLong_FromByteArray(const unsigned char* bytes, size_t n, ++numsignificantbytes; } - /* How many Python int digits do we need? We have - 8*numsignificantbytes bits, and each Python int digit has + /* How many Python long digits do we need? We have + 8*numsignificantbytes bits, and each Python long digit has PyLong_SHIFT bits, so it's the ceiling of the quotient. */ /* catch overflow before it happens */ if (numsignificantbytes > (PY_SSIZE_T_MAX - PyLong_SHIFT) / 8) { @@ -949,7 +607,7 @@ _PyLong_FromByteArray(const unsigned char* bytes, size_t n, /* Because we're going LSB to MSB, thisbyte is more significant than what's already in accum, so needs to be prepended to accum. */ - accum |= thisbyte << accumbits; + accum |= (twodigits)thisbyte << accumbits; accumbits += 8; if (accumbits >= PyLong_SHIFT) { /* There's enough to fill a Python digit. */ @@ -994,7 +652,7 @@ _PyLong_AsByteArray(PyLongObject* v, ndigits = -(Py_SIZE(v)); if (!is_signed) { PyErr_SetString(PyExc_OverflowError, - "can't convert negative int to unsigned"); + "can't convert negative long to unsigned"); return -1; } do_twos_comp = 1; @@ -1015,7 +673,7 @@ _PyLong_AsByteArray(PyLongObject* v, /* Copy over all the Python digits. It's crucial that every Python digit except for the MSD contribute - exactly PyLong_SHIFT bits to the total, so first assert that the int is + exactly PyLong_SHIFT bits to the total, so first assert that the long is normalized. */ assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0); j = 0; @@ -1070,7 +728,7 @@ _PyLong_AsByteArray(PyLongObject* v, ++j; if (do_twos_comp) { /* Fill leading bits of the byte with sign bits - (appropriately pretending that the int had an + (appropriately pretending that the long had an infinite supply of sign bits). */ accum |= (~(twodigits)0) << accumbits; } @@ -1101,48 +759,67 @@ _PyLong_AsByteArray(PyLongObject* v, return 0; Overflow: - PyErr_SetString(PyExc_OverflowError, "int too big to convert"); + PyErr_SetString(PyExc_OverflowError, "long too big to convert"); return -1; } -/* Create a new int object from a C pointer */ +/* Create a new long (or int) object from a C pointer */ PyObject * PyLong_FromVoidPtr(void *p) { #if SIZEOF_VOID_P <= SIZEOF_LONG - return PyLong_FromUnsignedLong((unsigned long)(uintptr_t)p); + if ((long)p < 0) + return PyLong_FromUnsignedLong((unsigned long)p); + return PyInt_FromLong((long)p); #else +#ifndef HAVE_LONG_LONG +# error "PyLong_FromVoidPtr: sizeof(void*) > sizeof(long), but no long long" +#endif #if SIZEOF_LONG_LONG < SIZEOF_VOID_P -# error "PyLong_FromVoidPtr: sizeof(long long) < sizeof(void*)" +# error "PyLong_FromVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)" #endif - return PyLong_FromUnsignedLongLong((unsigned long long)(uintptr_t)p); -#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */ + /* optimize null pointers */ + if (p == NULL) + return PyInt_FromLong(0); + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)p); +#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */ } -/* Get a C pointer from an int object. */ +/* Get a C pointer from a long object (or an int object in some cases) */ void * PyLong_AsVoidPtr(PyObject *vv) { + /* This function will allow int or long objects. If vv is neither, + then the PyLong_AsLong*() functions will raise the exception: + PyExc_SystemError, "bad argument to internal function" + */ #if SIZEOF_VOID_P <= SIZEOF_LONG long x; - if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0) + if (PyInt_Check(vv)) + x = PyInt_AS_LONG(vv); + else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0) x = PyLong_AsLong(vv); else x = PyLong_AsUnsignedLong(vv); #else +#ifndef HAVE_LONG_LONG +# error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long" +#endif #if SIZEOF_LONG_LONG < SIZEOF_VOID_P -# error "PyLong_AsVoidPtr: sizeof(long long) < sizeof(void*)" +# error "PyLong_AsVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)" #endif - long long x; + PY_LONG_LONG x; - if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0) + if (PyInt_Check(vv)) + x = PyInt_AS_LONG(vv); + else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0) x = PyLong_AsLongLong(vv); else x = PyLong_AsUnsignedLongLong(vv); @@ -1154,35 +831,34 @@ PyLong_AsVoidPtr(PyObject *vv) return (void *)x; } -/* Initial long long support by Chris Herborth (chrish@qnx.com), later +#ifdef HAVE_LONG_LONG + +/* Initial PY_LONG_LONG support by Chris Herborth (chrish@qnx.com), later * rewritten to use the newer PyLong_{As,From}ByteArray API. */ -#define PY_ABS_LLONG_MIN (0-(unsigned long long)LLONG_MIN) +#define IS_LITTLE_ENDIAN (int)*(unsigned char*)&one +#define PY_ABS_LLONG_MIN (0-(unsigned PY_LONG_LONG)PY_LLONG_MIN) -/* Create a new int object from a C long long int. */ +/* Create a new long int object from a C PY_LONG_LONG int. */ PyObject * -PyLong_FromLongLong(long long ival) +PyLong_FromLongLong(PY_LONG_LONG ival) { PyLongObject *v; - unsigned long long abs_ival; - unsigned long long t; /* unsigned so >> doesn't propagate sign bit */ + unsigned PY_LONG_LONG abs_ival; + unsigned PY_LONG_LONG t; /* unsigned so >> doesn't propagate sign bit */ int ndigits = 0; int negative = 0; - if (IS_SMALL_INT(ival)) { - return get_small_int((sdigit)ival); - } - if (ival < 0) { /* avoid signed overflow on negation; see comments in PyLong_FromLong above. */ - abs_ival = (unsigned long long)(-1-ival) + 1; + abs_ival = (unsigned PY_LONG_LONG)(-1-ival) + 1; negative = 1; } else { - abs_ival = (unsigned long long)ival; + abs_ival = (unsigned PY_LONG_LONG)ival; } /* Count the number of Python digits. @@ -1207,32 +883,17 @@ PyLong_FromLongLong(long long ival) return (PyObject *)v; } -/* Create a new int object from a C Py_ssize_t. */ +/* Create a new long int object from a C unsigned PY_LONG_LONG int. */ PyObject * -PyLong_FromSsize_t(Py_ssize_t ival) +PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival) { PyLongObject *v; - size_t abs_ival; - size_t t; /* unsigned so >> doesn't propagate sign bit */ + unsigned PY_LONG_LONG t; int ndigits = 0; - int negative = 0; - - if (IS_SMALL_INT(ival)) { - return get_small_int((sdigit)ival); - } - - if (ival < 0) { - /* avoid signed overflow when ival = SIZE_T_MIN */ - abs_ival = (size_t)(-1-ival)+1; - negative = 1; - } - else { - abs_ival = (size_t)ival; - } /* Count the number of Python digits. */ - t = abs_ival; + t = (unsigned PY_LONG_LONG)ival; while (t) { ++ndigits; t >>= PyLong_SHIFT; @@ -1240,123 +901,130 @@ PyLong_FromSsize_t(Py_ssize_t ival) v = _PyLong_New(ndigits); if (v != NULL) { digit *p = v->ob_digit; - Py_SIZE(v) = negative ? -ndigits : ndigits; - t = abs_ival; - while (t) { - *p++ = (digit)(t & PyLong_MASK); - t >>= PyLong_SHIFT; + Py_SIZE(v) = ndigits; + while (ival) { + *p++ = (digit)(ival & PyLong_MASK); + ival >>= PyLong_SHIFT; } } return (PyObject *)v; } -/* Get a C long long int from an int object or any object that has an - __int__ method. Return -1 and set an error if overflow occurs. */ +/* Create a new long int object from a C Py_ssize_t. */ -long long +PyObject * +PyLong_FromSsize_t(Py_ssize_t ival) +{ + Py_ssize_t bytes = ival; + int one = 1; + return _PyLong_FromByteArray((unsigned char *)&bytes, + SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 1); +} + +/* Create a new long int object from a C size_t. */ + +PyObject * +PyLong_FromSize_t(size_t ival) +{ + size_t bytes = ival; + int one = 1; + return _PyLong_FromByteArray((unsigned char *)&bytes, + SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 0); +} + +/* Get a C PY_LONG_LONG int from a long int object. + Return -1 and set an error if overflow occurs. */ + +PY_LONG_LONG PyLong_AsLongLong(PyObject *vv) { - PyLongObject *v; - long long bytes; + PY_LONG_LONG bytes; + int one = 1; int res; - int do_decref = 0; /* if nb_int was called */ if (vv == NULL) { PyErr_BadInternalCall(); return -1; } - - if (PyLong_Check(vv)) { - v = (PyLongObject *)vv; - } - else { - v = (PyLongObject *)_PyLong_FromNbIndexOrNbInt(vv); - if (v == NULL) + if (!PyLong_Check(vv)) { + PyNumberMethods *nb; + PyObject *io; + if (PyInt_Check(vv)) + return (PY_LONG_LONG)PyInt_AsLong(vv); + if ((nb = Py_TYPE(vv)->tp_as_number) == NULL || + nb->nb_int == NULL) { + PyErr_SetString(PyExc_TypeError, "an integer is required"); return -1; - do_decref = 1; + } + io = (*nb->nb_int) (vv); + if (io == NULL) + return -1; + if (PyInt_Check(io)) { + bytes = PyInt_AsLong(io); + Py_DECREF(io); + return bytes; + } + if (PyLong_Check(io)) { + bytes = PyLong_AsLongLong(io); + Py_DECREF(io); + return bytes; + } + Py_DECREF(io); + PyErr_SetString(PyExc_TypeError, "integer conversion failed"); + return -1; } - res = 0; - switch(Py_SIZE(v)) { - case -1: - bytes = -(sdigit)v->ob_digit[0]; - break; - case 0: - bytes = 0; - break; - case 1: - bytes = v->ob_digit[0]; - break; - default: - res = _PyLong_AsByteArray((PyLongObject *)v, (unsigned char *)&bytes, - SIZEOF_LONG_LONG, PY_LITTLE_ENDIAN, 1); - } - if (do_decref) { - Py_DECREF(v); - } + res = _PyLong_AsByteArray((PyLongObject *)vv, (unsigned char *)&bytes, + SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1); - /* Plan 9 can't handle long long in ? : expressions */ + /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */ if (res < 0) - return (long long)-1; + return (PY_LONG_LONG)-1; else return bytes; } -/* Get a C unsigned long long int from an int object. +/* Get a C unsigned PY_LONG_LONG int from a long int object. Return -1 and set an error if overflow occurs. */ -unsigned long long +unsigned PY_LONG_LONG PyLong_AsUnsignedLongLong(PyObject *vv) { - PyLongObject *v; - unsigned long long bytes; + unsigned PY_LONG_LONG bytes; + int one = 1; int res; - if (vv == NULL) { + if (vv == NULL || !PyLong_Check(vv)) { PyErr_BadInternalCall(); - return (unsigned long long)-1; - } - if (!PyLong_Check(vv)) { - PyErr_SetString(PyExc_TypeError, "an integer is required"); - return (unsigned long long)-1; - } - - v = (PyLongObject*)vv; - switch(Py_SIZE(v)) { - case 0: return 0; - case 1: return v->ob_digit[0]; + return (unsigned PY_LONG_LONG)-1; } res = _PyLong_AsByteArray((PyLongObject *)vv, (unsigned char *)&bytes, - SIZEOF_LONG_LONG, PY_LITTLE_ENDIAN, 0); + SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0); - /* Plan 9 can't handle long long in ? : expressions */ + /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */ if (res < 0) - return (unsigned long long)res; + return (unsigned PY_LONG_LONG)res; else return bytes; } -/* Get a C unsigned long int from an int object, ignoring the high bits. +/* 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. */ -static unsigned long long -_PyLong_AsUnsignedLongLongMask(PyObject *vv) +unsigned PY_LONG_LONG +PyLong_AsUnsignedLongLongMask(PyObject *vv) { - PyLongObject *v; - unsigned long long x; + register PyLongObject *v; + unsigned PY_LONG_LONG x; Py_ssize_t i; int sign; if (vv == NULL || !PyLong_Check(vv)) { PyErr_BadInternalCall(); - return (unsigned long long) -1; + return (unsigned PY_LONG_LONG) -1; } v = (PyLongObject *)vv; - switch(Py_SIZE(v)) { - case 0: return 0; - case 1: return v->ob_digit[0]; - } i = Py_SIZE(v); sign = 1; x = 0; @@ -1370,47 +1038,21 @@ _PyLong_AsUnsignedLongLongMask(PyObject *vv) return x * sign; } -unsigned long long -PyLong_AsUnsignedLongLongMask(PyObject *op) -{ - PyLongObject *lo; - unsigned long long val; - - if (op == NULL) { - PyErr_BadInternalCall(); - return (unsigned long long)-1; - } +/* Get a C long long int from a Python long or Python int object. + On overflow, returns -1 and sets *overflow to 1 or -1 depending + on the sign of the result. Otherwise *overflow is 0. - if (PyLong_Check(op)) { - return _PyLong_AsUnsignedLongLongMask(op); - } - - lo = (PyLongObject *)_PyLong_FromNbIndexOrNbInt(op); - if (lo == NULL) - return (unsigned long long)-1; - - val = _PyLong_AsUnsignedLongLongMask((PyObject *)lo); - Py_DECREF(lo); - return val; -} - -/* Get a C long long int from an int object or any object that has an - __int__ method. - - On overflow, return -1 and set *overflow to 1 or -1 depending on the sign of - the result. Otherwise *overflow is 0. - - For other errors (e.g., TypeError), return -1 and set an error condition. - In this case *overflow will be 0. + For other errors (e.g., type error), returns -1 and sets an error + condition. */ -long long +PY_LONG_LONG PyLong_AsLongLongAndOverflow(PyObject *vv, int *overflow) { /* This version by Tim Peters */ - PyLongObject *v; - unsigned long long x, prev; - long long res; + register PyLongObject *v; + unsigned PY_LONG_LONG x, prev; + PY_LONG_LONG res; Py_ssize_t i; int sign; int do_decref = 0; /* if nb_int was called */ @@ -1421,17 +1063,35 @@ PyLong_AsLongLongAndOverflow(PyObject *vv, int *overflow) return -1; } - if (PyLong_Check(vv)) { - v = (PyLongObject *)vv; - } - else { - v = (PyLongObject *)_PyLong_FromNbIndexOrNbInt(vv); - if (v == NULL) + if (PyInt_Check(vv)) + return PyInt_AsLong(vv); + + if (!PyLong_Check(vv)) { + PyNumberMethods *nb; + nb = Py_TYPE(vv)->tp_as_number; + if (nb == NULL || nb->nb_int == NULL) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + return -1; + } + vv = (*nb->nb_int) (vv); + if (vv == NULL) return -1; do_decref = 1; + if(PyInt_Check(vv)) { + res = PyInt_AsLong(vv); + goto exit; + } + if (!PyLong_Check(vv)) { + Py_DECREF(vv); + PyErr_SetString(PyExc_TypeError, + "nb_int should return int object"); + return -1; + } } res = -1; + v = (PyLongObject *)vv; i = Py_SIZE(v); switch (i) { @@ -1462,11 +1122,11 @@ PyLong_AsLongLongAndOverflow(PyObject *vv, int *overflow) /* Haven't lost any bits, but casting to long requires extra * care (see comment above). */ - if (x <= (unsigned long long)LLONG_MAX) { - res = (long long)x * sign; + if (x <= (unsigned PY_LONG_LONG)PY_LLONG_MAX) { + res = (PY_LONG_LONG)x * sign; } else if (sign < 0 && x == PY_ABS_LLONG_MIN) { - res = LLONG_MIN; + res = PY_LLONG_MIN; } else { *overflow = sign; @@ -1475,113 +1135,70 @@ PyLong_AsLongLongAndOverflow(PyObject *vv, int *overflow) } exit: if (do_decref) { - Py_DECREF(v); + Py_DECREF(vv); } return res; } -int -_PyLong_UnsignedShort_Converter(PyObject *obj, void *ptr) -{ - unsigned long uval; +#undef IS_LITTLE_ENDIAN - if (PyLong_Check(obj) && _PyLong_Sign(obj) < 0) { - PyErr_SetString(PyExc_ValueError, "value must be positive"); - return 0; - } - uval = PyLong_AsUnsignedLong(obj); - if (uval == (unsigned long)-1 && PyErr_Occurred()) - return 0; - if (uval > USHRT_MAX) { - PyErr_SetString(PyExc_OverflowError, - "Python int too large for C unsigned short"); - return 0; - } - - *(unsigned short *)ptr = Py_SAFE_DOWNCAST(uval, unsigned long, unsigned short); - return 1; -} +#endif /* HAVE_LONG_LONG */ -int -_PyLong_UnsignedInt_Converter(PyObject *obj, void *ptr) -{ - unsigned long uval; - if (PyLong_Check(obj) && _PyLong_Sign(obj) < 0) { - PyErr_SetString(PyExc_ValueError, "value must be positive"); - return 0; +static int +convert_binop(PyObject *v, PyObject *w, PyLongObject **a, PyLongObject **b) { + if (PyLong_Check(v)) { + *a = (PyLongObject *) v; + Py_INCREF(v); } - uval = PyLong_AsUnsignedLong(obj); - if (uval == (unsigned long)-1 && PyErr_Occurred()) - return 0; - if (uval > UINT_MAX) { - PyErr_SetString(PyExc_OverflowError, - "Python int too large for C unsigned int"); - return 0; + else if (PyInt_Check(v)) { + *a = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(v)); } - - *(unsigned int *)ptr = Py_SAFE_DOWNCAST(uval, unsigned long, unsigned int); - return 1; -} - -int -_PyLong_UnsignedLong_Converter(PyObject *obj, void *ptr) -{ - unsigned long uval; - - if (PyLong_Check(obj) && _PyLong_Sign(obj) < 0) { - PyErr_SetString(PyExc_ValueError, "value must be positive"); + else { return 0; } - uval = PyLong_AsUnsignedLong(obj); - if (uval == (unsigned long)-1 && PyErr_Occurred()) + if (PyLong_Check(w)) { + *b = (PyLongObject *) w; + Py_INCREF(w); + } + else if (PyInt_Check(w)) { + *b = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(w)); + } + else { + Py_DECREF(*a); return 0; - - *(unsigned long *)ptr = uval; + } return 1; } -int -_PyLong_UnsignedLongLong_Converter(PyObject *obj, void *ptr) -{ - unsigned long long uval; +#define CONVERT_BINOP(v, w, a, b) \ + do { \ + if (!convert_binop(v, w, a, b)) { \ + Py_INCREF(Py_NotImplemented); \ + return Py_NotImplemented; \ + } \ + } while(0) \ - if (PyLong_Check(obj) && _PyLong_Sign(obj) < 0) { - PyErr_SetString(PyExc_ValueError, "value must be positive"); - return 0; - } - uval = PyLong_AsUnsignedLongLong(obj); - if (uval == (unsigned long long)-1 && PyErr_Occurred()) - return 0; +/* bits_in_digit(d) returns the unique integer k such that 2**(k-1) <= d < + 2**k if d is nonzero, else 0. */ - *(unsigned long long *)ptr = uval; - return 1; -} +static const unsigned char BitLengthTable[32] = { + 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 +}; -int -_PyLong_Size_t_Converter(PyObject *obj, void *ptr) +static int +bits_in_digit(digit d) { - size_t uval; - - if (PyLong_Check(obj) && _PyLong_Sign(obj) < 0) { - PyErr_SetString(PyExc_ValueError, "value must be positive"); - return 0; + int d_bits = 0; + while (d >= 32) { + d_bits += 6; + d >>= 6; } - uval = PyLong_AsSize_t(obj); - if (uval == (size_t)-1 && PyErr_Occurred()) - return 0; - - *(size_t *)ptr = uval; - return 1; + d_bits += (int)BitLengthTable[d]; + return d_bits; } - -#define CHECK_BINOP(v,w) \ - do { \ - if (!PyLong_Check(v) || !PyLong_Check(w)) \ - Py_RETURN_NOTIMPLEMENTED; \ - } while(0) - /* x[0:m] and y[0:n] are digit vectors, LSD first, m >= n required. x[0:n] * is modified in place, by adding y to it. Carries are propagated as far as * x[m-1], and the remaining carry (0 or 1) is returned. @@ -1674,7 +1291,7 @@ v_rshift(digit *z, digit *a, Py_ssize_t m, int d) /* Divide long pin, w/ size digits, by non-zero digit n, storing quotient in pout, and returning the remainder. pin and pout point at the LSD. It's OK for pin == pout on entry, which saves oodles of mallocs/frees in - _PyLong_Format, but that should be done with great care since ints are + _PyLong_Format, but that should be done with great care since longs are immutable. */ static digit @@ -1694,14 +1311,14 @@ inplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n) return (digit)rem; } -/* Divide an integer by a digit, returning both the quotient +/* Divide a long integer by a digit, returning both the quotient (as function result) and the remainder (through *prem). The sign of a is ignored; n should not be zero. */ static PyLongObject * divrem1(PyLongObject *a, digit n, digit *prem) { - const Py_ssize_t size = Py_ABS(Py_SIZE(a)); + const Py_ssize_t size = ABS(Py_SIZE(a)); PyLongObject *z; assert(n > 0 && n <= PyLong_MASK); @@ -1712,31 +1329,26 @@ divrem1(PyLongObject *a, digit n, digit *prem) return long_normalize(z); } -/* Convert an integer to a base 10 string. Returns a new non-shared +/* Convert a long integer to a base 10 string. Returns a new non-shared string. (Return value is non-shared so that callers can modify the returned value if necessary.) */ -static int -long_to_decimal_string_internal(PyObject *aa, - PyObject **p_output, - _PyUnicodeWriter *writer, - _PyBytesWriter *bytes_writer, - char **bytes_str) +static PyObject * +long_to_decimal_string(PyObject *aa, int addL) { PyLongObject *scratch, *a; - PyObject *str = NULL; + PyObject *str; Py_ssize_t size, strlen, size_a, i, j; digit *pout, *pin, rem, tenpow; + char *p; int negative; - int d; - enum PyUnicode_Kind kind; a = (PyLongObject *)aa; if (a == NULL || !PyLong_Check(a)) { PyErr_BadInternalCall(); - return -1; + return NULL; } - size_a = Py_ABS(Py_SIZE(a)); + size_a = ABS(Py_SIZE(a)); negative = Py_SIZE(a) < 0; /* quick and dirty upper bound for the number of digits @@ -1746,20 +1358,18 @@ long_to_decimal_string_internal(PyObject *aa, But log2(a) < size_a * PyLong_SHIFT, and log2(_PyLong_DECIMAL_BASE) = log2(10) * _PyLong_DECIMAL_SHIFT - > 3.3 * _PyLong_DECIMAL_SHIFT - - size_a * PyLong_SHIFT / (3.3 * _PyLong_DECIMAL_SHIFT) = - size_a + size_a / d < size_a + size_a / floor(d), - where d = (3.3 * _PyLong_DECIMAL_SHIFT) / - (PyLong_SHIFT - 3.3 * _PyLong_DECIMAL_SHIFT) + > 3 * _PyLong_DECIMAL_SHIFT */ - d = (33 * _PyLong_DECIMAL_SHIFT) / - (10 * PyLong_SHIFT - 33 * _PyLong_DECIMAL_SHIFT); - assert(size_a < PY_SSIZE_T_MAX/2); - size = 1 + size_a + size_a / d; + if (size_a > PY_SSIZE_T_MAX / PyLong_SHIFT) { + PyErr_SetString(PyExc_OverflowError, + "long is too large to format"); + return NULL; + } + /* the expression size_a * PyLong_SHIFT is now safe from overflow */ + size = 1 + size_a * PyLong_SHIFT / (3 * _PyLong_DECIMAL_SHIFT); scratch = _PyLong_New(size); if (scratch == NULL) - return -1; + return NULL; /* convert array of base _PyLong_BASE digits in pin to an array of base _PyLong_DECIMAL_BASE digits in pout, following Knuth (TAOCP, @@ -1782,7 +1392,7 @@ long_to_decimal_string_internal(PyObject *aa, /* check for keyboard interrupt */ SIGCHECK({ Py_DECREF(scratch); - return -1; + return NULL; }); } /* pout should have at least one digit, so that the case when a = 0 @@ -1791,332 +1401,222 @@ long_to_decimal_string_internal(PyObject *aa, pout[size++] = 0; /* calculate exact length of output string, and allocate */ - strlen = negative + 1 + (size - 1) * _PyLong_DECIMAL_SHIFT; + strlen = (addL != 0) + negative + + 1 + (size - 1) * _PyLong_DECIMAL_SHIFT; tenpow = 10; rem = pout[size-1]; while (rem >= tenpow) { tenpow *= 10; strlen++; } - if (writer) { - if (_PyUnicodeWriter_Prepare(writer, strlen, '9') == -1) { - Py_DECREF(scratch); - return -1; - } - kind = writer->kind; - } - else if (bytes_writer) { - *bytes_str = _PyBytesWriter_Prepare(bytes_writer, *bytes_str, strlen); - if (*bytes_str == NULL) { - Py_DECREF(scratch); - return -1; - } + str = PyString_FromStringAndSize(NULL, strlen); + if (str == NULL) { + Py_DECREF(scratch); + return NULL; } - else { - str = PyUnicode_New(strlen, '9'); - if (str == NULL) { - Py_DECREF(scratch); - return -1; - } - kind = PyUnicode_KIND(str); - } - -#define WRITE_DIGITS(p) \ - do { \ - /* pout[0] through pout[size-2] contribute exactly \ - _PyLong_DECIMAL_SHIFT digits each */ \ - for (i=0; i < size - 1; i++) { \ - rem = pout[i]; \ - for (j = 0; j < _PyLong_DECIMAL_SHIFT; j++) { \ - *--p = '0' + rem % 10; \ - rem /= 10; \ - } \ - } \ - /* pout[size-1]: always produce at least one decimal digit */ \ - rem = pout[i]; \ - do { \ - *--p = '0' + rem % 10; \ - rem /= 10; \ - } while (rem != 0); \ - \ - /* and sign */ \ - if (negative) \ - *--p = '-'; \ - } while (0) - -#define WRITE_UNICODE_DIGITS(TYPE) \ - do { \ - if (writer) \ - p = (TYPE*)PyUnicode_DATA(writer->buffer) + writer->pos + strlen; \ - else \ - p = (TYPE*)PyUnicode_DATA(str) + strlen; \ - \ - WRITE_DIGITS(p); \ - \ - /* check we've counted correctly */ \ - if (writer) \ - assert(p == ((TYPE*)PyUnicode_DATA(writer->buffer) + writer->pos)); \ - else \ - assert(p == (TYPE*)PyUnicode_DATA(str)); \ - } while (0) /* fill the string right-to-left */ - if (bytes_writer) { - char *p = *bytes_str + strlen; - WRITE_DIGITS(p); - assert(p == *bytes_str); - } - else if (kind == PyUnicode_1BYTE_KIND) { - Py_UCS1 *p; - WRITE_UNICODE_DIGITS(Py_UCS1); - } - else if (kind == PyUnicode_2BYTE_KIND) { - Py_UCS2 *p; - WRITE_UNICODE_DIGITS(Py_UCS2); - } - else { - Py_UCS4 *p; - assert (kind == PyUnicode_4BYTE_KIND); - WRITE_UNICODE_DIGITS(Py_UCS4); + p = PyString_AS_STRING(str) + strlen; + *p = '\0'; + if (addL) + *--p = 'L'; + /* pout[0] through pout[size-2] contribute exactly + _PyLong_DECIMAL_SHIFT digits each */ + for (i=0; i < size - 1; i++) { + rem = pout[i]; + for (j = 0; j < _PyLong_DECIMAL_SHIFT; j++) { + *--p = '0' + rem % 10; + rem /= 10; + } } -#undef WRITE_DIGITS -#undef WRITE_UNICODE_DIGITS + /* pout[size-1]: always produce at least one decimal digit */ + rem = pout[i]; + do { + *--p = '0' + rem % 10; + rem /= 10; + } while (rem != 0); - Py_DECREF(scratch); - if (writer) { - writer->pos += strlen; - } - else if (bytes_writer) { - (*bytes_str) += strlen; - } - else { - assert(_PyUnicode_CheckConsistency(str, 1)); - *p_output = (PyObject *)str; - } - return 0; -} + /* and sign */ + if (negative) + *--p = '-'; -static PyObject * -long_to_decimal_string(PyObject *aa) -{ - PyObject *v; - if (long_to_decimal_string_internal(aa, &v, NULL, NULL, NULL) == -1) - return NULL; - return v; + /* check we've counted correctly */ + assert(p == PyString_AS_STRING(str)); + Py_DECREF(scratch); + return (PyObject *)str; } -/* Convert an int object to a string, using a given conversion base, - which should be one of 2, 8 or 16. Return a string object. - If base is 2, 8 or 16, add the proper prefix '0b', '0o' or '0x' - if alternate is nonzero. */ - -static int -long_format_binary(PyObject *aa, int base, int alternate, - PyObject **p_output, _PyUnicodeWriter *writer, - _PyBytesWriter *bytes_writer, char **bytes_str) +/* Convert the long to a string object with given base, + appending a base prefix of 0[box] if base is 2, 8 or 16. + Add a trailing "L" if addL is non-zero. + If newstyle is zero, then use the pre-2.6 behavior of octal having + a leading "0", instead of the prefix "0o" */ +PyAPI_FUNC(PyObject *) +_PyLong_Format(PyObject *aa, int base, int addL, int newstyle) { - PyLongObject *a = (PyLongObject *)aa; - PyObject *v = NULL; - Py_ssize_t sz; + register PyLongObject *a = (PyLongObject *)aa; + PyStringObject *str; + Py_ssize_t i, sz; Py_ssize_t size_a; - enum PyUnicode_Kind kind; - int negative; + char *p; int bits; + char sign = '\0'; + + if (base == 10) + return long_to_decimal_string((PyObject *)a, addL); - assert(base == 2 || base == 8 || base == 16); if (a == NULL || !PyLong_Check(a)) { PyErr_BadInternalCall(); - return -1; + return NULL; } - size_a = Py_ABS(Py_SIZE(a)); - negative = Py_SIZE(a) < 0; + assert(base >= 2 && base <= 36); + size_a = ABS(Py_SIZE(a)); /* Compute a rough upper bound for the length of the string */ - switch (base) { - case 16: - bits = 4; - break; - case 8: - bits = 3; - break; - case 2: - bits = 1; - break; - default: - Py_UNREACHABLE(); - } - - /* Compute exact length 'sz' of output string. */ - if (size_a == 0) { - sz = 1; - } - else { - Py_ssize_t size_a_in_bits; - /* Ensure overflow doesn't occur during computation of sz. */ - if (size_a > (PY_SSIZE_T_MAX - 3) / PyLong_SHIFT) { - PyErr_SetString(PyExc_OverflowError, - "int too large to format"); - return -1; - } - size_a_in_bits = (size_a - 1) * PyLong_SHIFT + - bits_in_digit(a->ob_digit[size_a - 1]); - /* Allow 1 character for a '-' sign. */ - sz = negative + (size_a_in_bits + (bits - 1)) / bits; - } - if (alternate) { - /* 2 characters for prefix */ - sz += 2; + i = base; + bits = 0; + while (i > 1) { + ++bits; + i >>= 1; + } + i = 5 + (addL ? 1 : 0); + /* ensure we don't get signed overflow in sz calculation */ + if (size_a > (PY_SSIZE_T_MAX - i) / PyLong_SHIFT) { + PyErr_SetString(PyExc_OverflowError, + "long is too large to format"); + return NULL; } + sz = i + 1 + (size_a * PyLong_SHIFT - 1) / bits; + assert(sz >= 0); + str = (PyStringObject *) PyString_FromStringAndSize((char *)0, sz); + if (str == NULL) + return NULL; + p = PyString_AS_STRING(str) + sz; + *p = '\0'; + if (addL) + *--p = 'L'; + if (Py_SIZE(a) < 0) + sign = '-'; - if (writer) { - if (_PyUnicodeWriter_Prepare(writer, sz, 'x') == -1) - return -1; - kind = writer->kind; - } - else if (bytes_writer) { - *bytes_str = _PyBytesWriter_Prepare(bytes_writer, *bytes_str, sz); - if (*bytes_str == NULL) - return -1; - } - else { - v = PyUnicode_New(sz, 'x'); - if (v == NULL) - return -1; - kind = PyUnicode_KIND(v); - } - -#define WRITE_DIGITS(p) \ - do { \ - if (size_a == 0) { \ - *--p = '0'; \ - } \ - else { \ - /* JRH: special case for power-of-2 bases */ \ - twodigits accum = 0; \ - int accumbits = 0; /* # of bits in accum */ \ - Py_ssize_t i; \ - for (i = 0; i < size_a; ++i) { \ - accum |= (twodigits)a->ob_digit[i] << accumbits; \ - accumbits += PyLong_SHIFT; \ - assert(accumbits >= bits); \ - do { \ - char cdigit; \ - cdigit = (char)(accum & (base - 1)); \ - cdigit += (cdigit < 10) ? '0' : 'a'-10; \ - *--p = cdigit; \ - accumbits -= bits; \ - accum >>= bits; \ - } while (i < size_a-1 ? accumbits >= bits : accum > 0); \ - } \ - } \ - \ - if (alternate) { \ - if (base == 16) \ - *--p = 'x'; \ - else if (base == 8) \ - *--p = 'o'; \ - else /* (base == 2) */ \ - *--p = 'b'; \ - *--p = '0'; \ - } \ - if (negative) \ - *--p = '-'; \ - } while (0) - -#define WRITE_UNICODE_DIGITS(TYPE) \ - do { \ - if (writer) \ - p = (TYPE*)PyUnicode_DATA(writer->buffer) + writer->pos + sz; \ - else \ - p = (TYPE*)PyUnicode_DATA(v) + sz; \ - \ - WRITE_DIGITS(p); \ - \ - if (writer) \ - assert(p == ((TYPE*)PyUnicode_DATA(writer->buffer) + writer->pos)); \ - else \ - assert(p == (TYPE*)PyUnicode_DATA(v)); \ - } while (0) - - if (bytes_writer) { - char *p = *bytes_str + sz; - WRITE_DIGITS(p); - assert(p == *bytes_str); - } - else if (kind == PyUnicode_1BYTE_KIND) { - Py_UCS1 *p; - WRITE_UNICODE_DIGITS(Py_UCS1); - } - else if (kind == PyUnicode_2BYTE_KIND) { - Py_UCS2 *p; - WRITE_UNICODE_DIGITS(Py_UCS2); - } - else { - Py_UCS4 *p; - assert (kind == PyUnicode_4BYTE_KIND); - WRITE_UNICODE_DIGITS(Py_UCS4); + if (Py_SIZE(a) == 0) { + *--p = '0'; } -#undef WRITE_DIGITS -#undef WRITE_UNICODE_DIGITS + else if ((base & (base - 1)) == 0) { + /* JRH: special case for power-of-2 bases */ + twodigits accum = 0; + int accumbits = 0; /* # of bits in accum */ + int basebits = 1; /* # of bits in base-1 */ + i = base; + while ((i >>= 1) > 1) + ++basebits; - if (writer) { - writer->pos += sz; - } - else if (bytes_writer) { - (*bytes_str) += sz; + for (i = 0; i < size_a; ++i) { + accum |= (twodigits)a->ob_digit[i] << accumbits; + accumbits += PyLong_SHIFT; + assert(accumbits >= basebits); + do { + char cdigit = (char)(accum & (base - 1)); + cdigit += (cdigit < 10) ? '0' : 'a'-10; + assert(p > PyString_AS_STRING(str)); + *--p = cdigit; + accumbits -= basebits; + accum >>= basebits; + } while (i < size_a-1 ? accumbits >= basebits : accum > 0); + } } else { - assert(_PyUnicode_CheckConsistency(v, 1)); - *p_output = v; - } - return 0; -} + /* Not 0, and base not a power of 2. Divide repeatedly by + base, but for speed use the highest power of base that + fits in a digit. */ + Py_ssize_t size = size_a; + digit *pin = a->ob_digit; + PyLongObject *scratch; + /* powbasw <- largest power of base that fits in a digit. */ + digit powbase = base; /* powbase == base ** power */ + int power = 1; + for (;;) { + twodigits newpow = powbase * (twodigits)base; + if (newpow >> PyLong_SHIFT) + /* doesn't fit in a digit */ + break; + powbase = (digit)newpow; + ++power; + } -PyObject * -_PyLong_Format(PyObject *obj, int base) -{ - PyObject *str; - int err; - if (base == 10) - err = long_to_decimal_string_internal(obj, &str, NULL, NULL, NULL); - else - err = long_format_binary(obj, base, 1, &str, NULL, NULL, NULL); - if (err == -1) - return NULL; - return str; -} + /* Get a scratch area for repeated division. */ + scratch = _PyLong_New(size); + if (scratch == NULL) { + Py_DECREF(str); + return NULL; + } -int -_PyLong_FormatWriter(_PyUnicodeWriter *writer, - PyObject *obj, - int base, int alternate) -{ - if (base == 10) - return long_to_decimal_string_internal(obj, NULL, writer, - NULL, NULL); - else - return long_format_binary(obj, base, alternate, NULL, writer, - NULL, NULL); -} + /* Repeatedly divide by powbase. */ + do { + int ntostore = power; + digit rem = inplace_divrem1(scratch->ob_digit, + pin, size, powbase); + pin = scratch->ob_digit; /* no need to use a again */ + if (pin[size - 1] == 0) + --size; + SIGCHECK({ + Py_DECREF(scratch); + Py_DECREF(str); + return NULL; + }); -char* -_PyLong_FormatBytesWriter(_PyBytesWriter *writer, char *str, - PyObject *obj, - int base, int alternate) -{ - char *str2; - int res; - str2 = str; - if (base == 10) - res = long_to_decimal_string_internal(obj, NULL, NULL, - writer, &str2); - else - res = long_format_binary(obj, base, alternate, NULL, NULL, - writer, &str2); - if (res < 0) - return NULL; - assert(str2 != NULL); - return str2; + /* Break rem into digits. */ + assert(ntostore > 0); + do { + digit nextrem = (digit)(rem / base); + char c = (char)(rem - nextrem * base); + assert(p > PyString_AS_STRING(str)); + c += (c < 10) ? '0' : 'a'-10; + *--p = c; + rem = nextrem; + --ntostore; + /* Termination is a bit delicate: must not + store leading zeroes, so must get out if + remaining quotient and rem are both 0. */ + } while (ntostore && (size || rem)); + } while (size != 0); + Py_DECREF(scratch); + } + + if (base == 2) { + *--p = 'b'; + *--p = '0'; + } + else if (base == 8) { + if (newstyle) { + *--p = 'o'; + *--p = '0'; + } + else + if (size_a != 0) + *--p = '0'; + } + else if (base == 16) { + *--p = 'x'; + *--p = '0'; + } + else if (base != 10) { + *--p = '#'; + *--p = '0' + base%10; + if (base > 10) + *--p = '0' + base/10; + } + if (sign) + *--p = sign; + if (p != PyString_AS_STRING(str)) { + char *q = PyString_AS_STRING(str); + assert(p > q); + do { + } while ((*q++ = *p++) != '\0'); + q--; + _PyString_Resize((PyObject **)&str, + (Py_ssize_t) (q - PyString_AS_STRING(str))); + } + return (PyObject *)str; } /* Table of digit values for 8-bit string -> integer conversion. @@ -2124,9 +1624,9 @@ _PyLong_FormatBytesWriter(_PyBytesWriter *writer, char *str, * 'a' and 'A' map to 10, ..., 'z' and 'Z' map to 35. * All other indices map to 37. * Note that when converting a base B string, a char c is a legitimate - * base B digit iff _PyLong_DigitValue[Py_CHARPyLong_MASK(c)] < B. + * base B digit iff _PyLong_DigitValue[Py_CHARMASK(c)] < B. */ -unsigned char _PyLong_DigitValue[256] = { +int _PyLong_DigitValue[256] = { 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, @@ -2147,21 +1647,15 @@ unsigned char _PyLong_DigitValue[256] = { /* *str points to the first digit in a string of base `base` digits. base * is a power of 2 (2, 4, 8, 16, or 32). *str is set to point to the first - * non-digit (which may be *str!). A normalized int is returned. + * non-digit (which may be *str!). A normalized long is returned. * The point to this routine is that it takes time linear in the number of * string characters. - * - * Return values: - * -1 on syntax error (exception needs to be set, *res is untouched) - * 0 else (exception may be set, in that case *res is set to NULL) */ -static int -long_from_binary_base(const char **str, int base, PyLongObject **res) +static PyLongObject * +long_from_binary_base(char **str, int base) { - const char *p = *str; - const char *start = p; - char prev = 0; - Py_ssize_t digits = 0; + char *p = *str; + char *start = p; int bits_per_char; Py_ssize_t n; PyLongObject *z; @@ -2171,55 +1665,31 @@ long_from_binary_base(const char **str, int base, PyLongObject **res) assert(base >= 2 && base <= 32 && (base & (base - 1)) == 0); n = base; - for (bits_per_char = -1; n; ++bits_per_char) { + for (bits_per_char = -1; n; ++bits_per_char) n >>= 1; - } - /* count digits and set p to end-of-string */ - while (_PyLong_DigitValue[Py_CHARMASK(*p)] < base || *p == '_') { - if (*p == '_') { - if (prev == '_') { - *str = p - 1; - return -1; - } - } else { - ++digits; - } - prev = *p; + /* n <- total # of bits needed, while setting p to end-of-string */ + while (_PyLong_DigitValue[Py_CHARMASK(*p)] < base) ++p; - } - if (prev == '_') { - /* Trailing underscore not allowed. */ - *str = p - 1; - return -1; - } - *str = p; - /* n <- the number of Python digits needed, - = ceiling((digits * bits_per_char) / PyLong_SHIFT). */ - if (digits > (PY_SSIZE_T_MAX - (PyLong_SHIFT - 1)) / bits_per_char) { + /* n <- # of Python digits needed, = ceiling(n/PyLong_SHIFT). */ + n = (p - start) * bits_per_char + PyLong_SHIFT - 1; + if (n / bits_per_char < p - start) { PyErr_SetString(PyExc_ValueError, - "int string too large to convert"); - *res = NULL; - return 0; + "long string too large to convert"); + return NULL; } - n = (digits * bits_per_char + PyLong_SHIFT - 1) / PyLong_SHIFT; + n = n / PyLong_SHIFT; z = _PyLong_New(n); - if (z == NULL) { - *res = NULL; - return 0; - } - /* Read string from right, and fill in int from left; i.e., + if (z == NULL) + return NULL; + /* Read string from right, and fill in long from left; i.e., * from least to most significant in both. */ accum = 0; bits_in_accum = 0; pdigit = z->ob_digit; while (--p >= start) { - int k; - if (*p == '_') { - continue; - } - k = (int)_PyLong_DigitValue[Py_CHARMASK(*p)]; + int k = _PyLong_DigitValue[Py_CHARMASK(*p)]; assert(k >= 0 && k < base); accum |= (twodigits)k << bits_in_accum; bits_in_accum += bits_per_char; @@ -2238,85 +1708,60 @@ long_from_binary_base(const char **str, int base, PyLongObject **res) } while (pdigit - z->ob_digit < n) *pdigit++ = 0; - *res = long_normalize(z); - return 0; + return long_normalize(z); } -/* Parses an int from a bytestring. Leading and trailing whitespace will be - * ignored. - * - * If successful, a PyLong object will be returned and 'pend' will be pointing - * to the first unused byte unless it's NULL. - * - * If unsuccessful, NULL will be returned. - */ PyObject * -PyLong_FromString(const char *str, char **pend, int base) +PyLong_FromString(char *str, char **pend, int base) { - int sign = 1, error_if_nonzero = 0; - const char *start, *orig_str = str; - PyLongObject *z = NULL; - PyObject *strobj; + int sign = 1; + char *start, *orig_str = str; + PyLongObject *z; + PyObject *strobj, *strrepr; Py_ssize_t slen; if ((base != 0 && base < 2) || base > 36) { PyErr_SetString(PyExc_ValueError, - "int() arg 2 must be >= 2 and <= 36"); + "long() base must be >= 2 and <= 36, or 0"); return NULL; } - while (*str != '\0' && Py_ISSPACE(*str)) { + while (*str != '\0' && isspace(Py_CHARMASK(*str))) str++; - } - if (*str == '+') { + if (*str == '+') ++str; - } else if (*str == '-') { ++str; sign = -1; } + while (*str != '\0' && isspace(Py_CHARMASK(*str))) + str++; if (base == 0) { - if (str[0] != '0') { + /* No base given. Deduce the base from the contents + of the string */ + if (str[0] != '0') base = 10; - } - else if (str[1] == 'x' || str[1] == 'X') { + else if (str[1] == 'x' || str[1] == 'X') base = 16; - } - else if (str[1] == 'o' || str[1] == 'O') { + else if (str[1] == 'o' || str[1] == 'O') base = 8; - } - else if (str[1] == 'b' || str[1] == 'B') { + else if (str[1] == 'b' || str[1] == 'B') base = 2; - } - else { - /* "old" (C-style) octal literal, now invalid. - it might still be zero though */ - error_if_nonzero = 1; - base = 10; - } + else + /* "old" (C-style) octal literal, still valid in + 2.x, although illegal in 3.x */ + base = 8; } + /* Whether or not we were deducing the base, skip leading chars + as needed */ if (str[0] == '0' && ((base == 16 && (str[1] == 'x' || str[1] == 'X')) || (base == 8 && (str[1] == 'o' || str[1] == 'O')) || - (base == 2 && (str[1] == 'b' || str[1] == 'B')))) { + (base == 2 && (str[1] == 'b' || str[1] == 'B')))) str += 2; - /* One underscore allowed here. */ - if (*str == '_') { - ++str; - } - } - if (str[0] == '_') { - /* May not start with underscores. */ - goto onError; - } start = str; - if ((base & (base - 1)) == 0) { - int res = long_from_binary_base(&str, base, &z); - if (res < 0) { - /* Syntax error. */ - goto onError; - } - } + if ((base & (base - 1)) == 0) + z = long_from_binary_base(&str, base); else { /*** Binary bases can be converted in time linear in the number of digits, because @@ -2327,18 +1772,19 @@ First some math: the largest integer that can be expressed in N base-B digits is B**N-1. Consequently, if we have an N-digit input in base B, the worst- case number of Python digits needed to hold it is the smallest integer n s.t. - BASE**n-1 >= B**N-1 [or, adding 1 to both sides] - BASE**n >= B**N [taking logs to base BASE] - n >= log(B**N)/log(BASE) = N * log(B)/log(BASE) + PyLong_BASE**n-1 >= B**N-1 [or, adding 1 to both sides] + PyLong_BASE**n >= B**N [taking logs to base PyLong_BASE] + n >= log(B**N)/log(PyLong_BASE) = N * log(B)/log(PyLong_BASE) -The static array log_base_BASE[base] == log(base)/log(BASE) so we can compute -this quickly. A Python int with that much space is reserved near the start, -and the result is computed into it. +The static array log_base_PyLong_BASE[base] == log(base)/log(PyLong_BASE) so +we can compute this quickly. A Python long with that much space is reserved +near the start, and the result is computed into it. The input string is actually treated as being in base base**i (i.e., i digits are processed at a time), where two more static arrays hold: - convwidth_base[base] = the largest integer i such that base**i <= BASE + convwidth_base[base] = the largest integer i such that + base**i <= PyLong_BASE convmultmax_base[base] = base ** convwidth_base[base] The first of these is the largest i such that i consecutive input digits @@ -2355,40 +1801,41 @@ where B = convmultmax_base[base]. Error analysis: as above, the number of Python digits `n` needed is worst- case - n >= N * log(B)/log(BASE) + n >= N * log(B)/log(PyLong_BASE) where `N` is the number of input digits in base `B`. This is computed via - size_z = (Py_ssize_t)((scan - str) * log_base_BASE[base]) + 1; + size_z = (Py_ssize_t)((scan - str) * log_base_PyLong_BASE[base]) + 1; below. Two numeric concerns are how much space this can waste, and whether -the computed result can be too small. To be concrete, assume BASE = 2**15, -which is the default (and it's unlikely anyone changes that). +the computed result can be too small. To be concrete, assume PyLong_BASE = +2**15, which is the default (and it's unlikely anyone changes that). -Waste isn't a problem: provided the first input digit isn't 0, the difference +Waste isn't a problem: provided the first input digit isn't 0, the difference between the worst-case input with N digits and the smallest input with N -digits is about a factor of B, but B is small compared to BASE so at most -one allocated Python digit can remain unused on that count. If -N*log(B)/log(BASE) is mathematically an exact integer, then truncating that -and adding 1 returns a result 1 larger than necessary. However, that can't -happen: whenever B is a power of 2, long_from_binary_base() is called -instead, and it's impossible for B**i to be an integer power of 2**15 when -B is not a power of 2 (i.e., it's impossible for N*log(B)/log(BASE) to be +digits is about a factor of B, but B is small compared to PyLong_BASE so at +most one allocated Python digit can remain unused on that count. If +N*log(B)/log(PyLong_BASE) is mathematically an exact integer, then truncating +that and adding 1 returns a result 1 larger than necessary. However, that +can't happen: whenever B is a power of 2, long_from_binary_base() is called +instead, and it's impossible for B**i to be an integer power of 2**15 when B +is not a power of 2 (i.e., it's impossible for N*log(B)/log(PyLong_BASE) to be an exact integer when B is not a power of 2, since B**i has a prime factor other than 2 in that case, but (2**15)**j's only prime factor is 2). -The computed result can be too small if the true value of N*log(B)/log(BASE) -is a little bit larger than an exact integer, but due to roundoff errors (in -computing log(B), log(BASE), their quotient, and/or multiplying that by N) -yields a numeric result a little less than that integer. Unfortunately, "how -close can a transcendental function get to an integer over some range?" -questions are generally theoretically intractable. Computer analysis via -continued fractions is practical: expand log(B)/log(BASE) via continued -fractions, giving a sequence i/j of "the best" rational approximations. Then -j*log(B)/log(BASE) is approximately equal to (the integer) i. This shows that -we can get very close to being in trouble, but very rarely. For example, -76573 is a denominator in one of the continued-fraction approximations to -log(10)/log(2**15), and indeed: +The computed result can be too small if the true value of +N*log(B)/log(PyLong_BASE) is a little bit larger than an exact integer, but +due to roundoff errors (in computing log(B), log(PyLong_BASE), their quotient, +and/or multiplying that by N) yields a numeric result a little less than that +integer. Unfortunately, "how close can a transcendental function get to an +integer over some range?" questions are generally theoretically intractable. +Computer analysis via continued fractions is practical: expand +log(B)/log(PyLong_BASE) via continued fractions, giving a sequence i/j of "the +best" rational approximations. Then j*log(B)/log(PyLong_BASE) is +approximately equal to (the integer) i. This shows that we can get very close +to being in trouble, but very rarely. For example, 76573 is a denominator in +one of the continued-fraction approximations to log(10)/log(2**15), and +indeed: >>> log(10)/log(2**15)*76573 16958.000000654003 @@ -2397,37 +1844,34 @@ is very close to an integer. If we were working with IEEE single-precision, rounding errors could kill us. Finding worst cases in IEEE double-precision requires better-than-double-precision log() functions, and Tim didn't bother. Instead the code checks to see whether the allocated space is enough as each -new Python digit is added, and copies the whole thing to a larger int if not. +new Python digit is added, and copies the whole thing to a larger long if not. This should happen extremely rarely, and in fact I don't have a test case that triggers it(!). Instead the code was tested by artificially allocating just 1 digit at the start, so that the copying code was exercised for every digit beyond the first. ***/ - twodigits c; /* current input character */ + register twodigits c; /* current input character */ Py_ssize_t size_z; - Py_ssize_t digits = 0; int i; int convwidth; twodigits convmultmax, convmult; digit *pz, *pzstop; - const char *scan, *lastdigit; - char prev = 0; + char* scan; - static double log_base_BASE[37] = {0.0e0,}; + static double log_base_PyLong_BASE[37] = {0.0e0,}; static int convwidth_base[37] = {0,}; static twodigits convmultmax_base[37] = {0,}; - if (log_base_BASE[base] == 0.0) { + if (log_base_PyLong_BASE[base] == 0.0) { twodigits convmax = base; int i = 1; - log_base_BASE[base] = (log((double)base) / - log((double)PyLong_BASE)); + log_base_PyLong_BASE[base] = (log((double)base) / + log((double)PyLong_BASE)); for (;;) { twodigits next = convmax * base; - if (next > PyLong_BASE) { + if (next > PyLong_BASE) break; - } convmax = next; ++i; } @@ -2438,50 +1882,21 @@ digit beyond the first. /* Find length of the string of numeric characters. */ scan = str; - lastdigit = str; - - while (_PyLong_DigitValue[Py_CHARMASK(*scan)] < base || *scan == '_') { - if (*scan == '_') { - if (prev == '_') { - /* Only one underscore allowed. */ - str = lastdigit + 1; - goto onError; - } - } - else { - ++digits; - lastdigit = scan; - } - prev = *scan; + while (_PyLong_DigitValue[Py_CHARMASK(*scan)] < base) ++scan; - } - if (prev == '_') { - /* Trailing underscore not allowed. */ - /* Set error pointer to first underscore. */ - str = lastdigit + 1; - goto onError; - } - /* Create an int object that can contain the largest possible + /* Create a long object that can contain the largest possible * integer with this base and length. Note that there's no * need to initialize z->ob_digit -- no slot is read up before * being stored into. */ - double fsize_z = (double)digits * log_base_BASE[base] + 1.0; - if (fsize_z > (double)MAX_LONG_DIGITS) { - /* The same exception as in _PyLong_New(). */ - PyErr_SetString(PyExc_OverflowError, - "too many digits in integer"); - return NULL; - } - size_z = (Py_ssize_t)fsize_z; + size_z = (Py_ssize_t)((scan - str) * log_base_PyLong_BASE[base]) + 1; /* Uncomment next line to test exceedingly rare copy code */ /* size_z = 1; */ assert(size_z > 0); z = _PyLong_New(size_z); - if (z == NULL) { + if (z == NULL) return NULL; - } Py_SIZE(z) = 0; /* `convwidth` consecutive input digits are treated as a single @@ -2492,19 +1907,11 @@ digit beyond the first. /* Work ;-) */ while (str < scan) { - if (*str == '_') { - str++; - continue; - } /* grab up to convwidth digits from the input string */ c = (digit)_PyLong_DigitValue[Py_CHARMASK(*str++)]; - for (i = 1; i < convwidth && str != scan; ++str) { - if (*str == '_') { - continue; - } - i++; + for (i = 1; i < convwidth && str != scan; ++i, ++str) { c = (twodigits)(c * base + - (int)_PyLong_DigitValue[Py_CHARMASK(*str)]); + _PyLong_DigitValue[Py_CHARMASK(*str)]); assert(c < PyLong_BASE); } @@ -2514,9 +1921,8 @@ digit beyond the first. */ if (i != convwidth) { convmult = base; - for ( ; i > 1; --i) { + for ( ; i > 1; --i) convmult *= base; - } } /* Multiply z by convmult, and add c. */ @@ -2554,152 +1960,87 @@ digit beyond the first. } } } - if (z == NULL) { + if (z == NULL) return NULL; - } - if (error_if_nonzero) { - /* reset the base to 0, else the exception message - doesn't make too much sense */ - base = 0; - if (Py_SIZE(z) != 0) { - goto onError; - } - /* there might still be other problems, therefore base - remains zero here for the same reason */ - } - if (str == start) { + if (str == start) goto onError; - } - if (sign < 0) { + if (sign < 0) Py_SIZE(z) = -(Py_SIZE(z)); - } - while (*str && Py_ISSPACE(*str)) { + if (*str == 'L' || *str == 'l') str++; - } - if (*str != '\0') { + while (*str && isspace(Py_CHARMASK(*str))) + str++; + if (*str != '\0') goto onError; - } - long_normalize(z); - z = maybe_small_long(z); - if (z == NULL) { - return NULL; - } - if (pend != NULL) { - *pend = (char *)str; - } + if (pend) + *pend = str; return (PyObject *) z; onError: - if (pend != NULL) { - *pend = (char *)str; - } Py_XDECREF(z); slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200; - strobj = PyUnicode_FromStringAndSize(orig_str, slen); - if (strobj == NULL) { + strobj = PyString_FromStringAndSize(orig_str, slen); + if (strobj == NULL) return NULL; - } - PyErr_Format(PyExc_ValueError, - "invalid literal for int() with base %d: %.200R", - base, strobj); + strrepr = PyObject_Repr(strobj); Py_DECREF(strobj); + if (strrepr == NULL) + return NULL; + PyErr_Format(PyExc_ValueError, + "invalid literal for long() with base %d: %s", + base, PyString_AS_STRING(strrepr)); + Py_DECREF(strrepr); return NULL; } -/* Since PyLong_FromString doesn't have a length parameter, - * check here for possible NULs in the string. - * - * Reports an invalid literal as a bytes object. - */ -PyObject * -_PyLong_FromBytes(const char *s, Py_ssize_t len, int base) -{ - PyObject *result, *strobj; - char *end = NULL; - - result = PyLong_FromString(s, &end, base); - if (end == NULL || (result != NULL && end == s + len)) - return result; - Py_XDECREF(result); - strobj = PyBytes_FromStringAndSize(s, Py_MIN(len, 200)); - if (strobj != NULL) { - PyErr_Format(PyExc_ValueError, - "invalid literal for int() with base %d: %.200R", - base, strobj); - Py_DECREF(strobj); - } - return NULL; -} - +#ifdef Py_USING_UNICODE PyObject * PyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base) { - PyObject *v, *unicode = PyUnicode_FromWideChar(u, length); - if (unicode == NULL) - return NULL; - v = PyLong_FromUnicodeObject(unicode, base); - Py_DECREF(unicode); - return v; -} + PyObject *result; + char *buffer = (char *)PyMem_MALLOC(length+1); -PyObject * -PyLong_FromUnicodeObject(PyObject *u, int base) -{ - PyObject *result, *asciidig; - const char *buffer; - char *end = NULL; - Py_ssize_t buflen; + if (buffer == NULL) + return NULL; - asciidig = _PyUnicode_TransformDecimalAndSpaceToASCII(u); - if (asciidig == NULL) + if (PyUnicode_EncodeDecimal(u, length, buffer, NULL)) { + PyMem_FREE(buffer); return NULL; - assert(PyUnicode_IS_ASCII(asciidig)); - /* Simply get a pointer to existing ASCII characters. */ - buffer = PyUnicode_AsUTF8AndSize(asciidig, &buflen); - assert(buffer != NULL); - - result = PyLong_FromString(buffer, &end, base); - if (end == NULL || (result != NULL && end == buffer + buflen)) { - Py_DECREF(asciidig); - return result; } - Py_DECREF(asciidig); - Py_XDECREF(result); - PyErr_Format(PyExc_ValueError, - "invalid literal for int() with base %d: %.200R", - base, u); - return NULL; + result = PyLong_FromString(buffer, NULL, base); + PyMem_FREE(buffer); + return result; } +#endif /* forward */ static PyLongObject *x_divrem (PyLongObject *, PyLongObject *, PyLongObject **); static PyObject *long_long(PyObject *v); -/* Int division with remainder, top-level routine */ +/* Long division with remainder, top-level routine */ static int long_divrem(PyLongObject *a, PyLongObject *b, PyLongObject **pdiv, PyLongObject **prem) { - Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b)); + Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); PyLongObject *z; if (size_b == 0) { PyErr_SetString(PyExc_ZeroDivisionError, - "integer division or modulo by zero"); + "long division or modulo by zero"); return -1; } if (size_a < size_b || (size_a == size_b && a->ob_digit[size_a-1] < b->ob_digit[size_b-1])) { /* |a| < |b|. */ - *prem = (PyLongObject *)long_long((PyObject *)a); - if (*prem == NULL) { + *pdiv = _PyLong_New(0); + if (*pdiv == NULL) return -1; - } - Py_INCREF(_PyLong_Zero); - *pdiv = (PyLongObject*)_PyLong_Zero; + Py_INCREF(a); + *prem = (PyLongObject *) a; return 0; } if (size_b == 1) { @@ -2722,27 +2063,16 @@ long_divrem(PyLongObject *a, PyLongObject *b, The quotient z has the sign of a*b; the remainder r has the sign of a, so a = b*z + r. */ - if ((Py_SIZE(a) < 0) != (Py_SIZE(b) < 0)) { - _PyLong_Negate(&z); - if (z == NULL) { - Py_CLEAR(*prem); - return -1; - } - } - if (Py_SIZE(a) < 0 && Py_SIZE(*prem) != 0) { - _PyLong_Negate(prem); - if (*prem == NULL) { - Py_DECREF(z); - Py_CLEAR(*prem); - return -1; - } - } - *pdiv = maybe_small_long(z); + if ((Py_SIZE(a) < 0) != (Py_SIZE(b) < 0)) + Py_SIZE(z) = -(Py_SIZE(z)); + if (Py_SIZE(a) < 0 && Py_SIZE(*prem) != 0) + Py_SIZE(*prem) = -Py_SIZE(*prem); + *pdiv = z; return 0; } -/* Unsigned int division with remainder -- the algorithm. The arguments v1 - and w1 should satisfy 2 <= Py_ABS(Py_SIZE(w1)) <= Py_ABS(Py_SIZE(v1)). */ +/* Unsigned long division with remainder -- the algorithm. The arguments v1 + and w1 should satisfy 2 <= ABS(Py_SIZE(w1)) <= ABS(Py_SIZE(v1)). */ static PyLongObject * x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem) @@ -2762,8 +2092,8 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem) that won't overflow a digit. */ /* allocate space; w will also be used to hold the final remainder */ - size_v = Py_ABS(Py_SIZE(v1)); - size_w = Py_ABS(Py_SIZE(w1)); + size_v = ABS(Py_SIZE(v1)); + size_w = ABS(Py_SIZE(w1)); assert(size_v >= size_w && size_w >= 2); /* Assert checks by div() */ v = _PyLong_New(size_v+1); if (v == NULL) { @@ -2894,7 +2224,7 @@ _PyLong_Frexp(PyLongObject *a, Py_ssize_t *e) multiple of 4, rounding ties to a multiple of 8. */ static const int half_even_correction[8] = {0, -1, -2, 1, 0, -1, 2, 1}; - a_size = Py_ABS(Py_SIZE(a)); + a_size = ABS(Py_SIZE(a)); if (a_size == 0) { /* Special case for 0: significand 0.0, exponent 0. */ *e = 0; @@ -2964,7 +2294,8 @@ _PyLong_Frexp(PyLongObject *a, Py_ssize_t *e) break; } } - assert(1 <= x_size && x_size <= (Py_ssize_t)Py_ARRAY_LENGTH(x_digits)); + assert(1 <= x_size && + x_size <= (Py_ssize_t)(sizeof(x_digits)/sizeof(digit))); /* Round, and convert to double. */ x_digits[0] += half_even_correction[x_digits[0] & 7]; @@ -2992,7 +2323,7 @@ _PyLong_Frexp(PyLongObject *a, Py_ssize_t *e) return -1.0; } -/* Get a C double from an int object. Rounds to the nearest double, +/* Get a C double from a long int object. Rounds to the nearest double, using the round-half-to-even rule in the case of a tie. */ double @@ -3001,25 +2332,14 @@ PyLong_AsDouble(PyObject *v) Py_ssize_t exponent; double x; - if (v == NULL) { + if (v == NULL || !PyLong_Check(v)) { PyErr_BadInternalCall(); return -1.0; } - if (!PyLong_Check(v)) { - PyErr_SetString(PyExc_TypeError, "an integer is required"); - return -1.0; - } - if (Py_ABS(Py_SIZE(v)) <= 1) { - /* Fast path; single digit long (31 bits) will cast safely - to double. This improves performance of FP/long operations - by 20%. - */ - return (double)MEDIUM_VALUE((PyLongObject *)v); - } x = _PyLong_Frexp((PyLongObject *)v, &exponent); if ((x == -1.0 && PyErr_Occurred()) || exponent > DBL_MAX_EXP) { PyErr_SetString(PyExc_OverflowError, - "int too large to convert to float"); + "long int too large to convert to float"); return -1.0; } return ldexp(x, (int)exponent); @@ -3027,104 +2347,90 @@ PyLong_AsDouble(PyObject *v) /* Methods */ -/* if a < b, return a negative number - if a == b, return 0 - if a > b, return a positive number */ +static void +long_dealloc(PyObject *v) +{ + Py_TYPE(v)->tp_free(v); +} -static Py_ssize_t -long_compare(PyLongObject *a, PyLongObject *b) +static PyObject * +long_repr(PyObject *v) { - Py_ssize_t sign = Py_SIZE(a) - Py_SIZE(b); - if (sign == 0) { - Py_ssize_t i = Py_ABS(Py_SIZE(a)); - sdigit diff = 0; - while (--i >= 0) { - diff = (sdigit) a->ob_digit[i] - (sdigit) b->ob_digit[i]; - if (diff) { - break; - } - } - sign = Py_SIZE(a) < 0 ? -diff : diff; - } - return sign; + return _PyLong_Format(v, 10, 1, 0); } static PyObject * -long_richcompare(PyObject *self, PyObject *other, int op) +long_str(PyObject *v) { - Py_ssize_t result; - CHECK_BINOP(self, other); - if (self == other) - result = 0; - else - result = long_compare((PyLongObject*)self, (PyLongObject*)other); - Py_RETURN_RICHCOMPARE(result, 0, op); + return _PyLong_Format(v, 10, 0, 0); } -static Py_hash_t +static int +long_compare(PyLongObject *a, PyLongObject *b) +{ + Py_ssize_t sign; + + if (Py_SIZE(a) != Py_SIZE(b)) { + sign = Py_SIZE(a) - Py_SIZE(b); + } + else { + Py_ssize_t i = ABS(Py_SIZE(a)); + while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i]) + ; + if (i < 0) + sign = 0; + else { + sign = (sdigit)a->ob_digit[i] - (sdigit)b->ob_digit[i]; + if (Py_SIZE(a) < 0) + sign = -sign; + } + } + return sign < 0 ? -1 : sign > 0 ? 1 : 0; +} + +static long long_hash(PyLongObject *v) { - Py_uhash_t x; + unsigned long x; Py_ssize_t i; int sign; + /* This is designed so that Python ints and longs with the + same value hash to the same value, otherwise comparisons + of mapping keys will turn out weird */ i = Py_SIZE(v); - switch(i) { - case -1: return v->ob_digit[0]==1 ? -2 : -(sdigit)v->ob_digit[0]; - case 0: return 0; - case 1: return v->ob_digit[0]; - } sign = 1; x = 0; if (i < 0) { sign = -1; i = -(i); } + /* The following loop produces a C unsigned long x such that x is + congruent to the absolute value of v modulo ULONG_MAX. The + resulting x is nonzero if and only if v is. */ while (--i >= 0) { - /* Here x is a quantity in the range [0, _PyHASH_MODULUS); we - want to compute x * 2**PyLong_SHIFT + v->ob_digit[i] modulo - _PyHASH_MODULUS. - - The computation of x * 2**PyLong_SHIFT % _PyHASH_MODULUS - amounts to a rotation of the bits of x. To see this, write - - x * 2**PyLong_SHIFT = y * 2**_PyHASH_BITS + z - - where y = x >> (_PyHASH_BITS - PyLong_SHIFT) gives the top - PyLong_SHIFT bits of x (those that are shifted out of the - original _PyHASH_BITS bits, and z = (x << PyLong_SHIFT) & - _PyHASH_MODULUS gives the bottom _PyHASH_BITS - PyLong_SHIFT - bits of x, shifted up. Then since 2**_PyHASH_BITS is - congruent to 1 modulo _PyHASH_MODULUS, y*2**_PyHASH_BITS is - congruent to y modulo _PyHASH_MODULUS. So - - x * 2**PyLong_SHIFT = y + z (mod _PyHASH_MODULUS). - - The right-hand side is just the result of rotating the - _PyHASH_BITS bits of x left by PyLong_SHIFT places; since - not all _PyHASH_BITS bits of x are 1s, the same is true - after rotation, so 0 <= y+z < _PyHASH_MODULUS and y + z is - the reduction of x*2**PyLong_SHIFT modulo - _PyHASH_MODULUS. */ - x = ((x << PyLong_SHIFT) & _PyHASH_MODULUS) | - (x >> (_PyHASH_BITS - PyLong_SHIFT)); + /* Force a native long #-bits (32 or 64) circular shift */ + x = (x >> (8*SIZEOF_LONG-PyLong_SHIFT)) | (x << PyLong_SHIFT); x += v->ob_digit[i]; - if (x >= _PyHASH_MODULUS) - x -= _PyHASH_MODULUS; + /* If the addition above overflowed we compensate by + incrementing. This preserves the value modulo + ULONG_MAX. */ + if (x < v->ob_digit[i]) + x++; } x = x * sign; - if (x == (Py_uhash_t)-1) - x = (Py_uhash_t)-2; - return (Py_hash_t)x; + if (x == (unsigned long)-1) + x = (unsigned long)-2; + return (long)x; } -/* Add the absolute values of two integers. */ +/* Add the absolute values of two long integers. */ static PyLongObject * x_add(PyLongObject *a, PyLongObject *b) { - Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b)); + Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); PyLongObject *z; Py_ssize_t i; digit carry = 0; @@ -3158,7 +2464,7 @@ x_add(PyLongObject *a, PyLongObject *b) static PyLongObject * x_sub(PyLongObject *a, PyLongObject *b) { - Py_ssize_t size_a = Py_ABS(Py_SIZE(a)), size_b = Py_ABS(Py_SIZE(b)); + Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); PyLongObject *z; Py_ssize_t i; int sign = 1; @@ -3178,7 +2484,7 @@ x_sub(PyLongObject *a, PyLongObject *b) while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i]) ; if (i < 0) - return (PyLongObject *)PyLong_FromLong(0); + return _PyLong_New(0); if (a->ob_digit[i] < b->ob_digit[i]) { sign = -1; { PyLongObject *temp = a; a = b; b = temp; } @@ -3203,33 +2509,23 @@ x_sub(PyLongObject *a, PyLongObject *b) borrow &= 1; /* Keep only one sign bit */ } assert(borrow == 0); - if (sign < 0) { - Py_SIZE(z) = -Py_SIZE(z); - } - return maybe_small_long(long_normalize(z)); + if (sign < 0) + Py_SIZE(z) = -(Py_SIZE(z)); + return long_normalize(z); } static PyObject * -long_add(PyLongObject *a, PyLongObject *b) +long_add(PyLongObject *v, PyLongObject *w) { - PyLongObject *z; + PyLongObject *a, *b, *z; - CHECK_BINOP(a, b); + CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); - if (Py_ABS(Py_SIZE(a)) <= 1 && Py_ABS(Py_SIZE(b)) <= 1) { - return PyLong_FromLong(MEDIUM_VALUE(a) + MEDIUM_VALUE(b)); - } if (Py_SIZE(a) < 0) { if (Py_SIZE(b) < 0) { z = x_add(a, b); - if (z != NULL) { - /* x_add received at least one multiple-digit int, - and thus z must be a multiple-digit int. - That also means z is not an element of - small_ints, so negating it in-place is safe. */ - assert(Py_REFCNT(z) == 1); + if (z != NULL && Py_SIZE(z) != 0) Py_SIZE(z) = -(Py_SIZE(z)); - } } else z = x_sub(b, a); @@ -3240,30 +2536,25 @@ long_add(PyLongObject *a, PyLongObject *b) else z = x_add(a, b); } + Py_DECREF(a); + Py_DECREF(b); return (PyObject *)z; } static PyObject * -long_sub(PyLongObject *a, PyLongObject *b) +long_sub(PyLongObject *v, PyLongObject *w) { - PyLongObject *z; + PyLongObject *a, *b, *z; - CHECK_BINOP(a, b); + CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); - if (Py_ABS(Py_SIZE(a)) <= 1 && Py_ABS(Py_SIZE(b)) <= 1) { - return PyLong_FromLong(MEDIUM_VALUE(a) - MEDIUM_VALUE(b)); - } if (Py_SIZE(a) < 0) { - if (Py_SIZE(b) < 0) { - z = x_sub(b, a); - } - else { + if (Py_SIZE(b) < 0) + z = x_sub(a, b); + else z = x_add(a, b); - if (z != NULL) { - assert(Py_SIZE(z) == 0 || Py_REFCNT(z) == 1); - Py_SIZE(z) = -(Py_SIZE(z)); - } - } + if (z != NULL && Py_SIZE(z) != 0) + Py_SIZE(z) = -(Py_SIZE(z)); } else { if (Py_SIZE(b) < 0) @@ -3271,6 +2562,8 @@ long_sub(PyLongObject *a, PyLongObject *b) else z = x_sub(a, b); } + Py_DECREF(a); + Py_DECREF(b); return (PyObject *)z; } @@ -3281,8 +2574,8 @@ static PyLongObject * x_mul(PyLongObject *a, PyLongObject *b) { PyLongObject *z; - Py_ssize_t size_a = Py_ABS(Py_SIZE(a)); - Py_ssize_t size_b = Py_ABS(Py_SIZE(b)); + Py_ssize_t size_a = ABS(Py_SIZE(a)); + Py_ssize_t size_b = ABS(Py_SIZE(b)); Py_ssize_t i; z = _PyLong_New(size_a + size_b); @@ -3334,7 +2627,7 @@ x_mul(PyLongObject *a, PyLongObject *b) assert((carry >> PyLong_SHIFT) == 0); } } - else { /* a is not the same as b -- gradeschool int mult */ + else { /* a is not the same as b -- gradeschool long mult */ for (i = 0; i < size_a; ++i) { twodigits carry = 0; twodigits f = a->ob_digit[i]; @@ -3362,7 +2655,7 @@ x_mul(PyLongObject *a, PyLongObject *b) } /* A helper for Karatsuba multiplication (k_mul). - Takes an int "n" and an integer "size" representing the place to + Takes a long "n" and an integer "size" representing the place to split, and sets low and high such that abs(n) == (high << size) + low, viewing the shift as being by digits. The sign bit is ignored, and the return values are >= 0. @@ -3376,9 +2669,9 @@ kmul_split(PyLongObject *n, { PyLongObject *hi, *lo; Py_ssize_t size_lo, size_hi; - const Py_ssize_t size_n = Py_ABS(Py_SIZE(n)); + const Py_ssize_t size_n = ABS(Py_SIZE(n)); - size_lo = Py_MIN(size_n, size); + size_lo = MIN(size_n, size); size_hi = size_n - size_lo; if ((hi = _PyLong_New(size_hi)) == NULL) @@ -3405,8 +2698,8 @@ static PyLongObject *k_lopsided_mul(PyLongObject *a, PyLongObject *b); static PyLongObject * k_mul(PyLongObject *a, PyLongObject *b) { - Py_ssize_t asize = Py_ABS(Py_SIZE(a)); - Py_ssize_t bsize = Py_ABS(Py_SIZE(b)); + Py_ssize_t asize = ABS(Py_SIZE(a)); + Py_ssize_t bsize = ABS(Py_SIZE(b)); PyLongObject *ah = NULL; PyLongObject *al = NULL; PyLongObject *bh = NULL; @@ -3441,7 +2734,7 @@ k_mul(PyLongObject *a, PyLongObject *b) i = a == b ? KARATSUBA_SQUARE_CUTOFF : KARATSUBA_CUTOFF; if (asize <= i) { if (asize == 0) - return (PyLongObject *)PyLong_FromLong(0); + return _PyLong_New(0); else return x_mul(a, b); } @@ -3449,7 +2742,7 @@ k_mul(PyLongObject *a, PyLongObject *b) /* If a is small compared to b, splitting on b gives a degenerate * case with ah==0, and Karatsuba may be (even much) less efficient * than "grade school" then. However, we can still win, by viewing - * b as a string of "big digits", each of width a->ob_size. That + * b as a string of "big digits", each of width Py_SIZE(a). That * leads to a sequence of balanced calls to k_mul. */ if (2 * asize <= bsize) @@ -3477,7 +2770,7 @@ k_mul(PyLongObject *a, PyLongObject *b) * 4. Subtract al*bl from the result, starting at shift. This may * underflow (borrow out of the high digit), but we don't care: * we're effectively doing unsigned arithmetic mod - * BASE**(sizea + sizeb), and so long as the *final* result fits, + * PyLong_BASE**(sizea + sizeb), and so long as the *final* result fits, * borrows and carries out of the high digit can be ignored. * 5. Subtract ah*bh from the result, starting at shift. * 6. Compute (ah+al)*(bh+bl), and add it into the result starting @@ -3617,7 +2910,7 @@ ah*bh and al*bl too. /* b has at least twice the digits of a, and a is big enough that Karatsuba * would pay off *if* the inputs had balanced sizes. View b as a sequence - * of slices, each with a->ob_size digits, and multiply the slices by a, + * of slices, each with Py_SIZE(a) digits, and multiply the slices by a, * one at a time. This gives k_mul balanced inputs to work with, and is * also cache-friendly (we compute one double-width slice of the result * at a time, then move on, never backtracking except for the helpful @@ -3626,8 +2919,8 @@ ah*bh and al*bl too. static PyLongObject * k_lopsided_mul(PyLongObject *a, PyLongObject *b) { - const Py_ssize_t asize = Py_ABS(Py_SIZE(a)); - Py_ssize_t bsize = Py_ABS(Py_SIZE(b)); + const Py_ssize_t asize = ABS(Py_SIZE(a)); + Py_ssize_t bsize = ABS(Py_SIZE(b)); Py_ssize_t nbdone; /* # of b digits already multiplied */ PyLongObject *ret; PyLongObject *bslice = NULL; @@ -3649,7 +2942,7 @@ k_lopsided_mul(PyLongObject *a, PyLongObject *b) nbdone = 0; while (bsize > 0) { PyLongObject *product; - const Py_ssize_t nbtouse = Py_MIN(bsize, asize); + const Py_ssize_t nbtouse = MIN(bsize, asize); /* Multiply the next slice of b by a. */ memcpy(bslice->ob_digit, b->ob_digit + nbdone, @@ -3678,74 +2971,24 @@ k_lopsided_mul(PyLongObject *a, PyLongObject *b) } static PyObject * -long_mul(PyLongObject *a, PyLongObject *b) +long_mul(PyLongObject *v, PyLongObject *w) { - PyLongObject *z; + PyLongObject *a, *b, *z; - CHECK_BINOP(a, b); - - /* fast path for single-digit multiplication */ - if (Py_ABS(Py_SIZE(a)) <= 1 && Py_ABS(Py_SIZE(b)) <= 1) { - stwodigits v = (stwodigits)(MEDIUM_VALUE(a)) * MEDIUM_VALUE(b); - return PyLong_FromLongLong((long long)v); + if (!convert_binop((PyObject *)v, (PyObject *)w, &a, &b)) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } z = k_mul(a, b); /* Negate if exactly one of the inputs is negative. */ - if (((Py_SIZE(a) ^ Py_SIZE(b)) < 0) && z) { - _PyLong_Negate(&z); - if (z == NULL) - return NULL; - } + if (((Py_SIZE(a) ^ Py_SIZE(b)) < 0) && z) + Py_SIZE(z) = -(Py_SIZE(z)); + Py_DECREF(a); + Py_DECREF(b); return (PyObject *)z; } -/* Fast modulo division for single-digit longs. */ -static PyObject * -fast_mod(PyLongObject *a, PyLongObject *b) -{ - sdigit left = a->ob_digit[0]; - sdigit right = b->ob_digit[0]; - sdigit mod; - - assert(Py_ABS(Py_SIZE(a)) == 1); - assert(Py_ABS(Py_SIZE(b)) == 1); - - if (Py_SIZE(a) == Py_SIZE(b)) { - /* 'a' and 'b' have the same sign. */ - mod = left % right; - } - else { - /* Either 'a' or 'b' is negative. */ - mod = right - 1 - (left - 1) % right; - } - - return PyLong_FromLong(mod * (sdigit)Py_SIZE(b)); -} - -/* Fast floor division for single-digit longs. */ -static PyObject * -fast_floor_div(PyLongObject *a, PyLongObject *b) -{ - sdigit left = a->ob_digit[0]; - sdigit right = b->ob_digit[0]; - sdigit div; - - assert(Py_ABS(Py_SIZE(a)) == 1); - assert(Py_ABS(Py_SIZE(b)) == 1); - - if (Py_SIZE(a) == Py_SIZE(b)) { - /* 'a' and 'b' have the same sign. */ - div = left / right; - } - else { - /* Either 'a' or 'b' is negative. */ - div = -1 - (left - 1) / right; - } - - return PyLong_FromLong(div); -} - /* The / and % operators are now defined in terms of divmod(). The expression a mod b has the value a - b*floor(a/b). The long_divrem function gives the remainder after division of @@ -3773,35 +3016,12 @@ l_divmod(PyLongObject *v, PyLongObject *w, { PyLongObject *div, *mod; - if (Py_ABS(Py_SIZE(v)) == 1 && Py_ABS(Py_SIZE(w)) == 1) { - /* Fast path for single-digit longs */ - div = NULL; - if (pdiv != NULL) { - div = (PyLongObject *)fast_floor_div(v, w); - if (div == NULL) { - return -1; - } - } - if (pmod != NULL) { - mod = (PyLongObject *)fast_mod(v, w); - if (mod == NULL) { - Py_XDECREF(div); - return -1; - } - *pmod = mod; - } - if (pdiv != NULL) { - /* We only want to set `*pdiv` when `*pmod` is - set successfully. */ - *pdiv = div; - } - return 0; - } if (long_divrem(v, w, &div, &mod) < 0) return -1; if ((Py_SIZE(mod) < 0 && Py_SIZE(w) > 0) || (Py_SIZE(mod) > 0 && Py_SIZE(w) < 0)) { PyLongObject *temp; + PyLongObject *one; temp = (PyLongObject *) long_add(mod, w); Py_DECREF(mod); mod = temp; @@ -3809,12 +3029,15 @@ l_divmod(PyLongObject *v, PyLongObject *w, Py_DECREF(div); return -1; } - temp = (PyLongObject *) long_sub(div, (PyLongObject *)_PyLong_One); - if (temp == NULL) { + one = (PyLongObject *) PyLong_FromLong(1L); + if (one == NULL || + (temp = (PyLongObject *) long_sub(div, one)) == NULL) { Py_DECREF(mod); Py_DECREF(div); + Py_XDECREF(one); return -1; } + Py_DECREF(one); Py_DECREF(div); div = temp; } @@ -3832,18 +3055,31 @@ l_divmod(PyLongObject *v, PyLongObject *w, } static PyObject * -long_div(PyObject *a, PyObject *b) +long_div(PyObject *v, PyObject *w) { - PyLongObject *div; + PyLongObject *a, *b, *div; - CHECK_BINOP(a, b); + CONVERT_BINOP(v, w, &a, &b); + if (l_divmod(a, b, &div, NULL) < 0) + div = NULL; + Py_DECREF(a); + Py_DECREF(b); + return (PyObject *)div; +} - if (Py_ABS(Py_SIZE(a)) == 1 && Py_ABS(Py_SIZE(b)) == 1) { - return fast_floor_div((PyLongObject*)a, (PyLongObject*)b); - } +static PyObject * +long_classic_div(PyObject *v, PyObject *w) +{ + PyLongObject *a, *b, *div; - if (l_divmod((PyLongObject*)a, (PyLongObject*)b, &div, NULL) < 0) + CONVERT_BINOP(v, w, &a, &b); + if (Py_DivisionWarningFlag && + PyErr_Warn(PyExc_DeprecationWarning, "classic long division") < 0) div = NULL; + else if (l_divmod(a, b, &div, NULL) < 0) + div = NULL; + Py_DECREF(a); + Py_DECREF(b); return (PyObject *)div; } @@ -3861,9 +3097,7 @@ long_true_divide(PyObject *v, PyObject *w) int inexact, negate, a_is_small, b_is_small; double dx, result; - CHECK_BINOP(v, w); - a = (PyLongObject *)v; - b = (PyLongObject *)w; + CONVERT_BINOP(v, w, &a, &b); /* Method in a nutshell: @@ -3953,8 +3187,8 @@ long_true_divide(PyObject *v, PyObject *w) */ /* Reduce to case where a and b are both positive. */ - a_size = Py_ABS(Py_SIZE(a)); - b_size = Py_ABS(Py_SIZE(b)); + a_size = ABS(Py_SIZE(a)); + b_size = ABS(Py_SIZE(b)); negate = (Py_SIZE(a) < 0) ^ (Py_SIZE(b) < 0); if (b_size == 0) { PyErr_SetString(PyExc_ZeroDivisionError, @@ -4004,7 +3238,7 @@ long_true_divide(PyObject *v, PyObject *w) goto underflow_or_zero; /* Choose value for shift; see comments for step 1 above. */ - shift = Py_MAX(diff, DBL_MIN_EXP) - DBL_MANT_DIG - 2; + shift = MAX(diff, DBL_MIN_EXP) - DBL_MANT_DIG - 2; inexact = 0; @@ -4070,12 +3304,12 @@ long_true_divide(PyObject *v, PyObject *w) inexact = 1; Py_DECREF(rem); } - x_size = Py_ABS(Py_SIZE(x)); + x_size = ABS(Py_SIZE(x)); assert(x_size > 0); /* result of division is never zero */ x_bits = (x_size-1)*PyLong_SHIFT+bits_in_digit(x->ob_digit[x_size-1]); /* The number of extra bits that have to be rounded away. */ - extra_bits = Py_MAX(x_bits, DBL_MIN_EXP - shift) - DBL_MANT_DIG; + extra_bits = MAX(x_bits, DBL_MIN_EXP - shift) - DBL_MANT_DIG; assert(extra_bits == 2 || extra_bits == 3); /* Round by directly modifying the low digit of x. */ @@ -4098,149 +3332,65 @@ long_true_divide(PyObject *v, PyObject *w) result = ldexp(dx, (int)shift); success: + Py_DECREF(a); + Py_DECREF(b); return PyFloat_FromDouble(negate ? -result : result); underflow_or_zero: + Py_DECREF(a); + Py_DECREF(b); return PyFloat_FromDouble(negate ? -0.0 : 0.0); overflow: PyErr_SetString(PyExc_OverflowError, "integer division result too large for a float"); error: + Py_DECREF(a); + Py_DECREF(b); return NULL; } static PyObject * -long_mod(PyObject *a, PyObject *b) +long_mod(PyObject *v, PyObject *w) { - PyLongObject *mod; + PyLongObject *a, *b, *mod; - CHECK_BINOP(a, b); + CONVERT_BINOP(v, w, &a, &b); - if (Py_ABS(Py_SIZE(a)) == 1 && Py_ABS(Py_SIZE(b)) == 1) { - return fast_mod((PyLongObject*)a, (PyLongObject*)b); - } - - if (l_divmod((PyLongObject*)a, (PyLongObject*)b, NULL, &mod) < 0) + if (l_divmod(a, b, NULL, &mod) < 0) mod = NULL; + Py_DECREF(a); + Py_DECREF(b); return (PyObject *)mod; } static PyObject * -long_divmod(PyObject *a, PyObject *b) +long_divmod(PyObject *v, PyObject *w) { - PyLongObject *div, *mod; + PyLongObject *a, *b, *div, *mod; PyObject *z; - CHECK_BINOP(a, b); + CONVERT_BINOP(v, w, &a, &b); - if (l_divmod((PyLongObject*)a, (PyLongObject*)b, &div, &mod) < 0) { + if (l_divmod(a, b, &div, &mod) < 0) { + Py_DECREF(a); + Py_DECREF(b); return NULL; } z = PyTuple_New(2); if (z != NULL) { - PyTuple_SET_ITEM(z, 0, (PyObject *) div); - PyTuple_SET_ITEM(z, 1, (PyObject *) mod); + PyTuple_SetItem(z, 0, (PyObject *) div); + PyTuple_SetItem(z, 1, (PyObject *) mod); } else { Py_DECREF(div); Py_DECREF(mod); } - return z; -} - - -/* Compute an inverse to a modulo n, or raise ValueError if a is not - invertible modulo n. Assumes n is positive. The inverse returned - is whatever falls out of the extended Euclidean algorithm: it may - be either positive or negative, but will be smaller than n in - absolute value. - - Pure Python equivalent for long_invmod: - - def invmod(a, n): - b, c = 1, 0 - while n: - q, r = divmod(a, n) - a, b, c, n = n, c, b - q*c, r - - # at this point a is the gcd of the original inputs - if a == 1: - return b - raise ValueError("Not invertible") -*/ - -static PyLongObject * -long_invmod(PyLongObject *a, PyLongObject *n) -{ - PyLongObject *b, *c; - - /* Should only ever be called for positive n */ - assert(Py_SIZE(n) > 0); - - b = (PyLongObject *)PyLong_FromLong(1L); - if (b == NULL) { - return NULL; - } - c = (PyLongObject *)PyLong_FromLong(0L); - if (c == NULL) { - Py_DECREF(b); - return NULL; - } - Py_INCREF(a); - Py_INCREF(n); - - /* references now owned: a, b, c, n */ - while (Py_SIZE(n) != 0) { - PyLongObject *q, *r, *s, *t; - - if (l_divmod(a, n, &q, &r) == -1) { - goto Error; - } - Py_DECREF(a); - a = n; - n = r; - t = (PyLongObject *)long_mul(q, c); - Py_DECREF(q); - if (t == NULL) { - goto Error; - } - s = (PyLongObject *)long_sub(b, t); - Py_DECREF(t); - if (s == NULL) { - goto Error; - } - Py_DECREF(b); - b = c; - c = s; - } - /* references now owned: a, b, c, n */ - - Py_DECREF(c); - Py_DECREF(n); - if (long_compare(a, (PyLongObject *)_PyLong_One)) { - /* a != 1; we don't have an inverse. */ - Py_DECREF(a); - Py_DECREF(b); - PyErr_SetString(PyExc_ValueError, - "base is not invertible for the given modulus"); - return NULL; - } - else { - /* a == 1; b gives an inverse modulo n */ - Py_DECREF(a); - return b; - } - - Error: Py_DECREF(a); Py_DECREF(b); - Py_DECREF(c); - Py_DECREF(n); - return NULL; + return z; } - /* pow(v, w, x) */ static PyObject * long_pow(PyObject *v, PyObject *w, PyObject *x) @@ -4259,29 +3409,39 @@ long_pow(PyObject *v, PyObject *w, PyObject *x) 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; /* a, b, c = v, w, x */ - CHECK_BINOP(v, w); - a = (PyLongObject*)v; Py_INCREF(a); - b = (PyLongObject*)w; Py_INCREF(b); + CONVERT_BINOP(v, w, &a, &b); if (PyLong_Check(x)) { c = (PyLongObject *)x; Py_INCREF(x); } + else if (PyInt_Check(x)) { + c = (PyLongObject *)PyLong_FromLong(PyInt_AS_LONG(x)); + if (c == NULL) + goto Error; + } else if (x == Py_None) c = NULL; else { Py_DECREF(a); Py_DECREF(b); - Py_RETURN_NOTIMPLEMENTED; + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } - if (Py_SIZE(b) < 0 && c == NULL) { - /* if exponent is negative and there's no modulus: - return a float. This works because we know + if (Py_SIZE(b) < 0) { /* if exponent is negative */ + if (c) { + PyErr_SetString(PyExc_TypeError, "pow() 2nd argument " + "cannot be negative when 3rd argument specified"); + goto Error; + } + else { + /* else return a float. This works because we know that this calls float_pow() which converts its arguments to double. */ - Py_DECREF(a); - Py_DECREF(b); - return PyFloat_Type.tp_as_number->nb_power(v, w, x); + Py_DECREF(a); + Py_DECREF(b); + return PyFloat_Type.tp_as_number->nb_power(v, w, x); + } } if (c) { @@ -4304,9 +3464,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x) Py_DECREF(c); c = temp; temp = NULL; - _PyLong_Negate(&c); - if (c == NULL) - goto Error; + Py_SIZE(c) = - Py_SIZE(c); } /* if modulus == 1: @@ -4316,26 +3474,6 @@ long_pow(PyObject *v, PyObject *w, PyObject *x) goto Done; } - /* if exponent is negative, negate the exponent and - replace the base with a modular inverse */ - if (Py_SIZE(b) < 0) { - temp = (PyLongObject *)_PyLong_Copy(b); - if (temp == NULL) - goto Error; - Py_DECREF(b); - b = temp; - temp = NULL; - _PyLong_Negate(&b); - if (b == NULL) - goto Error; - - temp = long_invmod(a, c); - if (temp == NULL) - goto Error; - Py_DECREF(a); - a = temp; - } - /* Reduce base by modulus in some cases: 1. If base < 0. Forcing the base non-negative makes things easier. 2. If base is obviously larger than the modulus. The "small @@ -4432,7 +3570,10 @@ long_pow(PyObject *v, PyObject *w, PyObject *x) goto Done; Error: - Py_CLEAR(z); + if (z != NULL) { + Py_DECREF(z); + z = NULL; + } /* fall through */ Done: if (Py_SIZE(b) > FIVEARY_CUTOFF) { @@ -4451,14 +3592,15 @@ long_invert(PyLongObject *v) { /* Implement ~x as -(x+1) */ PyLongObject *x; - if (Py_ABS(Py_SIZE(v)) <=1) - return PyLong_FromLong(-(MEDIUM_VALUE(v)+1)); - x = (PyLongObject *) long_add(v, (PyLongObject *)_PyLong_One); + PyLongObject *w; + w = (PyLongObject *)PyLong_FromLong(1L); + if (w == NULL) + return NULL; + x = (PyLongObject *) long_add(v, w); + Py_DECREF(w); if (x == NULL) return NULL; - _PyLong_Negate(&x); - /* No need for maybe_small_long here, since any small - longs will have been caught in the Py_SIZE <= 1 fast path. */ + Py_SIZE(x) = -(Py_SIZE(x)); return (PyObject *)x; } @@ -4466,8 +3608,11 @@ static PyObject * long_neg(PyLongObject *v) { PyLongObject *z; - if (Py_ABS(Py_SIZE(v)) <= 1) - return PyLong_FromLong(-MEDIUM_VALUE(v)); + if (Py_SIZE(v) == 0 && PyLong_CheckExact(v)) { + /* -0 == 0 */ + Py_INCREF(v); + return (PyObject *) v; + } z = (PyLongObject *)_PyLong_Copy(v); if (z != NULL) Py_SIZE(z) = -(Py_SIZE(v)); @@ -4484,139 +3629,111 @@ long_abs(PyLongObject *v) } static int -long_bool(PyLongObject *v) +long_nonzero(PyLongObject *v) { return Py_SIZE(v) != 0; } -/* wordshift, remshift = divmod(shiftby, PyLong_SHIFT) */ -static int -divmod_shift(PyObject *shiftby, Py_ssize_t *wordshift, digit *remshift) -{ - assert(PyLong_Check(shiftby)); - assert(Py_SIZE(shiftby) >= 0); - Py_ssize_t lshiftby = PyLong_AsSsize_t((PyObject *)shiftby); - if (lshiftby >= 0) { - *wordshift = lshiftby / PyLong_SHIFT; - *remshift = lshiftby % PyLong_SHIFT; - return 0; - } - /* PyLong_Check(shiftby) is true and Py_SIZE(shiftby) >= 0, so it must - be that PyLong_AsSsize_t raised an OverflowError. */ - assert(PyErr_ExceptionMatches(PyExc_OverflowError)); - PyErr_Clear(); - PyLongObject *wordshift_obj = divrem1((PyLongObject *)shiftby, PyLong_SHIFT, remshift); - if (wordshift_obj == NULL) { - return -1; - } - *wordshift = PyLong_AsSsize_t((PyObject *)wordshift_obj); - Py_DECREF(wordshift_obj); - if (*wordshift >= 0 && *wordshift < PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(digit)) { - return 0; - } - PyErr_Clear(); - /* Clip the value. With such large wordshift the right shift - returns 0 and the left shift raises an error in _PyLong_New(). */ - *wordshift = PY_SSIZE_T_MAX / sizeof(digit); - *remshift = 0; - return 0; -} - static PyObject * -long_rshift1(PyLongObject *a, Py_ssize_t wordshift, digit remshift) +long_rshift(PyLongObject *v, PyLongObject *w) { + PyLongObject *a, *b; PyLongObject *z = NULL; - Py_ssize_t newsize, hishift, i, j; + Py_ssize_t shiftby, newsize, wordshift, loshift, hishift, i, j; digit lomask, himask; + CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); + if (Py_SIZE(a) < 0) { /* Right shifting negative numbers is harder */ PyLongObject *a1, *a2; a1 = (PyLongObject *) long_invert(a); if (a1 == NULL) - return NULL; - a2 = (PyLongObject *) long_rshift1(a1, wordshift, remshift); + goto rshift_error; + a2 = (PyLongObject *) long_rshift(a1, b); Py_DECREF(a1); if (a2 == NULL) - return NULL; + goto rshift_error; z = (PyLongObject *) long_invert(a2); Py_DECREF(a2); } else { - newsize = Py_SIZE(a) - wordshift; - if (newsize <= 0) - return PyLong_FromLong(0); - hishift = PyLong_SHIFT - remshift; + shiftby = PyLong_AsSsize_t((PyObject *)b); + if (shiftby == -1L && PyErr_Occurred()) + goto rshift_error; + if (shiftby < 0) { + PyErr_SetString(PyExc_ValueError, + "negative shift count"); + goto rshift_error; + } + wordshift = shiftby / PyLong_SHIFT; + newsize = ABS(Py_SIZE(a)) - wordshift; + if (newsize <= 0) { + z = _PyLong_New(0); + Py_DECREF(a); + Py_DECREF(b); + return (PyObject *)z; + } + loshift = shiftby % PyLong_SHIFT; + hishift = PyLong_SHIFT - loshift; lomask = ((digit)1 << hishift) - 1; himask = PyLong_MASK ^ lomask; z = _PyLong_New(newsize); if (z == NULL) - return NULL; + goto rshift_error; + if (Py_SIZE(a) < 0) + Py_SIZE(z) = -(Py_SIZE(z)); for (i = 0, j = wordshift; i < newsize; i++, j++) { - z->ob_digit[i] = (a->ob_digit[j] >> remshift) & lomask; + z->ob_digit[i] = (a->ob_digit[j] >> loshift) & lomask; if (i+1 < newsize) z->ob_digit[i] |= (a->ob_digit[j+1] << hishift) & himask; } - z = maybe_small_long(long_normalize(z)); + z = long_normalize(z); } - return (PyObject *)z; + rshift_error: + Py_DECREF(a); + Py_DECREF(b); + return (PyObject *) z; + } static PyObject * -long_rshift(PyObject *a, PyObject *b) +long_lshift(PyObject *v, PyObject *w) { - Py_ssize_t wordshift; - digit remshift; + /* This version due to Tim Peters */ + PyLongObject *a, *b; + PyLongObject *z = NULL; + Py_ssize_t shiftby, oldsize, newsize, wordshift, remshift, i, j; + twodigits accum; - CHECK_BINOP(a, b); + CONVERT_BINOP(v, w, &a, &b); - if (Py_SIZE(b) < 0) { + shiftby = PyLong_AsSsize_t((PyObject *)b); + if (shiftby == -1L && PyErr_Occurred()) + goto out; + if (shiftby < 0) { PyErr_SetString(PyExc_ValueError, "negative shift count"); - return NULL; + goto out; } - if (Py_SIZE(a) == 0) { - return PyLong_FromLong(0); - } - if (divmod_shift(b, &wordshift, &remshift) < 0) - return NULL; - return long_rshift1((PyLongObject *)a, wordshift, remshift); -} -/* Return a >> shiftby. */ -PyObject * -_PyLong_Rshift(PyObject *a, size_t shiftby) -{ - Py_ssize_t wordshift; - digit remshift; - - assert(PyLong_Check(a)); if (Py_SIZE(a) == 0) { - return PyLong_FromLong(0); + z = (PyLongObject *)PyLong_FromLong(0); + goto out; } - wordshift = shiftby / PyLong_SHIFT; - remshift = shiftby % PyLong_SHIFT; - return long_rshift1((PyLongObject *)a, wordshift, remshift); -} -static PyObject * -long_lshift1(PyLongObject *a, Py_ssize_t wordshift, digit remshift) -{ - /* This version due to Tim Peters */ - PyLongObject *z = NULL; - Py_ssize_t oldsize, newsize, i, j; - twodigits accum; + /* wordshift, remshift = divmod(shiftby, PyLong_SHIFT) */ + wordshift = shiftby / PyLong_SHIFT; + remshift = shiftby - wordshift * PyLong_SHIFT; - oldsize = Py_ABS(Py_SIZE(a)); + oldsize = ABS(Py_SIZE(a)); newsize = oldsize + wordshift; if (remshift) ++newsize; z = _PyLong_New(newsize); if (z == NULL) - return NULL; - if (Py_SIZE(a) < 0) { - assert(Py_REFCNT(z) == 1); - Py_SIZE(z) = -Py_SIZE(z); - } + goto out; + if (Py_SIZE(a) < 0) + Py_SIZE(z) = -(Py_SIZE(z)); for (i = 0; i < wordshift; i++) z->ob_digit[i] = 0; accum = 0; @@ -4630,43 +3747,10 @@ long_lshift1(PyLongObject *a, Py_ssize_t wordshift, digit remshift) else assert(!accum); z = long_normalize(z); - return (PyObject *) maybe_small_long(z); -} - -static PyObject * -long_lshift(PyObject *a, PyObject *b) -{ - Py_ssize_t wordshift; - digit remshift; - - CHECK_BINOP(a, b); - - if (Py_SIZE(b) < 0) { - PyErr_SetString(PyExc_ValueError, "negative shift count"); - return NULL; - } - if (Py_SIZE(a) == 0) { - return PyLong_FromLong(0); - } - if (divmod_shift(b, &wordshift, &remshift) < 0) - return NULL; - return long_lshift1((PyLongObject *)a, wordshift, remshift); -} - -/* Return a << shiftby. */ -PyObject * -_PyLong_Lshift(PyObject *a, size_t shiftby) -{ - Py_ssize_t wordshift; - digit remshift; - - assert(PyLong_Check(a)); - if (Py_SIZE(a) == 0) { - return PyLong_FromLong(0); - } - wordshift = shiftby / PyLong_SHIFT; - remshift = shiftby % PyLong_SHIFT; - return long_lshift1((PyLongObject *)a, wordshift, remshift); + out: + Py_DECREF(a); + Py_DECREF(b); + return (PyObject *) z; } /* Compute two's complement of digit vector a[0:m], writing result to @@ -4690,7 +3774,7 @@ v_complement(digit *z, digit *a, Py_ssize_t m) static PyObject * long_bitwise(PyLongObject *a, - char op, /* '&', '|', '^' */ + int op, /* '&', '|', '^' */ PyLongObject *b) { int nega, negb, negz; @@ -4703,7 +3787,7 @@ long_bitwise(PyLongObject *a, result back to sign-magnitude at the end. */ /* If a is negative, replace it by its two's complement. */ - size_a = Py_ABS(Py_SIZE(a)); + size_a = ABS(Py_SIZE(a)); nega = Py_SIZE(a) < 0; if (nega) { z = _PyLong_New(size_a); @@ -4717,7 +3801,7 @@ long_bitwise(PyLongObject *a, Py_INCREF(a); /* Same for b. */ - size_b = Py_ABS(Py_SIZE(b)); + size_b = ABS(Py_SIZE(b)); negb = Py_SIZE(b) < 0; if (negb) { z = _PyLong_New(size_b); @@ -4759,7 +3843,8 @@ long_bitwise(PyLongObject *a, size_z = negb ? size_b : size_a; break; default: - Py_UNREACHABLE(); + PyErr_BadArgument(); + return NULL; } /* We allow an extra digit if z is negative, to make sure that @@ -4786,7 +3871,8 @@ long_bitwise(PyLongObject *a, z->ob_digit[i] = a->ob_digit[i] ^ b->ob_digit[i]; break; default: - Py_UNREACHABLE(); + PyErr_BadArgument(); + return NULL; } /* Copy any remaining digits of a, inverting if necessary. */ @@ -4806,36 +3892,63 @@ long_bitwise(PyLongObject *a, Py_DECREF(a); Py_DECREF(b); - return (PyObject *)maybe_small_long(long_normalize(z)); + return (PyObject *)long_normalize(z); } static PyObject * -long_and(PyObject *a, PyObject *b) +long_and(PyObject *v, PyObject *w) { + PyLongObject *a, *b; PyObject *c; - CHECK_BINOP(a, b); - c = long_bitwise((PyLongObject*)a, '&', (PyLongObject*)b); + CONVERT_BINOP(v, w, &a, &b); + c = long_bitwise(a, '&', b); + Py_DECREF(a); + Py_DECREF(b); return c; } static PyObject * -long_xor(PyObject *a, PyObject *b) +long_xor(PyObject *v, PyObject *w) { + PyLongObject *a, *b; PyObject *c; - CHECK_BINOP(a, b); - c = long_bitwise((PyLongObject*)a, '^', (PyLongObject*)b); + CONVERT_BINOP(v, w, &a, &b); + c = long_bitwise(a, '^', b); + Py_DECREF(a); + Py_DECREF(b); return c; } static PyObject * -long_or(PyObject *a, PyObject *b) +long_or(PyObject *v, PyObject *w) { + PyLongObject *a, *b; PyObject *c; - CHECK_BINOP(a, b); - c = long_bitwise((PyLongObject*)a, '|', (PyLongObject*)b); + CONVERT_BINOP(v, w, &a, &b); + c = long_bitwise(a, '|', b); + Py_DECREF(a); + Py_DECREF(b); return c; } +static int +long_coerce(PyObject **pv, PyObject **pw) +{ + if (PyInt_Check(*pw)) { + *pw = PyLong_FromLong(PyInt_AS_LONG(*pw)); + if (*pw == NULL) + return -1; + Py_INCREF(*pv); + return 0; + } + else if (PyLong_Check(*pw)) { + Py_INCREF(*pv); + Py_INCREF(*pw); + return 0; + } + return 1; /* Can't do it */ +} + static PyObject * long_long(PyObject *v) { @@ -4846,211 +3959,25 @@ long_long(PyObject *v) return v; } -PyObject * -_PyLong_GCD(PyObject *aarg, PyObject *barg) +static PyObject * +long_int(PyObject *v) { - PyLongObject *a, *b, *c = NULL, *d = NULL, *r; - stwodigits x, y, q, s, t, c_carry, d_carry; - stwodigits A, B, C, D, T; - int nbits, k; - Py_ssize_t size_a, size_b, alloc_a, alloc_b; - digit *a_digit, *b_digit, *c_digit, *d_digit, *a_end, *b_end; - - a = (PyLongObject *)aarg; - b = (PyLongObject *)barg; - size_a = Py_SIZE(a); - size_b = Py_SIZE(b); - if (-2 <= size_a && size_a <= 2 && -2 <= size_b && size_b <= 2) { - Py_INCREF(a); - Py_INCREF(b); - goto simple; - } - - /* Initial reduction: make sure that 0 <= b <= a. */ - a = (PyLongObject *)long_abs(a); - if (a == NULL) - return NULL; - b = (PyLongObject *)long_abs(b); - if (b == NULL) { - Py_DECREF(a); - return NULL; - } - if (long_compare(a, b) < 0) { - r = a; - a = b; - b = r; - } - /* We now own references to a and b */ - - alloc_a = Py_SIZE(a); - alloc_b = Py_SIZE(b); - /* reduce until a fits into 2 digits */ - while ((size_a = Py_SIZE(a)) > 2) { - nbits = bits_in_digit(a->ob_digit[size_a-1]); - /* extract top 2*PyLong_SHIFT bits of a into x, along with - corresponding bits of b into y */ - size_b = Py_SIZE(b); - assert(size_b <= size_a); - if (size_b == 0) { - if (size_a < alloc_a) { - r = (PyLongObject *)_PyLong_Copy(a); - Py_DECREF(a); + long x; + x = PyLong_AsLong(v); + if (PyErr_Occurred()) { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) { + PyErr_Clear(); + if (PyLong_CheckExact(v)) { + Py_INCREF(v); + return v; } else - r = a; - Py_DECREF(b); - Py_XDECREF(c); - Py_XDECREF(d); - return (PyObject *)r; - } - x = (((twodigits)a->ob_digit[size_a-1] << (2*PyLong_SHIFT-nbits)) | - ((twodigits)a->ob_digit[size_a-2] << (PyLong_SHIFT-nbits)) | - (a->ob_digit[size_a-3] >> nbits)); - - y = ((size_b >= size_a - 2 ? b->ob_digit[size_a-3] >> nbits : 0) | - (size_b >= size_a - 1 ? (twodigits)b->ob_digit[size_a-2] << (PyLong_SHIFT-nbits) : 0) | - (size_b >= size_a ? (twodigits)b->ob_digit[size_a-1] << (2*PyLong_SHIFT-nbits) : 0)); - - /* inner loop of Lehmer's algorithm; A, B, C, D never grow - larger than PyLong_MASK during the algorithm. */ - A = 1; B = 0; C = 0; D = 1; - for (k=0;; k++) { - if (y-C == 0) - break; - q = (x+(A-1))/(y-C); - s = B+q*D; - t = x-q*y; - if (s > t) - break; - x = y; y = t; - t = A+q*C; A = D; B = C; C = s; D = t; - } - - if (k == 0) { - /* no progress; do a Euclidean step */ - if (l_divmod(a, b, NULL, &r) < 0) - goto error; - Py_DECREF(a); - a = b; - b = r; - alloc_a = alloc_b; - alloc_b = Py_SIZE(b); - continue; - } - - /* - a, b = A*b-B*a, D*a-C*b if k is odd - a, b = A*a-B*b, D*b-C*a if k is even - */ - if (k&1) { - T = -A; A = -B; B = T; - T = -C; C = -D; D = T; - } - if (c != NULL) - Py_SIZE(c) = size_a; - else if (Py_REFCNT(a) == 1) { - Py_INCREF(a); - c = a; - } - else { - alloc_a = size_a; - c = _PyLong_New(size_a); - if (c == NULL) - goto error; - } - - if (d != NULL) - Py_SIZE(d) = size_a; - else if (Py_REFCNT(b) == 1 && size_a <= alloc_b) { - Py_INCREF(b); - d = b; - Py_SIZE(d) = size_a; + return _PyLong_Copy((PyLongObject *)v); } - else { - alloc_b = size_a; - d = _PyLong_New(size_a); - if (d == NULL) - goto error; - } - a_end = a->ob_digit + size_a; - b_end = b->ob_digit + size_b; - - /* compute new a and new b in parallel */ - a_digit = a->ob_digit; - b_digit = b->ob_digit; - c_digit = c->ob_digit; - d_digit = d->ob_digit; - c_carry = 0; - d_carry = 0; - while (b_digit < b_end) { - c_carry += (A * *a_digit) - (B * *b_digit); - d_carry += (D * *b_digit++) - (C * *a_digit++); - *c_digit++ = (digit)(c_carry & PyLong_MASK); - *d_digit++ = (digit)(d_carry & PyLong_MASK); - c_carry >>= PyLong_SHIFT; - d_carry >>= PyLong_SHIFT; - } - while (a_digit < a_end) { - c_carry += A * *a_digit; - d_carry -= C * *a_digit++; - *c_digit++ = (digit)(c_carry & PyLong_MASK); - *d_digit++ = (digit)(d_carry & PyLong_MASK); - c_carry >>= PyLong_SHIFT; - d_carry >>= PyLong_SHIFT; - } - assert(c_carry == 0); - assert(d_carry == 0); - - Py_INCREF(c); - Py_INCREF(d); - Py_DECREF(a); - Py_DECREF(b); - a = long_normalize(c); - b = long_normalize(d); - } - Py_XDECREF(c); - Py_XDECREF(d); - -simple: - assert(Py_REFCNT(a) > 0); - assert(Py_REFCNT(b) > 0); -/* Issue #24999: use two shifts instead of ">> 2*PyLong_SHIFT" to avoid - undefined behaviour when LONG_MAX type is smaller than 60 bits */ -#if LONG_MAX >> PyLong_SHIFT >> PyLong_SHIFT - /* a fits into a long, so b must too */ - x = PyLong_AsLong((PyObject *)a); - y = PyLong_AsLong((PyObject *)b); -#elif LLONG_MAX >> PyLong_SHIFT >> PyLong_SHIFT - x = PyLong_AsLongLong((PyObject *)a); - y = PyLong_AsLongLong((PyObject *)b); -#else -# error "_PyLong_GCD" -#endif - x = Py_ABS(x); - y = Py_ABS(y); - Py_DECREF(a); - Py_DECREF(b); - - /* usual Euclidean algorithm for longs */ - while (y != 0) { - t = y; - y = x % y; - x = t; + else + return NULL; } -#if LONG_MAX >> PyLong_SHIFT >> PyLong_SHIFT - return PyLong_FromLong(x); -#elif LLONG_MAX >> PyLong_SHIFT >> PyLong_SHIFT - return PyLong_FromLongLong(x); -#else -# error "_PyLong_GCD" -#endif - -error: - Py_DECREF(a); - Py_DECREF(b); - Py_XDECREF(c); - Py_XDECREF(d); - return NULL; + return PyInt_FromLong(x); } static PyObject * @@ -5064,74 +3991,87 @@ long_float(PyObject *v) } static PyObject * -long_subtype_new(PyTypeObject *type, PyObject *x, PyObject *obase); +long_oct(PyObject *v) +{ + return _PyLong_Format(v, 8, 1, 0); +} -/*[clinic input] -@classmethod -int.__new__ as long_new - x: object(c_default="NULL") = 0 - / - base as obase: object(c_default="NULL") = 10 -[clinic start generated code]*/ +static PyObject * +long_hex(PyObject *v) +{ + return _PyLong_Format(v, 16, 1, 0); +} + +static PyObject * +long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds); static PyObject * -long_new_impl(PyTypeObject *type, PyObject *x, PyObject *obase) -/*[clinic end generated code: output=e47cfe777ab0f24c input=81c98f418af9eb6f]*/ +long_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - Py_ssize_t base; + PyObject *x = NULL; + int base = -909; /* unlikely! */ + static char *kwlist[] = {"x", "base", 0}; if (type != &PyLong_Type) - return long_subtype_new(type, x, obase); /* Wimp out */ + return long_subtype_new(type, args, kwds); /* Wimp out */ + if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:long", kwlist, + &x, &base)) + return NULL; if (x == NULL) { - if (obase != NULL) { + if (base != -909) { PyErr_SetString(PyExc_TypeError, - "int() missing string argument"); + "long() missing string argument"); return NULL; } return PyLong_FromLong(0L); } - if (obase == NULL) + if (base == -909) return PyNumber_Long(x); - - base = PyNumber_AsSsize_t(obase, NULL); - if (base == -1 && PyErr_Occurred()) - return NULL; - if ((base != 0 && base < 2) || base > 36) { - PyErr_SetString(PyExc_ValueError, - "int() base must be >= 2 and <= 36, or 0"); - return NULL; - } - - if (PyUnicode_Check(x)) - return PyLong_FromUnicodeObject(x, (int)base); - else if (PyByteArray_Check(x) || PyBytes_Check(x)) { - char *string; - if (PyByteArray_Check(x)) - string = PyByteArray_AS_STRING(x); - else - string = PyBytes_AS_STRING(x); - return _PyLong_FromBytes(string, Py_SIZE(x), (int)base); + else if (PyString_Check(x)) { + /* Since PyLong_FromString doesn't have a length parameter, + * check here for possible NULs in the string. */ + char *string = PyString_AS_STRING(x); + if (strlen(string) != (size_t)PyString_Size(x)) { + /* create a repr() of the input string, + * just like PyLong_FromString does. */ + PyObject *srepr; + srepr = PyObject_Repr(x); + if (srepr == NULL) + return NULL; + PyErr_Format(PyExc_ValueError, + "invalid literal for long() with base %d: %s", + base, PyString_AS_STRING(srepr)); + Py_DECREF(srepr); + return NULL; + } + return PyLong_FromString(PyString_AS_STRING(x), NULL, base); } +#ifdef Py_USING_UNICODE + else if (PyUnicode_Check(x)) + return PyLong_FromUnicode(PyUnicode_AS_UNICODE(x), + PyUnicode_GET_SIZE(x), + base); +#endif else { PyErr_SetString(PyExc_TypeError, - "int() can't convert non-string with explicit base"); + "long() can't convert non-string with explicit base"); return NULL; } } -/* Wimpy, slow approach to tp_new calls for subtypes of int: - first create a regular int from whatever arguments we got, +/* Wimpy, slow approach to tp_new calls for subtypes of long: + first create a regular long from whatever arguments we got, then allocate a subtype instance and initialize it from - the regular int. The regular int is then thrown away. + the regular long. The regular long is then thrown away. */ static PyObject * -long_subtype_new(PyTypeObject *type, PyObject *x, PyObject *obase) +long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyLongObject *tmp, *newobj; Py_ssize_t i, n; assert(PyType_IsSubtype(type, &PyLong_Type)); - tmp = (PyLongObject *)long_new_impl(&PyLong_Type, x, obase); + tmp = (PyLongObject *)long_new(&PyLong_Type, args, kwds); if (tmp == NULL) return NULL; assert(PyLong_Check(tmp)); @@ -5151,263 +4091,84 @@ long_subtype_new(PyTypeObject *type, PyObject *x, PyObject *obase) return (PyObject *)newobj; } -/*[clinic input] -int.__getnewargs__ -[clinic start generated code]*/ - static PyObject * -int___getnewargs___impl(PyObject *self) -/*[clinic end generated code: output=839a49de3f00b61b input=5904770ab1fb8c75]*/ +long_getnewargs(PyLongObject *v) { - return Py_BuildValue("(N)", _PyLong_Copy((PyLongObject *)self)); + return Py_BuildValue("(N)", _PyLong_Copy(v)); } static PyObject * -long_get0(PyObject *Py_UNUSED(self), void *Py_UNUSED(context)) -{ +long_get0(PyLongObject *v, void *context) { return PyLong_FromLong(0L); } static PyObject * -long_get1(PyObject *Py_UNUSED(self), void *Py_UNUSED(ignored)) -{ +long_get1(PyLongObject *v, void *context) { return PyLong_FromLong(1L); } -/*[clinic input] -int.__format__ - - format_spec: unicode - / -[clinic start generated code]*/ - static PyObject * -int___format___impl(PyObject *self, PyObject *format_spec) -/*[clinic end generated code: output=b4929dee9ae18689 input=e31944a9b3e428b7]*/ -{ - _PyUnicodeWriter writer; - int ret; - - _PyUnicodeWriter_Init(&writer); - ret = _PyLong_FormatAdvancedWriter( - &writer, - self, - format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); - if (ret == -1) { - _PyUnicodeWriter_Dealloc(&writer); - return NULL; - } - return _PyUnicodeWriter_Finish(&writer); -} - -/* Return a pair (q, r) such that a = b * q + r, and - abs(r) <= abs(b)/2, with equality possible only if q is even. - In other words, q == a / b, rounded to the nearest integer using - round-half-to-even. */ - -PyObject * -_PyLong_DivmodNear(PyObject *a, PyObject *b) +long__format__(PyObject *self, PyObject *args) { - PyLongObject *quo = NULL, *rem = NULL; - PyObject *twice_rem, *result, *temp; - int quo_is_odd, quo_is_neg; - Py_ssize_t cmp; - - /* Equivalent Python code: - - def divmod_near(a, b): - q, r = divmod(a, b) - # round up if either r / b > 0.5, or r / b == 0.5 and q is odd. - # The expression r / b > 0.5 is equivalent to 2 * r > b if b is - # positive, 2 * r < b if b negative. - greater_than_half = 2*r > b if b > 0 else 2*r < b - exactly_half = 2*r == b - if greater_than_half or exactly_half and q % 2 == 1: - q += 1 - r -= b - return q, r + PyObject *format_spec; - */ - if (!PyLong_Check(a) || !PyLong_Check(b)) { - PyErr_SetString(PyExc_TypeError, - "non-integer arguments in division"); + if (!PyArg_ParseTuple(args, "O:__format__", &format_spec)) return NULL; - } - - /* Do a and b have different signs? If so, quotient is negative. */ - quo_is_neg = (Py_SIZE(a) < 0) != (Py_SIZE(b) < 0); - - if (long_divrem((PyLongObject*)a, (PyLongObject*)b, &quo, &rem) < 0) - goto error; + if (PyBytes_Check(format_spec)) + return _PyLong_FormatAdvanced(self, + PyBytes_AS_STRING(format_spec), + PyBytes_GET_SIZE(format_spec)); + if (PyUnicode_Check(format_spec)) { + /* Convert format_spec to a str */ + PyObject *result; + PyObject *str_spec = PyObject_Str(format_spec); + + if (str_spec == NULL) + return NULL; - /* compare twice the remainder with the divisor, to see - if we need to adjust the quotient and remainder */ - twice_rem = long_lshift((PyObject *)rem, _PyLong_One); - if (twice_rem == NULL) - goto error; - if (quo_is_neg) { - temp = long_neg((PyLongObject*)twice_rem); - Py_DECREF(twice_rem); - twice_rem = temp; - if (twice_rem == NULL) - goto error; - } - cmp = long_compare((PyLongObject *)twice_rem, (PyLongObject *)b); - Py_DECREF(twice_rem); + result = _PyLong_FormatAdvanced(self, + PyBytes_AS_STRING(str_spec), + PyBytes_GET_SIZE(str_spec)); - quo_is_odd = Py_SIZE(quo) != 0 && ((quo->ob_digit[0] & 1) != 0); - if ((Py_SIZE(b) < 0 ? cmp < 0 : cmp > 0) || (cmp == 0 && quo_is_odd)) { - /* fix up quotient */ - if (quo_is_neg) - temp = long_sub(quo, (PyLongObject *)_PyLong_One); - else - temp = long_add(quo, (PyLongObject *)_PyLong_One); - Py_DECREF(quo); - quo = (PyLongObject *)temp; - if (quo == NULL) - goto error; - /* and remainder */ - if (quo_is_neg) - temp = long_add(rem, (PyLongObject *)b); - else - temp = long_sub(rem, (PyLongObject *)b); - Py_DECREF(rem); - rem = (PyLongObject *)temp; - if (rem == NULL) - goto error; + Py_DECREF(str_spec); + return result; } - - result = PyTuple_New(2); - if (result == NULL) - goto error; - - /* PyTuple_SET_ITEM steals references */ - PyTuple_SET_ITEM(result, 0, (PyObject *)quo); - PyTuple_SET_ITEM(result, 1, (PyObject *)rem); - return result; - - error: - Py_XDECREF(quo); - Py_XDECREF(rem); + PyErr_SetString(PyExc_TypeError, "__format__ requires str or unicode"); return NULL; } static PyObject * -long_round(PyObject *self, PyObject *args) -{ - PyObject *o_ndigits=NULL, *temp, *result, *ndigits; - - /* To round an integer m to the nearest 10**n (n positive), we make use of - * the divmod_near operation, defined by: - * - * divmod_near(a, b) = (q, r) - * - * where q is the nearest integer to the quotient a / b (the - * nearest even integer in the case of a tie) and r == a - q * b. - * Hence q * b = a - r is the nearest multiple of b to a, - * preferring even multiples in the case of a tie. - * - * So the nearest multiple of 10**n to m is: - * - * m - divmod_near(m, 10**n)[1]. - */ - if (!PyArg_ParseTuple(args, "|O", &o_ndigits)) - return NULL; - if (o_ndigits == NULL) - return long_long(self); - - ndigits = PyNumber_Index(o_ndigits); - if (ndigits == NULL) - return NULL; - - /* if ndigits >= 0 then no rounding is necessary; return self unchanged */ - if (Py_SIZE(ndigits) >= 0) { - Py_DECREF(ndigits); - return long_long(self); - } - - /* result = self - divmod_near(self, 10 ** -ndigits)[1] */ - temp = long_neg((PyLongObject*)ndigits); - Py_DECREF(ndigits); - ndigits = temp; - if (ndigits == NULL) - return NULL; - - result = PyLong_FromLong(10L); - if (result == NULL) { - Py_DECREF(ndigits); - return NULL; - } - - temp = long_pow(result, ndigits, Py_None); - Py_DECREF(ndigits); - Py_DECREF(result); - result = temp; - if (result == NULL) - return NULL; - - temp = _PyLong_DivmodNear(self, result); - Py_DECREF(result); - result = temp; - if (result == NULL) - return NULL; - - temp = long_sub((PyLongObject *)self, - (PyLongObject *)PyTuple_GET_ITEM(result, 1)); - Py_DECREF(result); - result = temp; - - return result; -} - -/*[clinic input] -int.__sizeof__ -> Py_ssize_t - -Returns size in memory, in bytes. -[clinic start generated code]*/ - -static Py_ssize_t -int___sizeof___impl(PyObject *self) -/*[clinic end generated code: output=3303f008eaa6a0a5 input=9b51620c76fc4507]*/ +long_sizeof(PyLongObject *v) { Py_ssize_t res; - res = offsetof(PyLongObject, ob_digit) + Py_ABS(Py_SIZE(self))*sizeof(digit); - return res; + res = Py_TYPE(v)->tp_basicsize + ABS(Py_SIZE(v))*sizeof(digit); + return PyInt_FromSsize_t(res); } -/*[clinic input] -int.bit_length - -Number of bits necessary to represent self in binary. - ->>> bin(37) -'0b100101' ->>> (37).bit_length() -6 -[clinic start generated code]*/ - static PyObject * -int_bit_length_impl(PyObject *self) -/*[clinic end generated code: output=fc1977c9353d6a59 input=e4eb7a587e849a32]*/ +long_bit_length(PyLongObject *v) { PyLongObject *result, *x, *y; - Py_ssize_t ndigits; - int msd_bits; + Py_ssize_t ndigits, msd_bits = 0; digit msd; - assert(self != NULL); - assert(PyLong_Check(self)); + assert(v != NULL); + assert(PyLong_Check(v)); - ndigits = Py_ABS(Py_SIZE(self)); + ndigits = ABS(Py_SIZE(v)); if (ndigits == 0) - return PyLong_FromLong(0); + return PyInt_FromLong(0); - msd = ((PyLongObject *)self)->ob_digit[ndigits-1]; - msd_bits = bits_in_digit(msd); + msd = v->ob_digit[ndigits-1]; + while (msd >= 32) { + msd_bits += 6; + msd >>= 6; + } + msd_bits += (long)(BitLengthTable[msd]); if (ndigits <= PY_SSIZE_T_MAX/PyLong_SHIFT) - return PyLong_FromSsize_t((ndigits-1)*PyLong_SHIFT + msd_bits); + return PyInt_FromSsize_t((ndigits-1)*PyLong_SHIFT + msd_bits); /* expression above may overflow; use Python integers instead */ result = (PyLongObject *)PyLong_FromSsize_t(ndigits - 1); @@ -5440,6 +4201,15 @@ int_bit_length_impl(PyObject *self) return NULL; } +PyDoc_STRVAR(long_bit_length_doc, +"long.bit_length() -> int or long\n\ +\n\ +Number of bits necessary to represent self in binary.\n\ +>>> bin(37L)\n\ +'0b100101'\n\ +>>> (37L).bit_length()\n\ +6"); + #if 0 static PyObject * long_is_finite(PyObject *v) @@ -5448,242 +4218,87 @@ long_is_finite(PyObject *v) } #endif -/*[clinic input] -int.as_integer_ratio - -Return integer ratio. - -Return a pair of integers, whose ratio is exactly equal to the original int -and with a positive denominator. - ->>> (10).as_integer_ratio() -(10, 1) ->>> (-10).as_integer_ratio() -(-10, 1) ->>> (0).as_integer_ratio() -(0, 1) -[clinic start generated code]*/ - -static PyObject * -int_as_integer_ratio_impl(PyObject *self) -/*[clinic end generated code: output=e60803ae1cc8621a input=55ce3058e15de393]*/ -{ - PyObject *ratio_tuple; - PyObject *numerator = long_long(self); - if (numerator == NULL) { - return NULL; - } - ratio_tuple = PyTuple_Pack(2, numerator, _PyLong_One); - Py_DECREF(numerator); - return ratio_tuple; -} - -/*[clinic input] -int.to_bytes - - length: Py_ssize_t - Length of bytes object to use. An OverflowError is raised if the - integer is not representable with the given number of bytes. - byteorder: unicode - The byte order used to represent the integer. If byteorder is 'big', - the most significant byte is at the beginning of the byte array. If - byteorder is 'little', the most significant byte is at the end of the - byte array. To request the native byte order of the host system, use - `sys.byteorder' as the byte order value. - * - signed as is_signed: bool = False - Determines whether two's complement is used to represent the integer. - If signed is False and a negative integer is given, an OverflowError - is raised. - -Return an array of bytes representing an integer. -[clinic start generated code]*/ - -static PyObject * -int_to_bytes_impl(PyObject *self, Py_ssize_t length, PyObject *byteorder, - int is_signed) -/*[clinic end generated code: output=89c801df114050a3 input=ddac63f4c7bf414c]*/ -{ - int little_endian; - PyObject *bytes; - - if (_PyUnicode_EqualToASCIIId(byteorder, &PyId_little)) - little_endian = 1; - else if (_PyUnicode_EqualToASCIIId(byteorder, &PyId_big)) - little_endian = 0; - else { - PyErr_SetString(PyExc_ValueError, - "byteorder must be either 'little' or 'big'"); - return NULL; - } - - if (length < 0) { - PyErr_SetString(PyExc_ValueError, - "length argument must be non-negative"); - return NULL; - } - - bytes = PyBytes_FromStringAndSize(NULL, length); - if (bytes == NULL) - return NULL; - - if (_PyLong_AsByteArray((PyLongObject *)self, - (unsigned char *)PyBytes_AS_STRING(bytes), - length, little_endian, is_signed) < 0) { - Py_DECREF(bytes); - return NULL; - } - - return bytes; -} - -/*[clinic input] -@classmethod -int.from_bytes - - bytes as bytes_obj: object - Holds the array of bytes to convert. The argument must either - support the buffer protocol or be an iterable object producing bytes. - Bytes and bytearray are examples of built-in objects that support the - buffer protocol. - byteorder: unicode - The byte order used to represent the integer. If byteorder is 'big', - the most significant byte is at the beginning of the byte array. If - byteorder is 'little', the most significant byte is at the end of the - byte array. To request the native byte order of the host system, use - `sys.byteorder' as the byte order value. - * - signed as is_signed: bool = False - Indicates whether two's complement is used to represent the integer. - -Return the integer represented by the given array of bytes. -[clinic start generated code]*/ - -static PyObject * -int_from_bytes_impl(PyTypeObject *type, PyObject *bytes_obj, - PyObject *byteorder, int is_signed) -/*[clinic end generated code: output=efc5d68e31f9314f input=cdf98332b6a821b0]*/ -{ - int little_endian; - PyObject *long_obj, *bytes; - - if (_PyUnicode_EqualToASCIIId(byteorder, &PyId_little)) - little_endian = 1; - else if (_PyUnicode_EqualToASCIIId(byteorder, &PyId_big)) - little_endian = 0; - else { - PyErr_SetString(PyExc_ValueError, - "byteorder must be either 'little' or 'big'"); - return NULL; - } - - bytes = PyObject_Bytes(bytes_obj); - if (bytes == NULL) - return NULL; - - long_obj = _PyLong_FromByteArray( - (unsigned char *)PyBytes_AS_STRING(bytes), Py_SIZE(bytes), - little_endian, is_signed); - Py_DECREF(bytes); - - if (long_obj != NULL && type != &PyLong_Type) { - Py_SETREF(long_obj, _PyObject_CallOneArg((PyObject *)type, long_obj)); - } - - return long_obj; -} - -static PyObject * -long_long_meth(PyObject *self, PyObject *Py_UNUSED(ignored)) -{ - return long_long(self); -} - static PyMethodDef long_methods[] = { - {"conjugate", long_long_meth, METH_NOARGS, - "Returns self, the complex conjugate of any int."}, - INT_BIT_LENGTH_METHODDEF + {"conjugate", (PyCFunction)long_long, METH_NOARGS, + "Returns self, the complex conjugate of any long."}, + {"bit_length", (PyCFunction)long_bit_length, METH_NOARGS, + long_bit_length_doc}, #if 0 {"is_finite", (PyCFunction)long_is_finite, METH_NOARGS, "Returns always True."}, #endif - INT_TO_BYTES_METHODDEF - INT_FROM_BYTES_METHODDEF - INT_AS_INTEGER_RATIO_METHODDEF - {"__trunc__", long_long_meth, METH_NOARGS, + {"__trunc__", (PyCFunction)long_long, METH_NOARGS, "Truncating an Integral returns itself."}, - {"__floor__", long_long_meth, METH_NOARGS, - "Flooring an Integral returns itself."}, - {"__ceil__", long_long_meth, METH_NOARGS, - "Ceiling of an Integral returns itself."}, - {"__round__", (PyCFunction)long_round, METH_VARARGS, - "Rounding an Integral returns itself.\n" - "Rounding with an ndigits argument also returns an integer."}, - INT___GETNEWARGS___METHODDEF - INT___FORMAT___METHODDEF - INT___SIZEOF___METHODDEF + {"__getnewargs__", (PyCFunction)long_getnewargs, METH_NOARGS}, + {"__format__", (PyCFunction)long__format__, METH_VARARGS}, + {"__sizeof__", (PyCFunction)long_sizeof, METH_NOARGS, + "Returns size in memory, in bytes"}, {NULL, NULL} /* sentinel */ }; static PyGetSetDef long_getset[] = { {"real", - (getter)long_long_meth, (setter)NULL, + (getter)long_long, (setter)NULL, "the real part of a complex number", NULL}, {"imag", - long_get0, (setter)NULL, + (getter)long_get0, (setter)NULL, "the imaginary part of a complex number", NULL}, {"numerator", - (getter)long_long_meth, (setter)NULL, + (getter)long_long, (setter)NULL, "the numerator of a rational number in lowest terms", NULL}, {"denominator", - long_get1, (setter)NULL, + (getter)long_get1, (setter)NULL, "the denominator of a rational number in lowest terms", NULL}, {NULL} /* Sentinel */ }; PyDoc_STRVAR(long_doc, -"int([x]) -> integer\n\ -int(x, base=10) -> integer\n\ +"long(x=0) -> long\n\ +long(x, base=10) -> long\n\ \n\ -Convert a number or string to an integer, or return 0 if no arguments\n\ -are given. If x is a number, return x.__int__(). For floating point\n\ -numbers, this truncates towards zero.\n\ +Convert a number or string to a long integer, or return 0L if no arguments\n\ +are given. If x is floating point, the conversion truncates towards zero.\n\ \n\ -If x is not a number or if base is given, then x must be a string,\n\ -bytes, or bytearray instance representing an integer literal in the\n\ -given base. The literal can be preceded by '+' or '-' and be surrounded\n\ -by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.\n\ -Base 0 means to interpret the base from the string as an integer literal.\n\ +If x is not a number or if base is given, then x must be a string or\n\ +Unicode object representing an integer literal in the given base. The\n\ +literal can be preceded by '+' or '-' and be surrounded by whitespace.\n\ +The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to\n\ +interpret the base from the string as an integer literal.\n\ >>> int('0b100', base=0)\n\ -4"); +4L"); static PyNumberMethods long_as_number = { (binaryfunc)long_add, /*nb_add*/ (binaryfunc)long_sub, /*nb_subtract*/ (binaryfunc)long_mul, /*nb_multiply*/ + long_classic_div, /*nb_divide*/ long_mod, /*nb_remainder*/ long_divmod, /*nb_divmod*/ long_pow, /*nb_power*/ (unaryfunc)long_neg, /*nb_negative*/ - long_long, /*tp_positive*/ + (unaryfunc)long_long, /*tp_positive*/ (unaryfunc)long_abs, /*tp_absolute*/ - (inquiry)long_bool, /*tp_bool*/ + (inquiry)long_nonzero, /*tp_nonzero*/ (unaryfunc)long_invert, /*nb_invert*/ long_lshift, /*nb_lshift*/ - long_rshift, /*nb_rshift*/ + (binaryfunc)long_rshift, /*nb_rshift*/ long_and, /*nb_and*/ long_xor, /*nb_xor*/ long_or, /*nb_or*/ - long_long, /*nb_int*/ - 0, /*nb_reserved*/ + long_coerce, /*nb_coerce*/ + long_int, /*nb_int*/ + long_long, /*nb_long*/ long_float, /*nb_float*/ + long_oct, /*nb_oct*/ + long_hex, /*nb_hex*/ 0, /* nb_inplace_add */ 0, /* nb_inplace_subtract */ 0, /* nb_inplace_multiply */ + 0, /* nb_inplace_divide */ 0, /* nb_inplace_remainder */ 0, /* nb_inplace_power */ 0, /* nb_inplace_lshift */ @@ -5700,30 +4315,30 @@ static PyNumberMethods long_as_number = { PyTypeObject PyLong_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) - "int", /* tp_name */ + "long", /* tp_name */ offsetof(PyLongObject, ob_digit), /* tp_basicsize */ sizeof(digit), /* tp_itemsize */ - 0, /* tp_dealloc */ - 0, /* tp_vectorcall_offset */ + long_dealloc, /* tp_dealloc */ + 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ - 0, /* tp_as_async */ - long_to_decimal_string, /* tp_repr */ + (cmpfunc)long_compare, /* tp_compare */ + long_repr, /* tp_repr */ &long_as_number, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ (hashfunc)long_hash, /* tp_hash */ 0, /* tp_call */ - 0, /* tp_str */ + long_str, /* tp_str */ PyObject_GenericGetAttr, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | - Py_TPFLAGS_LONG_SUBCLASS, /* tp_flags */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES | + Py_TPFLAGS_BASETYPE | Py_TPFLAGS_LONG_SUBCLASS, /* tp_flags */ long_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ - long_richcompare, /* tp_richcompare */ + 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ @@ -5741,93 +4356,51 @@ PyTypeObject PyLong_Type = { PyObject_Del, /* tp_free */ }; -static PyTypeObject Int_InfoType; +static PyTypeObject Long_InfoType; -PyDoc_STRVAR(int_info__doc__, -"sys.int_info\n\ +PyDoc_STRVAR(long_info__doc__, +"sys.long_info\n\ \n\ -A named tuple that holds information about Python's\n\ +A struct sequence that holds information about Python's\n\ internal representation of integers. The attributes are read only."); -static PyStructSequence_Field int_info_fields[] = { +static PyStructSequence_Field long_info_fields[] = { {"bits_per_digit", "size of a digit in bits"}, {"sizeof_digit", "size in bytes of the C type used to represent a digit"}, {NULL, NULL} }; -static PyStructSequence_Desc int_info_desc = { - "sys.int_info", /* name */ - int_info__doc__, /* doc */ - int_info_fields, /* fields */ - 2 /* number of fields */ +static PyStructSequence_Desc long_info_desc = { + "sys.long_info", /* name */ + long_info__doc__, /* doc */ + long_info_fields, /* fields */ + 2 /* number of fields */ }; PyObject * PyLong_GetInfo(void) { - PyObject* int_info; + PyObject* long_info; int field = 0; - int_info = PyStructSequence_New(&Int_InfoType); - if (int_info == NULL) + long_info = PyStructSequence_New(&Long_InfoType); + if (long_info == NULL) return NULL; - PyStructSequence_SET_ITEM(int_info, field++, - PyLong_FromLong(PyLong_SHIFT)); - PyStructSequence_SET_ITEM(int_info, field++, - PyLong_FromLong(sizeof(digit))); + PyStructSequence_SET_ITEM(long_info, field++, + PyInt_FromLong(PyLong_SHIFT)); + PyStructSequence_SET_ITEM(long_info, field++, + PyInt_FromLong(sizeof(digit))); if (PyErr_Occurred()) { - Py_CLEAR(int_info); + Py_CLEAR(long_info); return NULL; } - return int_info; + return long_info; } int _PyLong_Init(void) { -#if NSMALLNEGINTS + NSMALLPOSINTS > 0 - for (Py_ssize_t i=0; i < NSMALLNEGINTS + NSMALLPOSINTS; i++) { - sdigit ival = (sdigit)i - NSMALLNEGINTS; - int size = (ival < 0) ? -1 : ((ival == 0) ? 0 : 1); - - PyLongObject *v = _PyLong_New(1); - if (!v) { - return -1; - } - - Py_SIZE(v) = size; - v->ob_digit[0] = (digit)abs(ival); - - small_ints[i] = v; - } -#endif - _PyLong_Zero = PyLong_FromLong(0); - if (_PyLong_Zero == NULL) { - return 0; - } - - _PyLong_One = PyLong_FromLong(1); - if (_PyLong_One == NULL) { - return 0; - } - - /* initialize int_info */ - if (Int_InfoType.tp_name == NULL) { - if (PyStructSequence_InitType2(&Int_InfoType, &int_info_desc) < 0) { - return 0; - } - } - + /* initialize long_info */ + if (Long_InfoType.tp_name == 0) + PyStructSequence_InitType(&Long_InfoType, &long_info_desc); return 1; } - -void -_PyLong_Fini(void) -{ - Py_CLEAR(_PyLong_One); - Py_CLEAR(_PyLong_Zero); -#if NSMALLNEGINTS + NSMALLPOSINTS > 0 - for (Py_ssize_t i = 0; i < NSMALLNEGINTS + NSMALLPOSINTS; i++) { - Py_CLEAR(small_ints[i]); - } -#endif -} |