1d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel/** @file 2d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel Long (arbitrary precision) integer object implementation. 3d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel 4d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel Copyright (c) 2015, Daryl McDaniel. All rights reserved.<BR> 5d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel This program and the accompanying materials are licensed and made available under 6d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel the terms and conditions of the BSD License that accompanies this distribution. 7d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel The full text of the license may be found at 8d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel http://opensource.org/licenses/bsd-license. 9d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel 10d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel**/ 133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* XXX The functional organization of this file is terrible */ 153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#include "Python.h" 173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#include "longintrepr.h" 183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#include "structseq.h" 193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#include <float.h> 213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#include <ctype.h> 223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#include <stddef.h> 233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* For long multiplication, use the O(N**2) school algorithm unless 253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * both operands contain more than KARATSUBA_CUTOFF digits (this 263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * being an internal Python long digit, in base PyLong_BASE). 273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define KARATSUBA_CUTOFF 70 293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define KARATSUBA_SQUARE_CUTOFF (2 * KARATSUBA_CUTOFF) 303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* For exponentiation, use the binary left-to-right algorithm 323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * unless the exponent contains more than FIVEARY_CUTOFF digits. 333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * In that case, do 5 bits at a time. The potential drawback is that 343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * a table of 2**5 intermediate results is computed. 353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define FIVEARY_CUTOFF 8 373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 38d11973f1cae1d8e25017b09734fbf419342b192aDaryl McDaniel#undef ABS 393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define ABS(x) ((x) < 0 ? -(x) : (x)) 403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#undef MIN 423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#undef MAX 433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define MAX(x, y) ((x) < (y) ? (y) : (x)) 443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define MIN(x, y) ((x) > (y) ? (y) : (x)) 453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define SIGCHECK(PyTryBlock) \ 473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do { \ 483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (--_Py_Ticker < 0) { \ 493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel _Py_Ticker = _Py_CheckInterval; \ 503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyErr_CheckSignals()) PyTryBlock \ 513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } \ 523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } while(0) 533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Normalize (remove leading zeros from) a long int object. 553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Doesn't attempt to free the storage--in most cases, due to the nature 563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel of the algorithms used, this could save at most be one word anyway. */ 573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyLongObject * 593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_normalize(register PyLongObject *v) 603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t j = ABS(Py_SIZE(v)); 623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i = j; 633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (i > 0 && v->ob_digit[i-1] == 0) 653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel --i; 663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i != j) 673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(v) = (Py_SIZE(v) < 0) ? -(i) : i; 683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return v; 693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Allocate a new long int object with size digits. 723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Return NULL and set exception if we run out of memory. */ 733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define MAX_LONG_DIGITS \ 753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ((PY_SSIZE_T_MAX - offsetof(PyLongObject, ob_digit))/sizeof(digit)) 763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLongObject * 783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel_PyLong_New(Py_ssize_t size) 793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (size > (Py_ssize_t)MAX_LONG_DIGITS) { 813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "too many digits in integer"); 833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* coverity[ampersand_in_size] */ 863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* XXX(nnorwitz): PyObject_NEW_VAR / _PyObject_VAR_SIZE need to detect 873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel overflow */ 883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size); 893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel_PyLong_Copy(PyLongObject *src) 933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *result; 953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(src != NULL); 983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = src->ob_size; 993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i < 0) 1003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = -(i); 1013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = _PyLong_New(i); 1023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (result != NULL) { 1033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result->ob_size = src->ob_size; 1043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--i >= 0) 1053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result->ob_digit[i] = src->ob_digit[i]; 1063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 1073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)result; 1083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 1093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Create a new long int object from a C long int */ 1113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 1133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_FromLong(long ival) 1143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 1153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *v; 1163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned long abs_ival; 1173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned long t; /* unsigned so >> doesn't propagate sign bit */ 1183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int ndigits = 0; 1193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int negative = 0; 1203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (ival < 0) { 1223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* if LONG_MIN == -LONG_MAX-1 (true on most platforms) then 1233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ANSI C says that the result of -ival is undefined when ival 1243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel == LONG_MIN. Hence the following workaround. */ 1253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel abs_ival = (unsigned long)(-1-ival) + 1; 1263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negative = 1; 1273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 1283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 1293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel abs_ival = (unsigned long)ival; 1303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 1313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Count the number of Python digits. 1333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel We used to pick 5 ("big enough for anything"), but that's a 1343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel waste of time and space given that 5*15 = 75 bits are rarely 1353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel needed. */ 1363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t = abs_ival; 1373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (t) { 1383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++ndigits; 1393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t >>= PyLong_SHIFT; 1403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 1413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = _PyLong_New(ndigits); 1423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (v != NULL) { 1433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *p = v->ob_digit; 1443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v->ob_size = negative ? -ndigits : ndigits; 1453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t = abs_ival; 1463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (t) { 1473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *p++ = (digit)(t & PyLong_MASK); 1483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t >>= PyLong_SHIFT; 1493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 1503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 1513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)v; 1523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 1533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Create a new long int object from a C unsigned long int */ 1553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 1573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_FromUnsignedLong(unsigned long ival) 1583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 1593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *v; 1603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned long t; 1613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int ndigits = 0; 1623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Count the number of Python digits. */ 1643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t = (unsigned long)ival; 1653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (t) { 1663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++ndigits; 1673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t >>= PyLong_SHIFT; 1683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 1693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = _PyLong_New(ndigits); 1703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (v != NULL) { 1713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *p = v->ob_digit; 1723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(v) = ndigits; 1733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (ival) { 1743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *p++ = (digit)(ival & PyLong_MASK); 1753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ival >>= PyLong_SHIFT; 1763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 1773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 1783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)v; 1793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 1803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Create a new long int object from a C double */ 1823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 1843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_FromDouble(double dval) 1853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 1863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *v; 1873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel double frac; 1883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int i, ndig, expo, neg; 1893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel neg = 0; 1903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_IS_INFINITY(dval)) { 1913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 1923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "cannot convert float infinity to integer"); 1933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 1943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 1953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_IS_NAN(dval)) { 1963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_ValueError, 1973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "cannot convert float NaN to integer"); 1983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 1993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 2003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (dval < 0.0) { 2013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel neg = 1; 2023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel dval = -dval; 2033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 2043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel frac = frexp(dval, &expo); /* dval = frac*2**expo; 0.0 <= frac < 1.0 */ 2053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (expo <= 0) 2063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyLong_FromLong(0L); 2073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ndig = (expo-1) / PyLong_SHIFT + 1; /* Number of 'digits' in result */ 2083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = _PyLong_New(ndig); 2093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (v == NULL) 2103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 2113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel frac = ldexp(frac, (expo-1) % PyLong_SHIFT + 1); 2123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = ndig; --i >= 0; ) { 2133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit bits = (digit)frac; 2143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v->ob_digit[i] = bits; 2153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel frac = frac - (double)bits; 2163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel frac = ldexp(frac, PyLong_SHIFT); 2173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 2183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (neg) 2193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(v) = -(Py_SIZE(v)); 2203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)v; 2213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 2223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Checking for overflow in PyLong_AsLong is a PITA since C doesn't define 2243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * anything about what happens when a signed integer operation overflows, 2253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * and some compilers think they're doing you a favor by being "clever" 2263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * then. The bit pattern for the largest postive signed long is 2273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * (unsigned long)LONG_MAX, and for the smallest negative signed long 2283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * it is abs(LONG_MIN), which we could write -(unsigned long)LONG_MIN. 2293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * However, some other compilers warn about applying unary minus to an 2303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * unsigned operand. Hence the weird "0-". 2313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 2323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define PY_ABS_LONG_MIN (0-(unsigned long)LONG_MIN) 2333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define PY_ABS_SSIZE_T_MIN (0-(size_t)PY_SSIZE_T_MIN) 2343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a C long int from a Python long or Python int object. 2363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel On overflow, returns -1 and sets *overflow to 1 or -1 depending 2373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel on the sign of the result. Otherwise *overflow is 0. 2383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel For other errors (e.g., type error), returns -1 and sets an error 2403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel condition. 2413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel*/ 2423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong 2443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_AsLongAndOverflow(PyObject *vv, int *overflow) 2453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 2463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* This version by Tim Peters */ 2473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel register PyLongObject *v; 2483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned long x, prev; 2493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long res; 2503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 2513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int sign; 2523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int do_decref = 0; /* if nb_int was called */ 2533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *overflow = 0; 2553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv == NULL) { 2563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadInternalCall(); 2573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 2583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 2593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if(PyInt_Check(vv)) 2613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyInt_AsLong(vv); 2623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (!PyLong_Check(vv)) { 2643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyNumberMethods *nb; 2653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel nb = vv->ob_type->tp_as_number; 2663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (nb == NULL || nb->nb_int == NULL) { 2673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_TypeError, 2683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "an integer is required"); 2693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 2703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 2713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel vv = (*nb->nb_int) (vv); 2723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv == NULL) 2733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 2743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do_decref = 1; 2753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if(PyInt_Check(vv)) { 2763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = PyInt_AsLong(vv); 2773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto exit; 2783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 2793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (!PyLong_Check(vv)) { 2803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(vv); 2813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_TypeError, 2823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "nb_int should return int object"); 2833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 2843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 2853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 2863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = -1; 2883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = (PyLongObject *)vv; 2893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = Py_SIZE(v); 2903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel switch (i) { 2923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case -1: 2933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = -(sdigit)v->ob_digit[0]; 2943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 2953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case 0: 2963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = 0; 2973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 2983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case 1: 2993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = v->ob_digit[0]; 3003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 3013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel default: 3023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = 1; 3033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = 0; 3043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i < 0) { 3053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = -1; 3063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = -(i); 3073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--i >= 0) { 3093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel prev = x; 3103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = (x << PyLong_SHIFT) + v->ob_digit[i]; 3113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((x >> PyLong_SHIFT) != prev) { 3123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *overflow = sign; 3133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto exit; 3143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Haven't lost any bits, but casting to long requires extra 3173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * care (see comment above). 3183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 3193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x <= (unsigned long)LONG_MAX) { 3203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = (long)x * sign; 3213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (sign < 0 && x == PY_ABS_LONG_MIN) { 3233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = LONG_MIN; 3243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 3263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *overflow = sign; 3273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* res is already set to -1 */ 3283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel exit: 3313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (do_decref) { 3323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(vv); 3333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return res; 3353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 3363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 3373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a C long int from a long int object. 3383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Returns -1 and sets an error condition if overflow occurs. */ 3393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 3403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong 3413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_AsLong(PyObject *obj) 3423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 3433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int overflow; 3443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long result = PyLong_AsLongAndOverflow(obj, &overflow); 3453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (overflow) { 3463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* XXX: could be cute and give a different 3473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel message for overflow == -1 */ 3483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 3493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "Python int too large to convert to C long"); 3503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return result; 3523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 3533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 3543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a C int from a long int object or any object that has an __int__ 3553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel method. Return -1 and set an error if overflow occurs. */ 3563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 3573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielint 3583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel_PyLong_AsInt(PyObject *obj) 3593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 3603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int overflow; 3613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long result = PyLong_AsLongAndOverflow(obj, &overflow); 3623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (overflow || result > INT_MAX || result < INT_MIN) { 3633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* XXX: could be cute and give a different 3643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel message for overflow == -1 */ 3653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 3663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "Python int too large to convert to C int"); 3673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 3683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (int)result; 3703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 3713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 3723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a Py_ssize_t from a long int object. 3733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Returns -1 and sets an error condition if overflow occurs. */ 3743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 3753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPy_ssize_t 3763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_AsSsize_t(PyObject *vv) { 3773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel register PyLongObject *v; 3783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_t x, prev; 3793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 3803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int sign; 3813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 3823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv == NULL || !PyLong_Check(vv)) { 3833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadInternalCall(); 3843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 3853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = (PyLongObject *)vv; 3873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = v->ob_size; 3883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = 1; 3893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = 0; 3903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i < 0) { 3913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = -1; 3923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = -(i); 3933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 3943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--i >= 0) { 3953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel prev = x; 3963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = (x << PyLong_SHIFT) | v->ob_digit[i]; 3973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((x >> PyLong_SHIFT) != prev) 3983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto overflow; 3993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Haven't lost any bits, but casting to a signed type requires 4013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * extra care (see comment above). 4023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 4033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x <= (size_t)PY_SSIZE_T_MAX) { 4043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (Py_ssize_t)x * sign; 4053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (sign < 0 && x == PY_ABS_SSIZE_T_MIN) { 4073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PY_SSIZE_T_MIN; 4083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* else overflow */ 4103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 4113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel overflow: 4123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 4133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "long int too large to convert to int"); 4143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 4153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 4163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 4173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a C unsigned long int from a long int object. 4183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Returns -1 and sets an error condition if overflow occurs. */ 4193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 4203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielunsigned long 4213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_AsUnsignedLong(PyObject *vv) 4223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 4233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel register PyLongObject *v; 4243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned long x, prev; 4253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 4263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 4273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv == NULL || !PyLong_Check(vv)) { 4283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv != NULL && PyInt_Check(vv)) { 4293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long val = PyInt_AsLong(vv); 4303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (val < 0) { 4313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 4323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "can't convert negative value " 4333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "to unsigned long"); 4343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (unsigned long) -1; 4353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return val; 4373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadInternalCall(); 4393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (unsigned long) -1; 4403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = (PyLongObject *)vv; 4423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = Py_SIZE(v); 4433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = 0; 4443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i < 0) { 4453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 4463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "can't convert negative value to unsigned long"); 4473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (unsigned long) -1; 4483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--i >= 0) { 4503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel prev = x; 4513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = (x << PyLong_SHIFT) | v->ob_digit[i]; 4523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((x >> PyLong_SHIFT) != prev) { 4533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 4543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "long int too large to convert"); 4553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (unsigned long) -1; 4563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return x; 4593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 4603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 4613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a C unsigned long int from a long int object, ignoring the high bits. 4623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Returns -1 and sets an error condition if an error occurs. */ 4633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 4643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielunsigned long 4653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_AsUnsignedLongMask(PyObject *vv) 4663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 4673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel register PyLongObject *v; 4683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned long x; 4693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 4703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int sign; 4713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 4723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv == NULL || !PyLong_Check(vv)) { 4733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv != NULL && PyInt_Check(vv)) 4743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyInt_AsUnsignedLongMask(vv); 4753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadInternalCall(); 4763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (unsigned long) -1; 4773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = (PyLongObject *)vv; 4793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = v->ob_size; 4803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = 1; 4813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = 0; 4823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i < 0) { 4833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = -1; 4843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = -i; 4853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--i >= 0) { 4873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = (x << PyLong_SHIFT) | v->ob_digit[i]; 4883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 4893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return x * sign; 4903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 4913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 4923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielint 4933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel_PyLong_Sign(PyObject *vv) 4943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 4953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *v = (PyLongObject *)vv; 4963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 4973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(v != NULL); 4983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(PyLong_Check(v)); 4993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return Py_SIZE(v) == 0 ? 0 : (Py_SIZE(v) < 0 ? -1 : 1); 5013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 5023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielsize_t 5043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel_PyLong_NumBits(PyObject *vv) 5053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 5063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *v = (PyLongObject *)vv; 5073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_t result = 0; 5083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t ndigits; 5093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(v != NULL); 5113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(PyLong_Check(v)); 5123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ndigits = ABS(Py_SIZE(v)); 5133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0); 5143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (ndigits > 0) { 5153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit msd = v->ob_digit[ndigits - 1]; 5163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = (ndigits - 1) * PyLong_SHIFT; 5183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (result / PyLong_SHIFT != (size_t)(ndigits - 1)) 5193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Overflow; 5203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do { 5213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++result; 5223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (result == 0) 5233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Overflow; 5243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel msd >>= 1; 5253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } while (msd); 5263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 5273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return result; 5283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Overflow: 5303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, "long has too many bits " 5313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "to express in a platform size_t"); 5323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (size_t)-1; 5333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 5343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 5363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel_PyLong_FromByteArray(const unsigned char* bytes, size_t n, 5373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int little_endian, int is_signed) 5383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 5393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const unsigned char* pstartbyte; /* LSB of bytes */ 5403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int incr; /* direction to move pstartbyte */ 5413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const unsigned char* pendbyte; /* MSB of bytes */ 5423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_t numsignificantbytes; /* number of bytes that matter */ 5433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t ndigits; /* number of Python long digits */ 5443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject* v; /* result */ 5453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t idigit = 0; /* next free index in v->ob_digit */ 5463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (n == 0) 5483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyLong_FromLong(0L); 5493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (little_endian) { 5513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pstartbyte = bytes; 5523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pendbyte = bytes + n - 1; 5533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel incr = 1; 5543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 5553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 5563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pstartbyte = bytes + n - 1; 5573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pendbyte = bytes; 5583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel incr = -1; 5593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 5603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (is_signed) 5623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel is_signed = *pendbyte >= 0x80; 5633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Compute numsignificantbytes. This consists of finding the most 5653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel significant byte. Leading 0 bytes are insignificant if the number 5663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel is positive, and leading 0xff bytes if negative. */ 5673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel { 5683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_t i; 5693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const unsigned char* p = pendbyte; 5703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const int pincr = -incr; /* search MSB to LSB */ 5713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const unsigned char insignficant = is_signed ? 0xff : 0x00; 5723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < n; ++i, p += pincr) { 5743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (*p != insignficant) 5753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 5763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 5773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel numsignificantbytes = n - i; 5783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* 2's-comp is a bit tricky here, e.g. 0xff00 == -0x0100, so 5793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel actually has 2 significant bytes. OTOH, 0xff0001 == 5803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel -0x00ffff, so we wouldn't *need* to bump it there; but we 5813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do for 0xffff = -0x0001. To be safe without bothering to 5823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel check every case, bump it regardless. */ 5833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (is_signed && numsignificantbytes < n) 5843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++numsignificantbytes; 5853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 5863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* How many Python long digits do we need? We have 5883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8*numsignificantbytes bits, and each Python long digit has 5893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLong_SHIFT bits, so it's the ceiling of the quotient. */ 5903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* catch overflow before it happens */ 5913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (numsignificantbytes > (PY_SSIZE_T_MAX - PyLong_SHIFT) / 8) { 5923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 5933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "byte array too long to convert to int"); 5943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 5953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 5963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ndigits = (numsignificantbytes * 8 + PyLong_SHIFT - 1) / PyLong_SHIFT; 5973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = _PyLong_New(ndigits); 5983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (v == NULL) 5993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 6003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 6013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Copy the bits over. The tricky parts are computing 2's-comp on 6023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel the fly for signed numbers, and dealing with the mismatch between 6033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8-bit bytes and (probably) 15-bit Python digits.*/ 6043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel { 6053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_t i; 6063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits carry = 1; /* for 2's-comp calculation */ 6073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits accum = 0; /* sliding register */ 6083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned int accumbits = 0; /* number of bits in accum */ 6093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const unsigned char* p = pstartbyte; 6103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 6113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < numsignificantbytes; ++i, p += incr) { 6123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits thisbyte = *p; 6133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Compute correction for 2's comp, if needed. */ 6143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (is_signed) { 6153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel thisbyte = (0xff ^ thisbyte) + carry; 6163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry = thisbyte >> 8; 6173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel thisbyte &= 0xff; 6183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 6193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Because we're going LSB to MSB, thisbyte is 6203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel more significant than what's already in accum, 6213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel so needs to be prepended to accum. */ 6223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum |= (twodigits)thisbyte << accumbits; 6233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accumbits += 8; 6243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (accumbits >= PyLong_SHIFT) { 6253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* There's enough to fill a Python digit. */ 6263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(idigit < ndigits); 6273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v->ob_digit[idigit] = (digit)(accum & PyLong_MASK); 6283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++idigit; 6293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum >>= PyLong_SHIFT; 6303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accumbits -= PyLong_SHIFT; 6313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(accumbits < PyLong_SHIFT); 6323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 6333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 6343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(accumbits < PyLong_SHIFT); 6353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (accumbits) { 6363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(idigit < ndigits); 6373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v->ob_digit[idigit] = (digit)accum; 6383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++idigit; 6393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 6403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 6413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 6423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(v) = is_signed ? -idigit : idigit; 6433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)long_normalize(v); 6443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 6453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 6463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielint 6473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel_PyLong_AsByteArray(PyLongObject* v, 6483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned char* bytes, size_t n, 6493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int little_endian, int is_signed) 6503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 6513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; /* index into v->ob_digit */ 6523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t ndigits; /* |v->ob_size| */ 6533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits accum; /* sliding register */ 6543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned int accumbits; /* # bits in accum */ 6553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int do_twos_comp; /* store 2's-comp? is_signed and v < 0 */ 6563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit carry; /* for computing 2's-comp */ 6573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_t j; /* # bytes filled */ 6583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned char* p; /* pointer to next byte in bytes */ 6593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int pincr; /* direction to move p */ 6603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 6613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(v != NULL && PyLong_Check(v)); 6623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 6633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(v) < 0) { 6643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ndigits = -(Py_SIZE(v)); 6653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (!is_signed) { 6663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 6673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "can't convert negative long to unsigned"); 6683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 6693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 6703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do_twos_comp = 1; 6713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 6723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 6733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ndigits = Py_SIZE(v); 6743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do_twos_comp = 0; 6753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 6763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 6773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (little_endian) { 6783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel p = bytes; 6793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pincr = 1; 6803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 6813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 6823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel p = bytes + n - 1; 6833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pincr = -1; 6843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 6853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 6863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Copy over all the Python digits. 6873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel It's crucial that every Python digit except for the MSD contribute 6883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel exactly PyLong_SHIFT bits to the total, so first assert that the long is 6893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel normalized. */ 6903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0); 6913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel j = 0; 6923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum = 0; 6933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accumbits = 0; 6943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry = do_twos_comp ? 1 : 0; 6953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < ndigits; ++i) { 6963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit thisdigit = v->ob_digit[i]; 6973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (do_twos_comp) { 6983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel thisdigit = (thisdigit ^ PyLong_MASK) + carry; 6993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry = thisdigit >> PyLong_SHIFT; 7003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel thisdigit &= PyLong_MASK; 7013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 7023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Because we're going LSB to MSB, thisdigit is more 7033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel significant than what's already in accum, so needs to be 7043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel prepended to accum. */ 7053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum |= (twodigits)thisdigit << accumbits; 7063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 7073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* The most-significant digit may be (probably is) at least 7083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel partly empty. */ 7093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i == ndigits - 1) { 7103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Count # of sign bits -- they needn't be stored, 7113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * although for signed conversion we need later to 7123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * make sure at least one sign bit gets stored. */ 7133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit s = do_twos_comp ? thisdigit ^ PyLong_MASK : thisdigit; 7143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (s != 0) { 7153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel s >>= 1; 7163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accumbits++; 7173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 7183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 7193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 7203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accumbits += PyLong_SHIFT; 7213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 7223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Store as many bytes as possible. */ 7233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (accumbits >= 8) { 7243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (j >= n) 7253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Overflow; 7263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++j; 7273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *p = (unsigned char)(accum & 0xff); 7283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel p += pincr; 7293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accumbits -= 8; 7303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum >>= 8; 7313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 7323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 7333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 7343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Store the straggler (if any). */ 7353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(accumbits < 8); 7363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(carry == 0); /* else do_twos_comp and *every* digit was 0 */ 7373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (accumbits > 0) { 7383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (j >= n) 7393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Overflow; 7403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++j; 7413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (do_twos_comp) { 7423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Fill leading bits of the byte with sign bits 7433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (appropriately pretending that the long had an 7443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel infinite supply of sign bits). */ 7453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum |= (~(twodigits)0) << accumbits; 7463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 7473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *p = (unsigned char)(accum & 0xff); 7483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel p += pincr; 7493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 7503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (j == n && n > 0 && is_signed) { 7513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* The main loop filled the byte array exactly, so the code 7523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel just above didn't get to ensure there's a sign bit, and the 7533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel loop below wouldn't add one either. Make sure a sign bit 7543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel exists. */ 7553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned char msb = *(p - pincr); 7563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int sign_bit_set = msb >= 0x80; 7573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(accumbits == 0); 7583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (sign_bit_set == do_twos_comp) 7593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0; 7603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 7613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Overflow; 7623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 7633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 7643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Fill remaining bytes with copies of the sign bit. */ 7653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel { 7663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned char signbyte = do_twos_comp ? 0xffU : 0U; 7673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for ( ; j < n; ++j, p += pincr) 7683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *p = signbyte; 7693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 7703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 7713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0; 7723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 7733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Overflow: 7743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, "long too big to convert"); 7753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 7763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 7773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 7783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 7793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Create a new long (or int) object from a C pointer */ 7803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 7813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 7823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_FromVoidPtr(void *p) 7833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 7843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#if SIZEOF_VOID_P <= SIZEOF_LONG 7853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((long)p < 0) 7863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyLong_FromUnsignedLong((unsigned long)p); 7873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyInt_FromLong((long)p); 7883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#else 7893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 7903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#ifndef HAVE_LONG_LONG 7913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel# error "PyLong_FromVoidPtr: sizeof(void*) > sizeof(long), but no long long" 7923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif 7933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#if SIZEOF_LONG_LONG < SIZEOF_VOID_P 7943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel# error "PyLong_FromVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)" 7953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif 7963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* optimize null pointers */ 7973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (p == NULL) 7983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyInt_FromLong(0); 7993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)p); 8003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */ 8023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 8033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a C pointer from a long object (or an int object in some cases) */ 8053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielvoid * 8073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_AsVoidPtr(PyObject *vv) 8083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 8093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* This function will allow int or long objects. If vv is neither, 8103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel then the PyLong_AsLong*() functions will raise the exception: 8113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyExc_SystemError, "bad argument to internal function" 8123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 8133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#if SIZEOF_VOID_P <= SIZEOF_LONG 8143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long x; 8153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyInt_Check(vv)) 8173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = PyInt_AS_LONG(vv); 8183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0) 8193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = PyLong_AsLong(vv); 8203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 8213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = PyLong_AsUnsignedLong(vv); 8223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#else 8233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#ifndef HAVE_LONG_LONG 8253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel# error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long" 8263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif 8273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#if SIZEOF_LONG_LONG < SIZEOF_VOID_P 8283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel# error "PyLong_AsVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)" 8293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif 8303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PY_LONG_LONG x; 8313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyInt_Check(vv)) 8333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = PyInt_AS_LONG(vv); 8343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0) 8353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = PyLong_AsLongLong(vv); 8363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 8373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = PyLong_AsUnsignedLongLong(vv); 8383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */ 8403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x == -1 && PyErr_Occurred()) 8423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 8433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (void *)x; 8443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 8453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#ifdef HAVE_LONG_LONG 8473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Initial PY_LONG_LONG support by Chris Herborth (chrish@qnx.com), later 8493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * rewritten to use the newer PyLong_{As,From}ByteArray API. 8503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 8513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define IS_LITTLE_ENDIAN (int)*(unsigned char*)&one 8533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define PY_ABS_LLONG_MIN (0-(unsigned PY_LONG_LONG)PY_LLONG_MIN) 8543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Create a new long int object from a C PY_LONG_LONG int. */ 8563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 8583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_FromLongLong(PY_LONG_LONG ival) 8593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 8603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *v; 8613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned PY_LONG_LONG abs_ival; 8623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned PY_LONG_LONG t; /* unsigned so >> doesn't propagate sign bit */ 8633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int ndigits = 0; 8643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int negative = 0; 8653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (ival < 0) { 8673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* avoid signed overflow on negation; see comments 8683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel in PyLong_FromLong above. */ 8693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel abs_ival = (unsigned PY_LONG_LONG)(-1-ival) + 1; 8703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negative = 1; 8713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 8723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 8733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel abs_ival = (unsigned PY_LONG_LONG)ival; 8743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 8753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Count the number of Python digits. 8773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel We used to pick 5 ("big enough for anything"), but that's a 8783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel waste of time and space given that 5*15 = 75 bits are rarely 8793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel needed. */ 8803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t = abs_ival; 8813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (t) { 8823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++ndigits; 8833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t >>= PyLong_SHIFT; 8843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 8853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = _PyLong_New(ndigits); 8863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (v != NULL) { 8873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *p = v->ob_digit; 8883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(v) = negative ? -ndigits : ndigits; 8893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t = abs_ival; 8903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (t) { 8913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *p++ = (digit)(t & PyLong_MASK); 8923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t >>= PyLong_SHIFT; 8933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 8943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 8953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)v; 8963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 8973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 8983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Create a new long int object from a C unsigned PY_LONG_LONG int. */ 8993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 9013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival) 9023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 9033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *v; 9043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned PY_LONG_LONG t; 9053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int ndigits = 0; 9063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Count the number of Python digits. */ 9083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t = (unsigned PY_LONG_LONG)ival; 9093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (t) { 9103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++ndigits; 9113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t >>= PyLong_SHIFT; 9123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 9133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = _PyLong_New(ndigits); 9143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (v != NULL) { 9153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *p = v->ob_digit; 9163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(v) = ndigits; 9173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (ival) { 9183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *p++ = (digit)(ival & PyLong_MASK); 9193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ival >>= PyLong_SHIFT; 9203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 9213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 9223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)v; 9233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 9243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Create a new long int object from a C Py_ssize_t. */ 9263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 9283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_FromSsize_t(Py_ssize_t ival) 9293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 9303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t bytes = ival; 9313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int one = 1; 9323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return _PyLong_FromByteArray((unsigned char *)&bytes, 9333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 1); 9343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 9353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Create a new long int object from a C size_t. */ 9373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 9393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_FromSize_t(size_t ival) 9403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 9413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_t bytes = ival; 9423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int one = 1; 9433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return _PyLong_FromByteArray((unsigned char *)&bytes, 9443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 0); 9453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 9463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a C PY_LONG_LONG int from a long int object. 9483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Return -1 and set an error if overflow occurs. */ 9493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPY_LONG_LONG 9513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_AsLongLong(PyObject *vv) 9523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 9533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PY_LONG_LONG bytes; 9543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int one = 1; 9553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int res; 9563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv == NULL) { 9583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadInternalCall(); 9593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 9603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 9613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (!PyLong_Check(vv)) { 9623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyNumberMethods *nb; 9633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *io; 9643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyInt_Check(vv)) 9653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PY_LONG_LONG)PyInt_AsLong(vv); 9663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((nb = vv->ob_type->tp_as_number) == NULL || 9673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel nb->nb_int == NULL) { 9683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_TypeError, "an integer is required"); 9693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 9703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 9713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel io = (*nb->nb_int) (vv); 9723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (io == NULL) 9733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 9743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyInt_Check(io)) { 9753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bytes = PyInt_AsLong(io); 9763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(io); 9773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return bytes; 9783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 9793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyLong_Check(io)) { 9803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bytes = PyLong_AsLongLong(io); 9813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(io); 9823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return bytes; 9833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 9843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(io); 9853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_TypeError, "integer conversion failed"); 9863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 9873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 9883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = _PyLong_AsByteArray((PyLongObject *)vv, (unsigned char *)&bytes, 9903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1); 9913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */ 9933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (res < 0) 9943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PY_LONG_LONG)-1; 9953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 9963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return bytes; 9973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 9983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 9993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a C unsigned PY_LONG_LONG int from a long int object. 10003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Return -1 and set an error if overflow occurs. */ 10013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielunsigned PY_LONG_LONG 10033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_AsUnsignedLongLong(PyObject *vv) 10043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 10053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned PY_LONG_LONG bytes; 10063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int one = 1; 10073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int res; 10083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv == NULL || !PyLong_Check(vv)) { 10103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadInternalCall(); 10113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (unsigned PY_LONG_LONG)-1; 10123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 10133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = _PyLong_AsByteArray((PyLongObject *)vv, (unsigned char *)&bytes, 10153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0); 10163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */ 10183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (res < 0) 10193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (unsigned PY_LONG_LONG)res; 10203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 10213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return bytes; 10223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 10233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a C unsigned long int from a long int object, ignoring the high bits. 10253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Returns -1 and sets an error condition if an error occurs. */ 10263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielunsigned PY_LONG_LONG 10283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_AsUnsignedLongLongMask(PyObject *vv) 10293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 10303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel register PyLongObject *v; 10313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned PY_LONG_LONG x; 10323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 10333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int sign; 10343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv == NULL || !PyLong_Check(vv)) { 10363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadInternalCall(); 10373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (unsigned long) -1; 10383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 10393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = (PyLongObject *)vv; 10403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = v->ob_size; 10413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = 1; 10423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = 0; 10433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i < 0) { 10443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = -1; 10453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = -i; 10463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 10473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--i >= 0) { 10483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = (x << PyLong_SHIFT) | v->ob_digit[i]; 10493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 10503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return x * sign; 10513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 10523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a C long long int from a Python long or Python int object. 10543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel On overflow, returns -1 and sets *overflow to 1 or -1 depending 10553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel on the sign of the result. Otherwise *overflow is 0. 10563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel For other errors (e.g., type error), returns -1 and sets an error 10583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel condition. 10593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel*/ 10603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPY_LONG_LONG 10623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_AsLongLongAndOverflow(PyObject *vv, int *overflow) 10633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 10643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* This version by Tim Peters */ 10653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel register PyLongObject *v; 10663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned PY_LONG_LONG x, prev; 10673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PY_LONG_LONG res; 10683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 10693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int sign; 10703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int do_decref = 0; /* if nb_int was called */ 10713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *overflow = 0; 10733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv == NULL) { 10743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadInternalCall(); 10753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 10763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 10773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyInt_Check(vv)) 10793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyInt_AsLong(vv); 10803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 10813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (!PyLong_Check(vv)) { 10823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyNumberMethods *nb; 10833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel nb = vv->ob_type->tp_as_number; 10843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (nb == NULL || nb->nb_int == NULL) { 10853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_TypeError, 10863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "an integer is required"); 10873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 10883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 10893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel vv = (*nb->nb_int) (vv); 10903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (vv == NULL) 10913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 10923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do_decref = 1; 10933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if(PyInt_Check(vv)) { 10943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = PyInt_AsLong(vv); 10953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto exit; 10963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 10973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (!PyLong_Check(vv)) { 10983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(vv); 10993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_TypeError, 11003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "nb_int should return int object"); 11013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 11023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 11053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = -1; 11063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = (PyLongObject *)vv; 11073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = Py_SIZE(v); 11083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 11093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel switch (i) { 11103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case -1: 11113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = -(sdigit)v->ob_digit[0]; 11123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 11133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case 0: 11143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = 0; 11153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 11163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case 1: 11173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = v->ob_digit[0]; 11183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 11193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel default: 11203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = 1; 11213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = 0; 11223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i < 0) { 11233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = -1; 11243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = -(i); 11253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--i >= 0) { 11273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel prev = x; 11283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = (x << PyLong_SHIFT) + v->ob_digit[i]; 11293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((x >> PyLong_SHIFT) != prev) { 11303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *overflow = sign; 11313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto exit; 11323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Haven't lost any bits, but casting to long requires extra 11353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * care (see comment above). 11363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 11373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x <= (unsigned PY_LONG_LONG)PY_LLONG_MAX) { 11383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = (PY_LONG_LONG)x * sign; 11393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (sign < 0 && x == PY_ABS_LLONG_MIN) { 11413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = PY_LLONG_MIN; 11423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 11443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *overflow = sign; 11453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* res is already set to -1 */ 11463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel exit: 11493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (do_decref) { 11503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(vv); 11513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return res; 11533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 11543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 11553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#undef IS_LITTLE_ENDIAN 11563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 11573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif /* HAVE_LONG_LONG */ 11583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 11593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 11603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic int 11613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielconvert_binop(PyObject *v, PyObject *w, PyLongObject **a, PyLongObject **b) { 11623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyLong_Check(v)) { 11633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *a = (PyLongObject *) v; 11643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(v); 11653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (PyInt_Check(v)) { 11673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *a = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(v)); 11683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 11703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0; 11713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyLong_Check(w)) { 11733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *b = (PyLongObject *) w; 11743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(w); 11753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (PyInt_Check(w)) { 11773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *b = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(w)); 11783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 11803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(*a); 11813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0; 11823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 11833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 1; 11843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 11853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 11863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define CONVERT_BINOP(v, w, a, b) \ 11873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do { \ 11883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (!convert_binop(v, w, a, b)) { \ 11893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(Py_NotImplemented); \ 11903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return Py_NotImplemented; \ 11913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } \ 11923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } while(0) \ 11933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 11943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* bits_in_digit(d) returns the unique integer k such that 2**(k-1) <= d < 11953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2**k if d is nonzero, else 0. */ 11963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 11973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic const unsigned char BitLengthTable[32] = { 11983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 11993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 12003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel}; 12013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 12023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic int 12033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielbits_in_digit(digit d) 12043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 12053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int d_bits = 0; 12063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (d >= 32) { 12073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel d_bits += 6; 12083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel d >>= 6; 12093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 12103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel d_bits += (int)BitLengthTable[d]; 12113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return d_bits; 12123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 12133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 12143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* x[0:m] and y[0:n] are digit vectors, LSD first, m >= n required. x[0:n] 12153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * is modified in place, by adding y to it. Carries are propagated as far as 12163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * x[m-1], and the remaining carry (0 or 1) is returned. 12173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 12183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic digit 12193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielv_iadd(digit *x, Py_ssize_t m, digit *y, Py_ssize_t n) 12203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 12213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 12223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit carry = 0; 12233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 12243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(m >= n); 12253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < n; ++i) { 12263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry += x[i] + y[i]; 12273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x[i] = carry & PyLong_MASK; 12283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry >>= PyLong_SHIFT; 12293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert((carry & 1) == carry); 12303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 12313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (; carry && i < m; ++i) { 12323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry += x[i]; 12333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x[i] = carry & PyLong_MASK; 12343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry >>= PyLong_SHIFT; 12353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert((carry & 1) == carry); 12363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 12373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return carry; 12383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 12393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 12403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* x[0:m] and y[0:n] are digit vectors, LSD first, m >= n required. x[0:n] 12413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * is modified in place, by subtracting y from it. Borrows are propagated as 12423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * far as x[m-1], and the remaining borrow (0 or 1) is returned. 12433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 12443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic digit 12453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielv_isub(digit *x, Py_ssize_t m, digit *y, Py_ssize_t n) 12463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 12473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 12483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit borrow = 0; 12493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 12503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(m >= n); 12513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < n; ++i) { 12523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow = x[i] - y[i] - borrow; 12533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x[i] = borrow & PyLong_MASK; 12543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow >>= PyLong_SHIFT; 12553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow &= 1; /* keep only 1 sign bit */ 12563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 12573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (; borrow && i < m; ++i) { 12583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow = x[i] - borrow; 12593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x[i] = borrow & PyLong_MASK; 12603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow >>= PyLong_SHIFT; 12613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow &= 1; 12623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 12633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return borrow; 12643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 12653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 12663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Shift digit vector a[0:m] d bits left, with 0 <= d < PyLong_SHIFT. Put 12673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * result in z[0:m], and return the d bits shifted out of the top. 12683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 12693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic digit 12703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielv_lshift(digit *z, digit *a, Py_ssize_t m, int d) 12713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 12723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 12733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit carry = 0; 12743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 12753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(0 <= d && d < PyLong_SHIFT); 12763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i=0; i < m; i++) { 12773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits acc = (twodigits)a[i] << d | carry; 12783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z[i] = (digit)acc & PyLong_MASK; 12793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry = (digit)(acc >> PyLong_SHIFT); 12803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 12813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return carry; 12823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 12833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 12843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Shift digit vector a[0:m] d bits right, with 0 <= d < PyLong_SHIFT. Put 12853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * result in z[0:m], and return the d bits shifted out of the bottom. 12863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 12873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic digit 12883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielv_rshift(digit *z, digit *a, Py_ssize_t m, int d) 12893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 12903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 12913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit carry = 0; 12923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit mask = ((digit)1 << d) - 1U; 12933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 12943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(0 <= d && d < PyLong_SHIFT); 12953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i=m; i-- > 0;) { 12963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits acc = (twodigits)carry << PyLong_SHIFT | a[i]; 12973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry = (digit)acc & mask; 12983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z[i] = (digit)(acc >> d); 12993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 13003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return carry; 13013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 13023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Divide long pin, w/ size digits, by non-zero digit n, storing quotient 13043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel in pout, and returning the remainder. pin and pout point at the LSD. 13053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel It's OK for pin == pout on entry, which saves oodles of mallocs/frees in 13063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel _PyLong_Format, but that should be done with great care since longs are 13073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel immutable. */ 13083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic digit 13103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielinplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n) 13113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 13123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits rem = 0; 13133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(n > 0 && n <= PyLong_MASK); 13153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pin += size; 13163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pout += size; 13173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--size >= 0) { 13183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit hi; 13193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem = (rem << PyLong_SHIFT) | *--pin; 13203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--pout = hi = (digit)(rem / n); 13213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem -= (twodigits)hi * n; 13223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 13233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (digit)rem; 13243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 13253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Divide a long integer by a digit, returning both the quotient 13273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (as function result) and the remainder (through *prem). 13283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel The sign of a is ignored; n should not be zero. */ 13293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyLongObject * 13313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanieldivrem1(PyLongObject *a, digit n, digit *prem) 13323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 13333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const Py_ssize_t size = ABS(Py_SIZE(a)); 13343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z; 13353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(n > 0 && n <= PyLong_MASK); 13373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(size); 13383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 13393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 13403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *prem = inplace_divrem1(z->ob_digit, a->ob_digit, size, n); 13413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_normalize(z); 13423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 13433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Convert a long integer to a base 10 string. Returns a new non-shared 13453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel string. (Return value is non-shared so that callers can modify the 13463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel returned value if necessary.) */ 13473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 13493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_to_decimal_string(PyObject *aa, int addL) 13503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 13513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *scratch, *a; 13523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *str; 13533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size, strlen, size_a, i, j; 13543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *pout, *pin, rem, tenpow; 13553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char *p; 13563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int negative; 13573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a = (PyLongObject *)aa; 13593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a == NULL || !PyLong_Check(a)) { 13603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadInternalCall(); 13613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 13623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 13633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_a = ABS(Py_SIZE(a)); 13643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negative = Py_SIZE(a) < 0; 13653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* quick and dirty upper bound for the number of digits 13673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel required to express a in base _PyLong_DECIMAL_BASE: 13683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel #digits = 1 + floor(log2(a) / log2(_PyLong_DECIMAL_BASE)) 13703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel But log2(a) < size_a * PyLong_SHIFT, and 13723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel log2(_PyLong_DECIMAL_BASE) = log2(10) * _PyLong_DECIMAL_SHIFT 13733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel > 3 * _PyLong_DECIMAL_SHIFT 13743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 13753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (size_a > PY_SSIZE_T_MAX / PyLong_SHIFT) { 13763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 13773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "long is too large to format"); 13783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 13793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 13803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* the expression size_a * PyLong_SHIFT is now safe from overflow */ 13813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size = 1 + size_a * PyLong_SHIFT / (3 * _PyLong_DECIMAL_SHIFT); 13823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel scratch = _PyLong_New(size); 13833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (scratch == NULL) 13843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 13853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* convert array of base _PyLong_BASE digits in pin to an array of 13873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base _PyLong_DECIMAL_BASE digits in pout, following Knuth (TAOCP, 13883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Volume 2 (3rd edn), section 4.4, Method 1b). */ 13893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pin = a->ob_digit; 13903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pout = scratch->ob_digit; 13913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size = 0; 13923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = size_a; --i >= 0; ) { 13933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit hi = pin[i]; 13943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (j = 0; j < size; j++) { 13953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits z = (twodigits)pout[j] << PyLong_SHIFT | hi; 13963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel hi = (digit)(z / _PyLong_DECIMAL_BASE); 13973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pout[j] = (digit)(z - (twodigits)hi * 13983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel _PyLong_DECIMAL_BASE); 13993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 14003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (hi) { 14013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pout[size++] = hi % _PyLong_DECIMAL_BASE; 14023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel hi /= _PyLong_DECIMAL_BASE; 14033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 14043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* check for keyboard interrupt */ 14053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel SIGCHECK({ 14063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(scratch); 14073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 14083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel }); 14093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 14103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* pout should have at least one digit, so that the case when a = 0 14113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel works correctly */ 14123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (size == 0) 14133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pout[size++] = 0; 14143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 14153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* calculate exact length of output string, and allocate */ 14163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel strlen = (addL != 0) + negative + 14173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1 + (size - 1) * _PyLong_DECIMAL_SHIFT; 14183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel tenpow = 10; 14193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem = pout[size-1]; 14203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (rem >= tenpow) { 14213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel tenpow *= 10; 14223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel strlen++; 14233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 14243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel str = PyString_FromStringAndSize(NULL, strlen); 14253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (str == NULL) { 14263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(scratch); 14273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 14283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 14293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 14303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* fill the string right-to-left */ 14313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel p = PyString_AS_STRING(str) + strlen; 14323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *p = '\0'; 14333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (addL) 14343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = 'L'; 14353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* pout[0] through pout[size-2] contribute exactly 14363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel _PyLong_DECIMAL_SHIFT digits each */ 14373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i=0; i < size - 1; i++) { 14383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem = pout[i]; 14393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (j = 0; j < _PyLong_DECIMAL_SHIFT; j++) { 14403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = '0' + rem % 10; 14413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem /= 10; 14423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 14433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 14443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* pout[size-1]: always produce at least one decimal digit */ 14453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem = pout[i]; 14463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do { 14473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = '0' + rem % 10; 14483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem /= 10; 14493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } while (rem != 0); 14503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 14513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* and sign */ 14523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (negative) 14533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = '-'; 14543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 14553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* check we've counted correctly */ 14563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(p == PyString_AS_STRING(str)); 14573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(scratch); 14583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)str; 14593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 14603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 14613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Convert the long to a string object with given base, 14623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel appending a base prefix of 0[box] if base is 2, 8 or 16. 14633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Add a trailing "L" if addL is non-zero. 14643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel If newstyle is zero, then use the pre-2.6 behavior of octal having 14653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a leading "0", instead of the prefix "0o" */ 14663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyAPI_FUNC(PyObject *) 14673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel_PyLong_Format(PyObject *aa, int base, int addL, int newstyle) 14683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 14693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel register PyLongObject *a = (PyLongObject *)aa; 14703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyStringObject *str; 14713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i, sz; 14723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size_a; 14733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char *p; 14743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int bits; 14753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char sign = '\0'; 14763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 14773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (base == 10) 14783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_to_decimal_string((PyObject *)a, addL); 14793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 14803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a == NULL || !PyLong_Check(a)) { 14813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadInternalCall(); 14823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 14833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 14843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(base >= 2 && base <= 36); 14853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_a = ABS(Py_SIZE(a)); 14863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 14873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Compute a rough upper bound for the length of the string */ 14883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = base; 14893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bits = 0; 14903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (i > 1) { 14913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++bits; 14923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i >>= 1; 14933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 14943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = 5 + (addL ? 1 : 0); 14953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* ensure we don't get signed overflow in sz calculation */ 14963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (size_a > (PY_SSIZE_T_MAX - i) / PyLong_SHIFT) { 14973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 14983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "long is too large to format"); 14993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 15003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 15013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sz = i + 1 + (size_a * PyLong_SHIFT - 1) / bits; 15023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(sz >= 0); 15033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel str = (PyStringObject *) PyString_FromStringAndSize((char *)0, sz); 15043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (str == NULL) 15053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 15063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel p = PyString_AS_STRING(str) + sz; 15073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *p = '\0'; 15083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (addL) 15093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = 'L'; 15103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a->ob_size < 0) 15113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = '-'; 15123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 15133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a->ob_size == 0) { 15143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = '0'; 15153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 15163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if ((base & (base - 1)) == 0) { 15173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* JRH: special case for power-of-2 bases */ 15183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits accum = 0; 15193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int accumbits = 0; /* # of bits in accum */ 15203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int basebits = 1; /* # of bits in base-1 */ 15213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = base; 15223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while ((i >>= 1) > 1) 15233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++basebits; 15243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 15253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < size_a; ++i) { 15263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum |= (twodigits)a->ob_digit[i] << accumbits; 15273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accumbits += PyLong_SHIFT; 15283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(accumbits >= basebits); 15293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do { 15303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char cdigit = (char)(accum & (base - 1)); 15313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel cdigit += (cdigit < 10) ? '0' : 'a'-10; 15323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(p > PyString_AS_STRING(str)); 15333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = cdigit; 15343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accumbits -= basebits; 15353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum >>= basebits; 15363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } while (i < size_a-1 ? accumbits >= basebits : accum > 0); 15373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 15383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 15393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 15403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Not 0, and base not a power of 2. Divide repeatedly by 15413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base, but for speed use the highest power of base that 15423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel fits in a digit. */ 15433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size = size_a; 15443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *pin = a->ob_digit; 15453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *scratch; 15463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* powbasw <- largest power of base that fits in a digit. */ 15473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit powbase = base; /* powbase == base ** power */ 15483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int power = 1; 15493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (;;) { 15503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits newpow = powbase * (twodigits)base; 15513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (newpow >> PyLong_SHIFT) 15523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* doesn't fit in a digit */ 15533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 15543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel powbase = (digit)newpow; 15553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++power; 15563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 15573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 15583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Get a scratch area for repeated division. */ 15593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel scratch = _PyLong_New(size); 15603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (scratch == NULL) { 15613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(str); 15623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 15633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 15643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 15653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Repeatedly divide by powbase. */ 15663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do { 15673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int ntostore = power; 15683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit rem = inplace_divrem1(scratch->ob_digit, 15693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pin, size, powbase); 15703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pin = scratch->ob_digit; /* no need to use a again */ 15713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (pin[size - 1] == 0) 15723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel --size; 15733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel SIGCHECK({ 15743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(scratch); 15753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(str); 15763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 15773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel }); 15783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 15793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Break rem into digits. */ 15803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(ntostore > 0); 15813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do { 15823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit nextrem = (digit)(rem / base); 15833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char c = (char)(rem - nextrem * base); 15843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(p > PyString_AS_STRING(str)); 15853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c += (c < 10) ? '0' : 'a'-10; 15863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = c; 15873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem = nextrem; 15883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel --ntostore; 15893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Termination is a bit delicate: must not 15903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel store leading zeroes, so must get out if 15913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel remaining quotient and rem are both 0. */ 15923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } while (ntostore && (size || rem)); 15933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } while (size != 0); 15943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(scratch); 15953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 15963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 15973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (base == 2) { 15983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = 'b'; 15993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = '0'; 16003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 16013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (base == 8) { 16023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (newstyle) { 16033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = 'o'; 16043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = '0'; 16053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 16063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 16073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (size_a != 0) 16083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = '0'; 16093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 16103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (base == 16) { 16113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = 'x'; 16123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = '0'; 16133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 16143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (base != 10) { 16153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = '#'; 16163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = '0' + base%10; 16173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (base > 10) 16183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = '0' + base/10; 16193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 16203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (sign) 16213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--p = sign; 16223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (p != PyString_AS_STRING(str)) { 16233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char *q = PyString_AS_STRING(str); 16243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(p > q); 16253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do { 16263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } while ((*q++ = *p++) != '\0'); 16273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel q--; 16283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel _PyString_Resize((PyObject **)&str, 16293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (Py_ssize_t) (q - PyString_AS_STRING(str))); 16303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 16313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)str; 16323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 16333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 16343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Table of digit values for 8-bit string -> integer conversion. 16353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * '0' maps to 0, ..., '9' maps to 9. 16363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * 'a' and 'A' map to 10, ..., 'z' and 'Z' map to 35. 16373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * All other indices map to 37. 16383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * Note that when converting a base B string, a char c is a legitimate 16393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * base B digit iff _PyLong_DigitValue[Py_CHARMASK(c)] < B. 16403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 16413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielint _PyLong_DigitValue[256] = { 16423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 37, 37, 37, 37, 37, 37, 16463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 16473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 37, 37, 37, 37, 16483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 16493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 37, 37, 37, 37, 16503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel}; 16593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 16603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* *str points to the first digit in a string of base `base` digits. base 16613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * is a power of 2 (2, 4, 8, 16, or 32). *str is set to point to the first 16623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * non-digit (which may be *str!). A normalized long is returned. 16633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * The point to this routine is that it takes time linear in the number of 16643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * string characters. 16653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 16663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyLongObject * 16673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_from_binary_base(char **str, int base) 16683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 16693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char *p = *str; 16703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char *start = p; 16713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int bits_per_char; 16723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t n; 16733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z; 16743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits accum; 16753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int bits_in_accum; 16763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *pdigit; 16773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 16783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(base >= 2 && base <= 32 && (base & (base - 1)) == 0); 16793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel n = base; 16803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (bits_per_char = -1; n; ++bits_per_char) 16813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel n >>= 1; 16823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* n <- total # of bits needed, while setting p to end-of-string */ 16833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (_PyLong_DigitValue[Py_CHARMASK(*p)] < base) 16843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++p; 16853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *str = p; 16863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* n <- # of Python digits needed, = ceiling(n/PyLong_SHIFT). */ 16873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel n = (p - start) * bits_per_char + PyLong_SHIFT - 1; 16883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (n / bits_per_char < p - start) { 16893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_ValueError, 16903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "long string too large to convert"); 16913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 16923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 16933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel n = n / PyLong_SHIFT; 16943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(n); 16953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 16963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 16973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Read string from right, and fill in long from left; i.e., 16983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * from least to most significant in both. 16993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 17003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum = 0; 17013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bits_in_accum = 0; 17023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pdigit = z->ob_digit; 17033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--p >= start) { 17043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int k = _PyLong_DigitValue[Py_CHARMASK(*p)]; 17053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(k >= 0 && k < base); 17063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum |= (twodigits)k << bits_in_accum; 17073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bits_in_accum += bits_per_char; 17083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (bits_in_accum >= PyLong_SHIFT) { 17093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pdigit++ = (digit)(accum & PyLong_MASK); 17103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(pdigit - z->ob_digit <= n); 17113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum >>= PyLong_SHIFT; 17123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bits_in_accum -= PyLong_SHIFT; 17133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(bits_in_accum < PyLong_SHIFT); 17143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 17153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 17163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (bits_in_accum) { 17173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(bits_in_accum <= PyLong_SHIFT); 17183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pdigit++ = (digit)accum; 17193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(pdigit - z->ob_digit <= n); 17203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 17213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (pdigit - z->ob_digit < n) 17223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pdigit++ = 0; 17233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_normalize(z); 17243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 17253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 17263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 17273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_FromString(char *str, char **pend, int base) 17283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 17293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int sign = 1; 17303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char *start, *orig_str = str; 17313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z; 17323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *strobj, *strrepr; 17333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t slen; 17343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 17353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((base != 0 && base < 2) || base > 36) { 17363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_ValueError, 17373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "long() arg 2 must be >= 2 and <= 36"); 17383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 17393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 17403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (*str != '\0' && isspace(Py_CHARMASK(*str))) 17413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel str++; 17423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (*str == '+') 17433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++str; 17443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (*str == '-') { 17453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++str; 17463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = -1; 17473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 17483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (*str != '\0' && isspace(Py_CHARMASK(*str))) 17493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel str++; 17503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (base == 0) { 17513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* No base given. Deduce the base from the contents 17523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel of the string */ 17533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (str[0] != '0') 17543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base = 10; 17553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (str[1] == 'x' || str[1] == 'X') 17563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base = 16; 17573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (str[1] == 'o' || str[1] == 'O') 17583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base = 8; 17593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (str[1] == 'b' || str[1] == 'B') 17603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base = 2; 17613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 17623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* "old" (C-style) octal literal, still valid in 17633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2.x, although illegal in 3.x */ 17643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base = 8; 17653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 17663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Whether or not we were deducing the base, skip leading chars 17673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel as needed */ 17683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (str[0] == '0' && 17693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ((base == 16 && (str[1] == 'x' || str[1] == 'X')) || 17703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (base == 8 && (str[1] == 'o' || str[1] == 'O')) || 17713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (base == 2 && (str[1] == 'b' || str[1] == 'B')))) 17723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel str += 2; 17733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 17743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel start = str; 17753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((base & (base - 1)) == 0) 17763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = long_from_binary_base(&str, base); 17773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 17783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/*** 17793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielBinary bases can be converted in time linear in the number of digits, because 17803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPython's representation base is binary. Other bases (including decimal!) use 17813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielthe simple quadratic-time algorithm below, complicated by some speed tricks. 17823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 17833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielFirst some math: the largest integer that can be expressed in N base-B digits 17843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielis B**N-1. Consequently, if we have an N-digit input in base B, the worst- 17853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielcase number of Python digits needed to hold it is the smallest integer n s.t. 17863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 17873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLong_BASE**n-1 >= B**N-1 [or, adding 1 to both sides] 17883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLong_BASE**n >= B**N [taking logs to base PyLong_BASE] 17893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel n >= log(B**N)/log(PyLong_BASE) = N * log(B)/log(PyLong_BASE) 17903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 17913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielThe static array log_base_PyLong_BASE[base] == log(base)/log(PyLong_BASE) so 17923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielwe can compute this quickly. A Python long with that much space is reserved 17933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielnear the start, and the result is computed into it. 17943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 17953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielThe input string is actually treated as being in base base**i (i.e., i digits 17963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielare processed at a time), where two more static arrays hold: 17973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 17983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel convwidth_base[base] = the largest integer i such that 17993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base**i <= PyLong_BASE 18003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel convmultmax_base[base] = base ** convwidth_base[base] 18013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielThe first of these is the largest i such that i consecutive input digits 18033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielmust fit in a single Python digit. The second is effectively the input 18043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielbase we're really using. 18053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielViewing the input as a sequence <c0, c1, ..., c_n-1> of digits in base 18073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielconvmultmax_base[base], the result is "simply" 18083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (((c0*B + c1)*B + c2)*B + c3)*B + ... ))) + c_n-1 18103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielwhere B = convmultmax_base[base]. 18123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielError analysis: as above, the number of Python digits `n` needed is worst- 18143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielcase 18153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel n >= N * log(B)/log(PyLong_BASE) 18173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielwhere `N` is the number of input digits in base `B`. This is computed via 18193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_z = (Py_ssize_t)((scan - str) * log_base_PyLong_BASE[base]) + 1; 18213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielbelow. Two numeric concerns are how much space this can waste, and whether 18233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielthe computed result can be too small. To be concrete, assume PyLong_BASE = 18243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel2**15, which is the default (and it's unlikely anyone changes that). 18253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielWaste isn't a problem: provided the first input digit isn't 0, the difference 18273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielbetween the worst-case input with N digits and the smallest input with N 18283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanieldigits is about a factor of B, but B is small compared to PyLong_BASE so at 18293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielmost one allocated Python digit can remain unused on that count. If 18303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielN*log(B)/log(PyLong_BASE) is mathematically an exact integer, then truncating 18313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielthat and adding 1 returns a result 1 larger than necessary. However, that 18323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielcan't happen: whenever B is a power of 2, long_from_binary_base() is called 18333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielinstead, and it's impossible for B**i to be an integer power of 2**15 when B 18343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielis not a power of 2 (i.e., it's impossible for N*log(B)/log(PyLong_BASE) to be 18353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielan exact integer when B is not a power of 2, since B**i has a prime factor 18363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielother than 2 in that case, but (2**15)**j's only prime factor is 2). 18373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielThe computed result can be too small if the true value of 18393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielN*log(B)/log(PyLong_BASE) is a little bit larger than an exact integer, but 18403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanieldue to roundoff errors (in computing log(B), log(PyLong_BASE), their quotient, 18413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanieland/or multiplying that by N) yields a numeric result a little less than that 18423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielinteger. Unfortunately, "how close can a transcendental function get to an 18433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielinteger over some range?" questions are generally theoretically intractable. 18443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielComputer analysis via continued fractions is practical: expand 18453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellog(B)/log(PyLong_BASE) via continued fractions, giving a sequence i/j of "the 18463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielbest" rational approximations. Then j*log(B)/log(PyLong_BASE) is 18473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielapproximately equal to (the integer) i. This shows that we can get very close 18483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielto being in trouble, but very rarely. For example, 76573 is a denominator in 18493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielone of the continued-fraction approximations to log(10)/log(2**15), and 18503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielindeed: 18513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel >>> log(10)/log(2**15)*76573 18533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 16958.000000654003 18543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielis very close to an integer. If we were working with IEEE single-precision, 18563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielrounding errors could kill us. Finding worst cases in IEEE double-precision 18573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielrequires better-than-double-precision log() functions, and Tim didn't bother. 18583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielInstead the code checks to see whether the allocated space is enough as each 18593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielnew Python digit is added, and copies the whole thing to a larger long if not. 18603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielThis should happen extremely rarely, and in fact I don't have a test case 18613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielthat triggers it(!). Instead the code was tested by artificially allocating 18623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanieljust 1 digit at the start, so that the copying code was exercised for every 18633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanieldigit beyond the first. 18643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel***/ 18653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel register twodigits c; /* current input character */ 18663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size_z; 18673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int i; 18683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int convwidth; 18693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits convmultmax, convmult; 18703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *pz, *pzstop; 18713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char* scan; 18723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel static double log_base_PyLong_BASE[37] = {0.0e0,}; 18743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel static int convwidth_base[37] = {0,}; 18753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel static twodigits convmultmax_base[37] = {0,}; 18763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (log_base_PyLong_BASE[base] == 0.0) { 18783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits convmax = base; 18793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int i = 1; 18803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel log_base_PyLong_BASE[base] = (log((double)base) / 18823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel log((double)PyLong_BASE)); 18833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (;;) { 18843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits next = convmax * base; 18853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (next > PyLong_BASE) 18863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 18873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel convmax = next; 18883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++i; 18893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 18903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel convmultmax_base[base] = convmax; 18913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(i > 0); 18923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel convwidth_base[base] = i; 18933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 18943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 18953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Find length of the string of numeric characters. */ 18963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel scan = str; 18973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (_PyLong_DigitValue[Py_CHARMASK(*scan)] < base) 18983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++scan; 18993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 19003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Create a long object that can contain the largest possible 19013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * integer with this base and length. Note that there's no 19023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * need to initialize z->ob_digit -- no slot is read up before 19033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * being stored into. 19043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 19053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_z = (Py_ssize_t)((scan - str) * log_base_PyLong_BASE[base]) + 1; 19063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Uncomment next line to test exceedingly rare copy code */ 19073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* size_z = 1; */ 19083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(size_z > 0); 19093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(size_z); 19103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 19113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 19123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(z) = 0; 19133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 19143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* `convwidth` consecutive input digits are treated as a single 19153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * digit in base `convmultmax`. 19163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 19173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel convwidth = convwidth_base[base]; 19183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel convmultmax = convmultmax_base[base]; 19193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 19203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Work ;-) */ 19213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (str < scan) { 19223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* grab up to convwidth digits from the input string */ 19233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c = (digit)_PyLong_DigitValue[Py_CHARMASK(*str++)]; 19243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 1; i < convwidth && str != scan; ++i, ++str) { 19253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c = (twodigits)(c * base + 19263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel _PyLong_DigitValue[Py_CHARMASK(*str)]); 19273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(c < PyLong_BASE); 19283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 19293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 19303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel convmult = convmultmax; 19313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Calculate the shift only if we couldn't get 19323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * convwidth digits. 19333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 19343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i != convwidth) { 19353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel convmult = base; 19363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for ( ; i > 1; --i) 19373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel convmult *= base; 19383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 19393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 19403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Multiply z by convmult, and add c. */ 19413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pz = z->ob_digit; 19423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel pzstop = pz + Py_SIZE(z); 19433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (; pz < pzstop; ++pz) { 19443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c += (twodigits)*pz * convmult; 19453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pz = (digit)(c & PyLong_MASK); 19463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c >>= PyLong_SHIFT; 19473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 19483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* carry off the current end? */ 19493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (c) { 19503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(c < PyLong_BASE); 19513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(z) < size_z) { 19523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pz = (digit)c; 19533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++Py_SIZE(z); 19543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 19553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 19563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *tmp; 19573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Extremely rare. Get more space. */ 19583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(Py_SIZE(z) == size_z); 19593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel tmp = _PyLong_New(size_z + 1); 19603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (tmp == NULL) { 19613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(z); 19623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 19633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 19643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memcpy(tmp->ob_digit, 19653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit, 19663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sizeof(digit) * size_z); 19673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(z); 19683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = tmp; 19693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[size_z] = (digit)c; 19703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++size_z; 19713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 19723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 19733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 19743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 19753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 19763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 19773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (str == start) 19783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto onError; 19793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (sign < 0) 19803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(z) = -(Py_SIZE(z)); 19813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (*str == 'L' || *str == 'l') 19823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel str++; 19833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (*str && isspace(Py_CHARMASK(*str))) 19843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel str++; 19853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (*str != '\0') 19863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto onError; 19873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (pend) 19883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pend = str; 19893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *) z; 19903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 19913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel onError: 19923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(z); 19933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200; 19943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel strobj = PyString_FromStringAndSize(orig_str, slen); 19953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (strobj == NULL) 19963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 19973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel strrepr = PyObject_Repr(strobj); 19983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(strobj); 19993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (strrepr == NULL) 20003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 20013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_Format(PyExc_ValueError, 20023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "invalid literal for long() with base %d: %s", 20033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base, PyString_AS_STRING(strrepr)); 20043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(strrepr); 20053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 20063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 20073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 20083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#ifdef Py_USING_UNICODE 20093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 20103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base) 20113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 20123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *result; 20133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char *buffer = (char *)PyMem_MALLOC(length+1); 20143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 20153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (buffer == NULL) 20163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 20173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 20183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyUnicode_EncodeDecimal(u, length, buffer, NULL)) { 20193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyMem_FREE(buffer); 20203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 20213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 20223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = PyLong_FromString(buffer, NULL, base); 20233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyMem_FREE(buffer); 20243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return result; 20253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 20263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif 20273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 20283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* forward */ 20293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyLongObject *x_divrem 20303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (PyLongObject *, PyLongObject *, PyLongObject **); 20313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject *long_long(PyObject *v); 20323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 20333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Long division with remainder, top-level routine */ 20343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 20353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic int 20363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_divrem(PyLongObject *a, PyLongObject *b, 20373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject **pdiv, PyLongObject **prem) 20383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 20393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); 20403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z; 20413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 20423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (size_b == 0) { 20433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_ZeroDivisionError, 20443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "long division or modulo by zero"); 20453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 20463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 20473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (size_a < size_b || 20483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (size_a == size_b && 20493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a->ob_digit[size_a-1] < b->ob_digit[size_b-1])) { 20503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* |a| < |b|. */ 20513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pdiv = _PyLong_New(0); 20523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (*pdiv == NULL) 20533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 20543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(a); 20553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *prem = (PyLongObject *) a; 20563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0; 20573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 20583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (size_b == 1) { 20593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit rem = 0; 20603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = divrem1(a, b->ob_digit[0], &rem); 20613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 20623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 20633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *prem = (PyLongObject *) PyLong_FromLong((long)rem); 20643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (*prem == NULL) { 20653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(z); 20663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 20673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 20683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 20693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 20703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = x_divrem(a, b, prem); 20713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 20723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 20733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 20743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Set the signs. 20753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel The quotient z has the sign of a*b; 20763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel the remainder r has the sign of a, 20773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel so a = b*z + r. */ 20783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((a->ob_size < 0) != (b->ob_size < 0)) 20793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_size = -(z->ob_size); 20803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a->ob_size < 0 && (*prem)->ob_size != 0) 20813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (*prem)->ob_size = -((*prem)->ob_size); 20823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pdiv = z; 20833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0; 20843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 20853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 20863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Unsigned long division with remainder -- the algorithm. The arguments v1 20873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel and w1 should satisfy 2 <= ABS(Py_SIZE(w1)) <= ABS(Py_SIZE(v1)). */ 20883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 20893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyLongObject * 20903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielx_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem) 20913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 20923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *v, *w, *a; 20933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i, k, size_v, size_w; 20943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int d; 20953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit wm1, wm2, carry, q, r, vtop, *v0, *vk, *w0, *ak; 20963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits vv; 20973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sdigit zhi; 20983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel stwodigits z; 20993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 21003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* We follow Knuth [The Art of Computer Programming, Vol. 2 (3rd 21013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel edn.), section 4.3.1, Algorithm D], except that we don't explicitly 21023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel handle the special case when the initial estimate q for a quotient 21033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit is >= PyLong_BASE: the max value for q is PyLong_BASE+1, and 21043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel that won't overflow a digit. */ 21053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 21063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* allocate space; w will also be used to hold the final remainder */ 21073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_v = ABS(Py_SIZE(v1)); 21083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_w = ABS(Py_SIZE(w1)); 21093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(size_v >= size_w && size_w >= 2); /* Assert checks by div() */ 21103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = _PyLong_New(size_v+1); 21113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (v == NULL) { 21123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *prem = NULL; 21133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 21143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 21153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel w = _PyLong_New(size_w); 21163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (w == NULL) { 21173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(v); 21183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *prem = NULL; 21193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 21203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 21213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 21223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* normalize: shift w1 left so that its top digit is >= PyLong_BASE/2. 21233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shift v1 left by the same amount. Results go into w and v. */ 21243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel d = PyLong_SHIFT - bits_in_digit(w1->ob_digit[size_w-1]); 21253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry = v_lshift(w->ob_digit, w1->ob_digit, size_w, d); 21263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(carry == 0); 21273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry = v_lshift(v->ob_digit, v1->ob_digit, size_v, d); 21283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (carry != 0 || v->ob_digit[size_v-1] >= w->ob_digit[size_w-1]) { 21293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v->ob_digit[size_v] = carry; 21303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_v++; 21313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 21323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 21333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Now v->ob_digit[size_v-1] < w->ob_digit[size_w-1], so quotient has 21343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel at most (and usually exactly) k = size_v - size_w digits. */ 21353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel k = size_v - size_w; 21363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(k >= 0); 21373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a = _PyLong_New(k); 21383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a == NULL) { 21393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(w); 21403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(v); 21413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *prem = NULL; 21423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 21433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 21443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v0 = v->ob_digit; 21453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel w0 = w->ob_digit; 21463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel wm1 = w0[size_w-1]; 21473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel wm2 = w0[size_w-2]; 21483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (vk = v0+k, ak = a->ob_digit + k; vk-- > v0;) { 21493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* inner loop: divide vk[0:size_w+1] by w0[0:size_w], giving 21503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel single-digit quotient q, remainder in vk[0:size_w]. */ 21513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 21523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel SIGCHECK({ 21533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 21543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(w); 21553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(v); 21563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *prem = NULL; 21573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 21583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel }); 21593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 21603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* estimate quotient digit q; may overestimate by 1 (rare) */ 21613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel vtop = vk[size_w]; 21623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(vtop <= wm1); 21633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel vv = ((twodigits)vtop << PyLong_SHIFT) | vk[size_w-1]; 21643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel q = (digit)(vv / wm1); 21653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel r = (digit)(vv - (twodigits)wm1 * q); /* r = vv % wm1 */ 21663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while ((twodigits)wm2 * q > (((twodigits)r << PyLong_SHIFT) 21673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel | vk[size_w-2])) { 21683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel --q; 21693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel r += wm1; 21703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (r >= PyLong_BASE) 21713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 21723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 21733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(q <= PyLong_BASE); 21743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 21753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* subtract q*w0[0:size_w] from vk[0:size_w+1] */ 21763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel zhi = 0; 21773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < size_w; ++i) { 21783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* invariants: -PyLong_BASE <= -q <= zhi <= 0; 21793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel -PyLong_BASE * q <= z < PyLong_BASE */ 21803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = (sdigit)vk[i] + zhi - 21813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (stwodigits)q * (stwodigits)w0[i]; 21823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel vk[i] = (digit)z & PyLong_MASK; 21833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel zhi = (sdigit)Py_ARITHMETIC_RIGHT_SHIFT(stwodigits, 21843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z, PyLong_SHIFT); 21853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 21863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 21873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* add w back if q was too large (this branch taken rarely) */ 21883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert((sdigit)vtop + zhi == -1 || (sdigit)vtop + zhi == 0); 21893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((sdigit)vtop + zhi < 0) { 21903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry = 0; 21913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < size_w; ++i) { 21923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry += vk[i] + w0[i]; 21933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel vk[i] = carry & PyLong_MASK; 21943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry >>= PyLong_SHIFT; 21953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 21963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel --q; 21973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 21983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 21993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* store quotient digit */ 22003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(q < PyLong_BASE); 22013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *--ak = q; 22023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 22033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* unshift remainder; we reuse w to store the result */ 22053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry = v_rshift(w0, v0, size_w, d); 22063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(carry==0); 22073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(v); 22083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *prem = long_normalize(w); 22103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_normalize(a); 22113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 22123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* For a nonzero PyLong a, express a in the form x * 2**e, with 0.5 <= 22143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel abs(x) < 1.0 and e >= 0; return x and put e in *e. Here x is 22153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rounded to DBL_MANT_DIG significant bits using round-half-to-even. 22163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel If a == 0, return 0.0 and set *e = 0. If the resulting exponent 22173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel e is larger than PY_SSIZE_T_MAX, raise OverflowError and return 22183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel -1.0. */ 22193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* attempt to define 2.0**DBL_MANT_DIG as a compile-time constant */ 22213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#if DBL_MANT_DIG == 53 22223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define EXP2_DBL_MANT_DIG 9007199254740992.0 22233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#else 22243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define EXP2_DBL_MANT_DIG (ldexp(1.0, DBL_MANT_DIG)) 22253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif 22263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanieldouble 22283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel_PyLong_Frexp(PyLongObject *a, Py_ssize_t *e) 22293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 22303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t a_size, a_bits, shift_digits, shift_bits, x_size; 22313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* See below for why x_digits is always large enough. */ 22323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit rem, x_digits[2 + (DBL_MANT_DIG + 1) / PyLong_SHIFT]; 22333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel double dx; 22343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Correction term for round-half-to-even rounding. For a digit x, 22353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "x + half_even_correction[x & 7]" gives x rounded to the nearest 22363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel multiple of 4, rounding ties to a multiple of 8. */ 22373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel static const int half_even_correction[8] = {0, -1, -2, 1, 0, -1, 2, 1}; 22383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_size = ABS(Py_SIZE(a)); 22403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a_size == 0) { 22413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Special case for 0: significand 0.0, exponent 0. */ 22423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *e = 0; 22433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0.0; 22443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 22453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_bits = bits_in_digit(a->ob_digit[a_size-1]); 22463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* The following is an overflow-free version of the check 22473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "if ((a_size - 1) * PyLong_SHIFT + a_bits > PY_SSIZE_T_MAX) ..." */ 22483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a_size >= (PY_SSIZE_T_MAX - 1) / PyLong_SHIFT + 1 && 22493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (a_size > (PY_SSIZE_T_MAX - 1) / PyLong_SHIFT + 1 || 22503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_bits > (PY_SSIZE_T_MAX - 1) % PyLong_SHIFT + 1)) 22513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto overflow; 22523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_bits = (a_size - 1) * PyLong_SHIFT + a_bits; 22533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Shift the first DBL_MANT_DIG + 2 bits of a into x_digits[0:x_size] 22553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (shifting left if a_bits <= DBL_MANT_DIG + 2). 22563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Number of digits needed for result: write // for floor division. 22583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Then if shifting left, we end up using 22593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1 + a_size + (DBL_MANT_DIG + 2 - a_bits) // PyLong_SHIFT 22613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digits. If shifting right, we use 22633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_size - (a_bits - DBL_MANT_DIG - 2) // PyLong_SHIFT 22653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digits. Using a_size = 1 + (a_bits - 1) // PyLong_SHIFT along with 22673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel the inequalities 22683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel m // PyLong_SHIFT + n // PyLong_SHIFT <= (m + n) // PyLong_SHIFT 22703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel m // PyLong_SHIFT - n // PyLong_SHIFT <= 22713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1 + (m - n - 1) // PyLong_SHIFT, 22723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel valid for any integers m and n, we find that x_size satisfies 22743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_size <= 2 + (DBL_MANT_DIG + 1) // PyLong_SHIFT 22763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 22773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel in both cases. 22783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 22793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a_bits <= DBL_MANT_DIG + 2) { 22803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shift_digits = (DBL_MANT_DIG + 2 - a_bits) / PyLong_SHIFT; 22813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shift_bits = (DBL_MANT_DIG + 2 - a_bits) % PyLong_SHIFT; 22823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_size = 0; 22833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (x_size < shift_digits) 22843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_digits[x_size++] = 0; 22853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem = v_lshift(x_digits + x_size, a->ob_digit, a_size, 22863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (int)shift_bits); 22873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_size += a_size; 22883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_digits[x_size++] = rem; 22893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 22903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 22913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shift_digits = (a_bits - DBL_MANT_DIG - 2) / PyLong_SHIFT; 22923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shift_bits = (a_bits - DBL_MANT_DIG - 2) % PyLong_SHIFT; 22933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem = v_rshift(x_digits, a->ob_digit + shift_digits, 22943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_size - shift_digits, (int)shift_bits); 22953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_size = a_size - shift_digits; 22963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* For correct rounding below, we need the least significant 22973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bit of x to be 'sticky' for this shift: if any of the bits 22983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shifted out was nonzero, we set the least significant bit 22993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel of x. */ 23003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (rem) 23013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_digits[0] |= 1; 23023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 23033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (shift_digits > 0) 23043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a->ob_digit[--shift_digits]) { 23053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_digits[0] |= 1; 23063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 23073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 23083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 23093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(1 <= x_size && 23103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_size <= (Py_ssize_t)(sizeof(x_digits)/sizeof(digit))); 23113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Round, and convert to double. */ 23133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_digits[0] += half_even_correction[x_digits[0] & 7]; 23143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel dx = x_digits[--x_size]; 23153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (x_size > 0) 23163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel dx = dx * PyLong_BASE + x_digits[--x_size]; 23173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Rescale; make correction if result is 1.0. */ 23193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel dx /= 4.0 * EXP2_DBL_MANT_DIG; 23203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (dx == 1.0) { 23213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a_bits == PY_SSIZE_T_MAX) 23223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto overflow; 23233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel dx = 0.5; 23243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_bits += 1; 23253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 23263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *e = a_bits; 23283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return Py_SIZE(a) < 0 ? -dx : dx; 23293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel overflow: 23313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* exponent > PY_SSIZE_T_MAX */ 23323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 23333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "huge integer: number of bits overflows a Py_ssize_t"); 23343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *e = 0; 23353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1.0; 23363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 23373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Get a C double from a long int object. Rounds to the nearest double, 23393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel using the round-half-to-even rule in the case of a tie. */ 23403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanieldouble 23423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_AsDouble(PyObject *v) 23433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 23443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t exponent; 23453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel double x; 23463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (v == NULL || !PyLong_Check(v)) { 23483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadInternalCall(); 23493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1.0; 23503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 23513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = _PyLong_Frexp((PyLongObject *)v, &exponent); 23523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((x == -1.0 && PyErr_Occurred()) || exponent > DBL_MAX_EXP) { 23533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 23543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "long int too large to convert to float"); 23553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1.0; 23563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 23573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return ldexp(x, (int)exponent); 23583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 23593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Methods */ 23613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic void 23633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_dealloc(PyObject *v) 23643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 23653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_TYPE(v)->tp_free(v); 23663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 23673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 23693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_repr(PyObject *v) 23703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 23713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return _PyLong_Format(v, 10, 1, 0); 23723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 23733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 23753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_str(PyObject *v) 23763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 23773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return _PyLong_Format(v, 10, 0, 0); 23783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 23793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic int 23813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_compare(PyLongObject *a, PyLongObject *b) 23823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 23833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t sign; 23843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 23853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(a) != Py_SIZE(b)) { 23863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = Py_SIZE(a) - Py_SIZE(b); 23873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 23883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 23893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i = ABS(Py_SIZE(a)); 23903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i]) 23913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ; 23923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i < 0) 23933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = 0; 23943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 23953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = (sdigit)a->ob_digit[i] - (sdigit)b->ob_digit[i]; 23963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(a) < 0) 23973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = -sign; 23983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 23993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 24003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return sign < 0 ? -1 : sign > 0 ? 1 : 0; 24013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 24023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 24033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic long 24043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_hash(PyLongObject *v) 24053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 24063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel unsigned long x; 24073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 24083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int sign; 24093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 24103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* This is designed so that Python ints and longs with the 24113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel same value hash to the same value, otherwise comparisons 24123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel of mapping keys will turn out weird */ 24133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = v->ob_size; 24143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = 1; 24153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = 0; 24163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i < 0) { 24173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = -1; 24183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = -(i); 24193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 24203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* The following loop produces a C unsigned long x such that x is 24213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel congruent to the absolute value of v modulo ULONG_MAX. The 24223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel resulting x is nonzero if and only if v is. */ 24233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--i >= 0) { 24243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Force a native long #-bits (32 or 64) circular shift */ 24253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = (x >> (8*SIZEOF_LONG-PyLong_SHIFT)) | (x << PyLong_SHIFT); 24263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x += v->ob_digit[i]; 24273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* If the addition above overflowed we compensate by 24283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel incrementing. This preserves the value modulo 24293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ULONG_MAX. */ 24303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x < v->ob_digit[i]) 24313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x++; 24323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 24333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = x * sign; 24343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x == (unsigned long)-1) 24353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = (unsigned long)-2; 24363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (long)x; 24373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 24383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 24393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 24403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Add the absolute values of two long integers. */ 24413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 24423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyLongObject * 24433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielx_add(PyLongObject *a, PyLongObject *b) 24443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 24453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); 24463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z; 24473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 24483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit carry = 0; 24493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 24503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Ensure a is the larger of the two: */ 24513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (size_a < size_b) { 24523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel { PyLongObject *temp = a; a = b; b = temp; } 24533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel { Py_ssize_t size_temp = size_a; 24543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_a = size_b; 24553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_b = size_temp; } 24563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 24573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(size_a+1); 24583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 24593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 24603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < size_b; ++i) { 24613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry += a->ob_digit[i] + b->ob_digit[i]; 24623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = carry & PyLong_MASK; 24633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry >>= PyLong_SHIFT; 24643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 24653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (; i < size_a; ++i) { 24663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry += a->ob_digit[i]; 24673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = carry & PyLong_MASK; 24683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry >>= PyLong_SHIFT; 24693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 24703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = carry; 24713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_normalize(z); 24723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 24733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 24743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Subtract the absolute values of two integers. */ 24753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 24763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyLongObject * 24773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielx_sub(PyLongObject *a, PyLongObject *b) 24783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 24793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); 24803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z; 24813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 24823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int sign = 1; 24833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit borrow = 0; 24843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 24853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Ensure a is the larger of the two: */ 24863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (size_a < size_b) { 24873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = -1; 24883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel { PyLongObject *temp = a; a = b; b = temp; } 24893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel { Py_ssize_t size_temp = size_a; 24903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_a = size_b; 24913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_b = size_temp; } 24923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 24933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (size_a == size_b) { 24943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Find highest digit where a and b differ: */ 24953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = size_a; 24963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i]) 24973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ; 24983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i < 0) 24993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return _PyLong_New(0); 25003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a->ob_digit[i] < b->ob_digit[i]) { 25013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sign = -1; 25023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel { PyLongObject *temp = a; a = b; b = temp; } 25033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 25043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_a = size_b = i+1; 25053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 25063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(size_a); 25073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 25083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 25093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < size_b; ++i) { 25103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* The following assumes unsigned arithmetic 25113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel works module 2**N for some N>PyLong_SHIFT. */ 25123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow = a->ob_digit[i] - b->ob_digit[i] - borrow; 25133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = borrow & PyLong_MASK; 25143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow >>= PyLong_SHIFT; 25153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow &= 1; /* Keep only one sign bit */ 25163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 25173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (; i < size_a; ++i) { 25183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow = a->ob_digit[i] - borrow; 25193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = borrow & PyLong_MASK; 25203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow >>= PyLong_SHIFT; 25213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel borrow &= 1; /* Keep only one sign bit */ 25223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 25233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(borrow == 0); 25243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (sign < 0) 25253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_size = -(z->ob_size); 25263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_normalize(z); 25273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 25283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 25293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 25303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_add(PyLongObject *v, PyLongObject *w) 25313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 25323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b, *z; 25333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 25343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); 25353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 25363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a->ob_size < 0) { 25373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (b->ob_size < 0) { 25383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = x_add(a, b); 25393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z != NULL && z->ob_size != 0) 25403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_size = -(z->ob_size); 25413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 25423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 25433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = x_sub(b, a); 25443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 25453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 25463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (b->ob_size < 0) 25473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = x_sub(a, b); 25483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 25493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = x_add(a, b); 25503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 25513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 25523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 25533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)z; 25543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 25553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 25563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 25573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_sub(PyLongObject *v, PyLongObject *w) 25583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 25593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b, *z; 25603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 25613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); 25623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 25633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a->ob_size < 0) { 25643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (b->ob_size < 0) 25653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = x_sub(a, b); 25663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 25673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = x_add(a, b); 25683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z != NULL && z->ob_size != 0) 25693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_size = -(z->ob_size); 25703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 25713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 25723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (b->ob_size < 0) 25733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = x_add(a, b); 25743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 25753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = x_sub(a, b); 25763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 25773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 25783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 25793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)z; 25803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 25813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 25823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Grade school multiplication, ignoring the signs. 25833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * Returns the absolute value of the product, or NULL if error. 25843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 25853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyLongObject * 25863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielx_mul(PyLongObject *a, PyLongObject *b) 25873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 25883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z; 25893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size_a = ABS(Py_SIZE(a)); 25903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size_b = ABS(Py_SIZE(b)); 25913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 25923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 25933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(size_a + size_b); 25943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 25953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 25963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 25973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memset(z->ob_digit, 0, Py_SIZE(z) * sizeof(digit)); 25983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a == b) { 25993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Efficient squaring per HAC, Algorithm 14.16: 26003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf 26013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * Gives slightly less than a 2x speedup when a == b, 26023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * via exploiting that each entry in the multiplication 26033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * pyramid appears twice (except for the size_a squares). 26043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 26053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < size_a; ++i) { 26063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits carry; 26073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits f = a->ob_digit[i]; 26083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *pz = z->ob_digit + (i << 1); 26093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *pa = a->ob_digit + i + 1; 26103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *paend = a->ob_digit + size_a; 26113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 26123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel SIGCHECK({ 26133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(z); 26143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 26153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel }); 26163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 26173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry = *pz + f * f; 26183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pz++ = (digit)(carry & PyLong_MASK); 26193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry >>= PyLong_SHIFT; 26203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(carry <= PyLong_MASK); 26213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 26223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Now f is added in twice in each column of the 26233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * pyramid it appears. Same as adding f<<1 once. 26243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 26253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel f <<= 1; 26263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (pa < paend) { 26273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry += *pz + *pa++ * f; 26283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pz++ = (digit)(carry & PyLong_MASK); 26293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry >>= PyLong_SHIFT; 26303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(carry <= (PyLong_MASK << 1)); 26313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 26323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (carry) { 26333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry += *pz; 26343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pz++ = (digit)(carry & PyLong_MASK); 26353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry >>= PyLong_SHIFT; 26363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 26373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (carry) 26383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pz += (digit)(carry & PyLong_MASK); 26393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert((carry >> PyLong_SHIFT) == 0); 26403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 26413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 26423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { /* a is not the same as b -- gradeschool long mult */ 26433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < size_a; ++i) { 26443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits carry = 0; 26453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits f = a->ob_digit[i]; 26463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *pz = z->ob_digit + i; 26473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *pb = b->ob_digit; 26483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit *pbend = b->ob_digit + size_b; 26493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 26503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel SIGCHECK({ 26513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(z); 26523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 26533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel }); 26543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 26553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (pb < pbend) { 26563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry += *pz + *pb++ * f; 26573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pz++ = (digit)(carry & PyLong_MASK); 26583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry >>= PyLong_SHIFT; 26593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(carry <= PyLong_MASK); 26603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 26613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (carry) 26623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pz += (digit)(carry & PyLong_MASK); 26633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert((carry >> PyLong_SHIFT) == 0); 26643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 26653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 26663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_normalize(z); 26673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 26683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 26693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* A helper for Karatsuba multiplication (k_mul). 26703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Takes a long "n" and an integer "size" representing the place to 26713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel split, and sets low and high such that abs(n) == (high << size) + low, 26723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel viewing the shift as being by digits. The sign bit is ignored, and 26733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel the return values are >= 0. 26743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Returns 0 on success, -1 on failure. 26753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel*/ 26763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic int 26773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielkmul_split(PyLongObject *n, 26783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size, 26793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject **high, 26803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject **low) 26813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 26823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *hi, *lo; 26833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size_lo, size_hi; 26843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const Py_ssize_t size_n = ABS(Py_SIZE(n)); 26853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 26863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_lo = MIN(size_n, size); 26873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_hi = size_n - size_lo; 26883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 26893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((hi = _PyLong_New(size_hi)) == NULL) 26903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 26913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((lo = _PyLong_New(size_lo)) == NULL) { 26923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(hi); 26933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 26943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 26953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 26963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memcpy(lo->ob_digit, n->ob_digit, size_lo * sizeof(digit)); 26973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memcpy(hi->ob_digit, n->ob_digit + size_lo, size_hi * sizeof(digit)); 26983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 26993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *high = long_normalize(hi); 27003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *low = long_normalize(lo); 27013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0; 27023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 27033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 27043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyLongObject *k_lopsided_mul(PyLongObject *a, PyLongObject *b); 27053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 27063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Karatsuba multiplication. Ignores the input signs, and returns the 27073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * absolute value of the product (or NULL if error). 27083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * See Knuth Vol. 2 Chapter 4.3.3 (Pp. 294-295). 27093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 27103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyLongObject * 27113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielk_mul(PyLongObject *a, PyLongObject *b) 27123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 27133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t asize = ABS(Py_SIZE(a)); 27143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t bsize = ABS(Py_SIZE(b)); 27153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *ah = NULL; 27163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *al = NULL; 27173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *bh = NULL; 27183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *bl = NULL; 27193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *ret = NULL; 27203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *t1, *t2, *t3; 27213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t shift; /* the number of digits we split off */ 27223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 27233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 27243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* (ah*X+al)(bh*X+bl) = ah*bh*X*X + (ah*bl + al*bh)*X + al*bl 27253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * Let k = (ah+al)*(bh+bl) = ah*bl + al*bh + ah*bh + al*bl 27263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * Then the original product is 27273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * ah*bh*X*X + (k - ah*bh - al*bl)*X + al*bl 27283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * By picking X to be a power of 2, "*X" is just shifting, and it's 27293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * been reduced to 3 multiplies on numbers half the size. 27303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 27313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 27323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* We want to split based on the larger number; fiddle so that b 27333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * is largest. 27343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 27353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (asize > bsize) { 27363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t1 = a; 27373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a = b; 27383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel b = t1; 27393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 27403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = asize; 27413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel asize = bsize; 27423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bsize = i; 27433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 27443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 27453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Use gradeschool math when either number is too small. */ 27463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = a == b ? KARATSUBA_SQUARE_CUTOFF : KARATSUBA_CUTOFF; 27473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (asize <= i) { 27483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (asize == 0) 27493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return _PyLong_New(0); 27503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 27513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return x_mul(a, b); 27523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 27533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 27543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* If a is small compared to b, splitting on b gives a degenerate 27553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * case with ah==0, and Karatsuba may be (even much) less efficient 27563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * than "grade school" then. However, we can still win, by viewing 27573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * b as a string of "big digits", each of width a->ob_size. That 27583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * leads to a sequence of balanced calls to k_mul. 27593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 27603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (2 * asize <= bsize) 27613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return k_lopsided_mul(a, b); 27623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 27633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Split a & b into hi & lo pieces. */ 27643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shift = bsize >> 1; 27653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (kmul_split(a, shift, &ah, &al) < 0) goto fail; 27663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(Py_SIZE(ah) > 0); /* the split isn't degenerate */ 27673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 27683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a == b) { 27693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bh = ah; 27703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bl = al; 27713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(bh); 27723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(bl); 27733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 27743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (kmul_split(b, shift, &bh, &bl) < 0) goto fail; 27753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 27763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* The plan: 27773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * 1. Allocate result space (asize + bsize digits: that's always 27783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * enough). 27793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * 2. Compute ah*bh, and copy into result at 2*shift. 27803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * 3. Compute al*bl, and copy into result at 0. Note that this 27813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * can't overlap with #2. 27823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * 4. Subtract al*bl from the result, starting at shift. This may 27833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * underflow (borrow out of the high digit), but we don't care: 27843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * we're effectively doing unsigned arithmetic mod 27853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * PyLong_BASE**(sizea + sizeb), and so long as the *final* result fits, 27863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * borrows and carries out of the high digit can be ignored. 27873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * 5. Subtract ah*bh from the result, starting at shift. 27883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * 6. Compute (ah+al)*(bh+bl), and add it into the result starting 27893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * at shift. 27903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 27913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 27923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* 1. Allocate result space. */ 27933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ret = _PyLong_New(asize + bsize); 27943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (ret == NULL) goto fail; 27953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#ifdef Py_DEBUG 27963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Fill with trash, to catch reference to uninitialized digits. */ 27973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memset(ret->ob_digit, 0xDF, Py_SIZE(ret) * sizeof(digit)); 27983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif 27993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* 2. t1 <- ah*bh, and copy into high digits of result. */ 28013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((t1 = k_mul(ah, bh)) == NULL) goto fail; 28023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(Py_SIZE(t1) >= 0); 28033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(2*shift + Py_SIZE(t1) <= Py_SIZE(ret)); 28043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memcpy(ret->ob_digit + 2*shift, t1->ob_digit, 28053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(t1) * sizeof(digit)); 28063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Zero-out the digits higher than the ah*bh copy. */ 28083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = Py_SIZE(ret) - 2*shift - Py_SIZE(t1); 28093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i) 28103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memset(ret->ob_digit + 2*shift + Py_SIZE(t1), 0, 28113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i * sizeof(digit)); 28123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* 3. t2 <- al*bl, and copy into the low digits. */ 28143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((t2 = k_mul(al, bl)) == NULL) { 28153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(t1); 28163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto fail; 28173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 28183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(Py_SIZE(t2) >= 0); 28193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(Py_SIZE(t2) <= 2*shift); /* no overlap with high digits */ 28203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memcpy(ret->ob_digit, t2->ob_digit, Py_SIZE(t2) * sizeof(digit)); 28213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Zero out remaining digits. */ 28233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = 2*shift - Py_SIZE(t2); /* number of uninitialized digits */ 28243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i) 28253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memset(ret->ob_digit + Py_SIZE(t2), 0, i * sizeof(digit)); 28263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* 4 & 5. Subtract ah*bh (t1) and al*bl (t2). We do al*bl first 28283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * because it's fresher in cache. 28293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 28303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel i = Py_SIZE(ret) - shift; /* # digits after shift */ 28313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, Py_SIZE(t2)); 28323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(t2); 28333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, Py_SIZE(t1)); 28353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(t1); 28363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* 6. t3 <- (ah+al)(bh+bl), and add into result. */ 28383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((t1 = x_add(ah, al)) == NULL) goto fail; 28393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(ah); 28403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(al); 28413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ah = al = NULL; 28423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a == b) { 28443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t2 = t1; 28453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(t2); 28463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 28473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if ((t2 = x_add(bh, bl)) == NULL) { 28483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(t1); 28493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto fail; 28503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 28513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(bh); 28523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(bl); 28533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bh = bl = NULL; 28543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel t3 = k_mul(t1, t2); 28563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(t1); 28573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(t2); 28583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (t3 == NULL) goto fail; 28593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(Py_SIZE(t3) >= 0); 28603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Add t3. It's not obvious why we can't run out of room here. 28623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * See the (*) comment after this function. 28633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 28643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, Py_SIZE(t3)); 28653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(t3); 28663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_normalize(ret); 28683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel fail: 28703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(ret); 28713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(ah); 28723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(al); 28733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(bh); 28743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(bl); 28753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 28763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 28773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* (*) Why adding t3 can't "run out of room" above. 28793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielLet f(x) mean the floor of x and c(x) mean the ceiling of x. Some facts 28813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielto start with: 28823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel1. For any integer i, i = c(i/2) + f(i/2). In particular, 28843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bsize = c(bsize/2) + f(bsize/2). 28853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel2. shift = f(bsize/2) 28863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel3. asize <= bsize 28873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel4. Since we call k_lopsided_mul if asize*2 <= bsize, asize*2 > bsize in this 28883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel routine, so asize > bsize/2 >= f(bsize/2) in this routine. 28893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielWe allocated asize + bsize result digits, and add t3 into them at an offset 28913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielof shift. This leaves asize+bsize-shift allocated digit positions for t3 28923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielto fit into, = (by #1 and #2) asize + f(bsize/2) + c(bsize/2) - f(bsize/2) = 28933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielasize + c(bsize/2) available digit positions. 28943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielbh has c(bsize/2) digits, and bl at most f(size/2) digits. So bh+hl has 28963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielat most c(bsize/2) digits + 1 bit. 28973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 28983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielIf asize == bsize, ah has c(bsize/2) digits, else ah has at most f(bsize/2) 28993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanieldigits, and al has at most f(bsize/2) digits in any case. So ah+al has at 29003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielmost (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 1 bit. 29013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielThe product (ah+al)*(bh+bl) therefore has at most 29033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c(bsize/2) + (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 2 bits 29053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanieland we have asize + c(bsize/2) available digit positions. We need to show 29073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielthis is always enough. An instance of c(bsize/2) cancels out in both, so 29083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielthe question reduces to whether asize digits is enough to hold 29093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel(asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 2 bits. If asize < bsize, 29103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielthen we're asking whether asize digits >= f(bsize/2) digits + 2 bits. By #4, 29113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielasize is at least f(bsize/2)+1 digits, so this in turn reduces to whether 1 29123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanieldigit is enough to hold 2 bits. This is so since PyLong_SHIFT=15 >= 2. If 29133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielasize == bsize, then we're asking whether bsize digits is enough to hold 29143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielc(bsize/2) digits + 2 bits, or equivalently (by #1) whether f(bsize/2) digits 29153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielis enough to hold 2 bits. This is so if bsize >= 2, which holds because 29163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielbsize >= KARATSUBA_CUTOFF >= 2. 29173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielNote that since there's always enough room for (ah+al)*(bh+bl), and that's 29193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielclearly >= each of ah*bh and al*bl, there's always enough room to subtract 29203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielah*bh and al*bl too. 29213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel*/ 29223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* b has at least twice the digits of a, and a is big enough that Karatsuba 29243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * would pay off *if* the inputs had balanced sizes. View b as a sequence 29253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * of slices, each with a->ob_size digits, and multiply the slices by a, 29263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * one at a time. This gives k_mul balanced inputs to work with, and is 29273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * also cache-friendly (we compute one double-width slice of the result 29283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * at a time, then move on, never backtracking except for the helpful 29293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * single-width slice overlap between successive partial sums). 29303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 29313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyLongObject * 29323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielk_lopsided_mul(PyLongObject *a, PyLongObject *b) 29333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 29343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const Py_ssize_t asize = ABS(Py_SIZE(a)); 29353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t bsize = ABS(Py_SIZE(b)); 29363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t nbdone; /* # of b digits already multiplied */ 29373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *ret; 29383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *bslice = NULL; 29393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(asize > KARATSUBA_CUTOFF); 29413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(2 * asize <= bsize); 29423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Allocate result space, and zero it out. */ 29443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ret = _PyLong_New(asize + bsize); 29453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (ret == NULL) 29463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 29473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memset(ret->ob_digit, 0, Py_SIZE(ret) * sizeof(digit)); 29483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Successive slices of b are copied into bslice. */ 29503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bslice = _PyLong_New(asize); 29513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (bslice == NULL) 29523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto fail; 29533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel nbdone = 0; 29553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (bsize > 0) { 29563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *product; 29573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const Py_ssize_t nbtouse = MIN(bsize, asize); 29583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Multiply the next slice of b by a. */ 29603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memcpy(bslice->ob_digit, b->ob_digit + nbdone, 29613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel nbtouse * sizeof(digit)); 29623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(bslice) = nbtouse; 29633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel product = k_mul(a, bslice); 29643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (product == NULL) 29653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto fail; 29663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Add into result. */ 29683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (void)v_iadd(ret->ob_digit + nbdone, Py_SIZE(ret) - nbdone, 29693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel product->ob_digit, Py_SIZE(product)); 29703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(product); 29713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bsize -= nbtouse; 29733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel nbdone += nbtouse; 29743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 29753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(bslice); 29773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_normalize(ret); 29783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel fail: 29803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(ret); 29813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(bslice); 29823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 29833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 29843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 29863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_mul(PyLongObject *v, PyLongObject *w) 29873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 29883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b, *z; 29893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (!convert_binop((PyObject *)v, (PyObject *)w, &a, &b)) { 29913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(Py_NotImplemented); 29923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return Py_NotImplemented; 29933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 29943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 29953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = k_mul(a, b); 29963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Negate if exactly one of the inputs is negative. */ 29973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (((a->ob_size ^ b->ob_size) < 0) && z) 29983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_size = -(z->ob_size); 29993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 30003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 30013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)z; 30023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 30033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 30043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* The / and % operators are now defined in terms of divmod(). 30053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel The expression a mod b has the value a - b*floor(a/b). 30063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel The long_divrem function gives the remainder after division of 30073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel |a| by |b|, with the sign of a. This is also expressed 30083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel as a - b*trunc(a/b), if trunc truncates towards zero. 30093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Some examples: 30103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a b a rem b a mod b 30113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13 10 3 3 30123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel -13 10 -3 7 30133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 13 -10 3 -7 30143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel -13 -10 -3 -3 30153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel So, to get from rem to mod, we have to add b if a and b 30163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel have different signs. We then subtract one from the 'div' 30173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel part of the outcome to keep the invariant intact. */ 30183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 30193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Compute 30203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * *pdiv, *pmod = divmod(v, w) 30213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * NULL can be passed for pdiv or pmod, in which case that part of 30223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * the result is simply thrown away. The caller owns a reference to 30233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * each of these it requests (does not pass NULL for). 30243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 30253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic int 30263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniell_divmod(PyLongObject *v, PyLongObject *w, 30273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject **pdiv, PyLongObject **pmod) 30283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 30293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *div, *mod; 30303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 30313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (long_divrem(v, w, &div, &mod) < 0) 30323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 30333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((Py_SIZE(mod) < 0 && Py_SIZE(w) > 0) || 30343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (Py_SIZE(mod) > 0 && Py_SIZE(w) < 0)) { 30353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *temp; 30363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *one; 30373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel temp = (PyLongObject *) long_add(mod, w); 30383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(mod); 30393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel mod = temp; 30403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (mod == NULL) { 30413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(div); 30423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 30433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 30443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel one = (PyLongObject *) PyLong_FromLong(1L); 30453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (one == NULL || 30463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (temp = (PyLongObject *) long_sub(div, one)) == NULL) { 30473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(mod); 30483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(div); 30493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(one); 30503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 30513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 30523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(one); 30533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(div); 30543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel div = temp; 30553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 30563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (pdiv != NULL) 30573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pdiv = div; 30583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 30593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(div); 30603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 30613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (pmod != NULL) 30623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pmod = mod; 30633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 30643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(mod); 30653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 30663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0; 30673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 30683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 30693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 30703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_div(PyObject *v, PyObject *w) 30713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 30723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b, *div; 30733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 30743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP(v, w, &a, &b); 30753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (l_divmod(a, b, &div, NULL) < 0) 30763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel div = NULL; 30773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 30783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 30793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)div; 30803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 30813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 30823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 30833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_classic_div(PyObject *v, PyObject *w) 30843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 30853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b, *div; 30863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 30873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP(v, w, &a, &b); 30883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_DivisionWarningFlag && 30893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_Warn(PyExc_DeprecationWarning, "classic long division") < 0) 30903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel div = NULL; 30913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (l_divmod(a, b, &div, NULL) < 0) 30923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel div = NULL; 30933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 30943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 30953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)div; 30963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 30973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 30983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* PyLong/PyLong -> float, with correctly rounded result. */ 30993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define MANT_DIG_DIGITS (DBL_MANT_DIG / PyLong_SHIFT) 31013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define MANT_DIG_BITS (DBL_MANT_DIG % PyLong_SHIFT) 31023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 31043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_true_divide(PyObject *v, PyObject *w) 31053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 31063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b, *x; 31073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t a_size, b_size, shift, extra_bits, diff, x_size, x_bits; 31083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit mask, low; 31093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int inexact, negate, a_is_small, b_is_small; 31103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel double dx, result; 31113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP(v, w, &a, &b); 31133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* 31153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Method in a nutshell: 31163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0. reduce to case a, b > 0; filter out obvious underflow/overflow 31183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1. choose a suitable integer 'shift' 31193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2. use integer arithmetic to compute x = floor(2**-shift*a/b) 31203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 3. adjust x for correct rounding 31213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 4. convert x to a double dx with the same value 31223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5. return ldexp(dx, shift). 31233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel In more detail: 31253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0. For any a, a/0 raises ZeroDivisionError; for nonzero b, 0/b 31273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel returns either 0.0 or -0.0, depending on the sign of b. For a and 31283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel b both nonzero, ignore signs of a and b, and add the sign back in 31293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel at the end. Now write a_bits and b_bits for the bit lengths of a 31303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel and b respectively (that is, a_bits = 1 + floor(log_2(a)); likewise 31313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for b). Then 31323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2**(a_bits - b_bits - 1) < a/b < 2**(a_bits - b_bits + 1). 31343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel So if a_bits - b_bits > DBL_MAX_EXP then a/b > 2**DBL_MAX_EXP and 31363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel so overflows. Similarly, if a_bits - b_bits < DBL_MIN_EXP - 31373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel DBL_MANT_DIG - 1 then a/b underflows to 0. With these cases out of 31383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel the way, we can assume that 31393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel DBL_MIN_EXP - DBL_MANT_DIG - 1 <= a_bits - b_bits <= DBL_MAX_EXP. 31413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1. The integer 'shift' is chosen so that x has the right number of 31433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bits for a double, plus two or three extra bits that will be used 31443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel in the rounding decisions. Writing a_bits and b_bits for the 31453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel number of significant bits in a and b respectively, a 31463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel straightforward formula for shift is: 31473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shift = a_bits - b_bits - DBL_MANT_DIG - 2 31493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel This is fine in the usual case, but if a/b is smaller than the 31513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel smallest normal float then it can lead to double rounding on an 31523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel IEEE 754 platform, giving incorrectly rounded results. So we 31533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel adjust the formula slightly. The actual formula used is: 31543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shift = MAX(a_bits - b_bits, DBL_MIN_EXP) - DBL_MANT_DIG - 2 31563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2. The quantity x is computed by first shifting a (left -shift bits 31583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if shift <= 0, right shift bits if shift > 0) and then dividing by 31593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel b. For both the shift and the division, we keep track of whether 31603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel the result is inexact, in a flag 'inexact'; this information is 31613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel needed at the rounding stage. 31623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel With the choice of shift above, together with our assumption that 31643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_bits - b_bits >= DBL_MIN_EXP - DBL_MANT_DIG - 1, it follows 31653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel that x >= 1. 31663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 3. Now x * 2**shift <= a/b < (x+1) * 2**shift. We want to replace 31683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel this with an exactly representable float of the form 31693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel round(x/2**extra_bits) * 2**(extra_bits+shift). 31713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel For float representability, we need x/2**extra_bits < 31733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2**DBL_MANT_DIG and extra_bits + shift >= DBL_MIN_EXP - 31743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel DBL_MANT_DIG. This translates to the condition: 31753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel extra_bits >= MAX(x_bits, DBL_MIN_EXP - shift) - DBL_MANT_DIG 31773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel To round, we just modify the bottom digit of x in-place; this can 31793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel end up giving a digit with value > PyLONG_MASK, but that's not a 31803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel problem since digits can hold values up to 2*PyLONG_MASK+1. 31813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel With the original choices for shift above, extra_bits will always 31833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel be 2 or 3. Then rounding under the round-half-to-even rule, we 31843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel round up iff the most significant of the extra bits is 1, and 31853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel either: (a) the computation of x in step 2 had an inexact result, 31863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel or (b) at least one other of the extra bits is 1, or (c) the least 31873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel significant bit of x (above those to be rounded) is 1. 31883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 4. Conversion to a double is straightforward; all floating-point 31903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel operations involved in the conversion are exact, so there's no 31913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel danger of rounding errors. 31923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 31933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 5. Use ldexp(x, shift) to compute x*2**shift, the final result. 31943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel The result will always be exactly representable as a double, except 31953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel in the case that it overflows. To avoid dependence on the exact 31963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel behaviour of ldexp on overflow, we check for overflow before 31973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel applying ldexp. The result of ldexp is adjusted for sign before 31983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel returning. 31993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 32003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 32013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Reduce to case where a and b are both positive. */ 32023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_size = ABS(Py_SIZE(a)); 32033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel b_size = ABS(Py_SIZE(b)); 32043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negate = (Py_SIZE(a) < 0) ^ (Py_SIZE(b) < 0); 32053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (b_size == 0) { 32063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_ZeroDivisionError, 32073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "division by zero"); 32083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto error; 32093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 32103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a_size == 0) 32113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto underflow_or_zero; 32123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 32133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Fast path for a and b small (exactly representable in a double). 32143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Relies on floating-point division being correctly rounded; results 32153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel may be subject to double rounding on x86 machines that operate with 32163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel the x87 FPU set to 64-bit precision. */ 32173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_is_small = a_size <= MANT_DIG_DIGITS || 32183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (a_size == MANT_DIG_DIGITS+1 && 32193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a->ob_digit[MANT_DIG_DIGITS] >> MANT_DIG_BITS == 0); 32203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel b_is_small = b_size <= MANT_DIG_DIGITS || 32213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (b_size == MANT_DIG_DIGITS+1 && 32223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel b->ob_digit[MANT_DIG_DIGITS] >> MANT_DIG_BITS == 0); 32233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a_is_small && b_is_small) { 32243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel double da, db; 32253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel da = a->ob_digit[--a_size]; 32263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (a_size > 0) 32273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel da = da * PyLong_BASE + a->ob_digit[--a_size]; 32283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel db = b->ob_digit[--b_size]; 32293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (b_size > 0) 32303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel db = db * PyLong_BASE + b->ob_digit[--b_size]; 32313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = da / db; 32323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto success; 32333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 32343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 32353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Catch obvious cases of underflow and overflow */ 32363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel diff = a_size - b_size; 32373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (diff > PY_SSIZE_T_MAX/PyLong_SHIFT - 1) 32383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Extreme overflow */ 32393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto overflow; 32403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (diff < 1 - PY_SSIZE_T_MAX/PyLong_SHIFT) 32413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Extreme underflow */ 32423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto underflow_or_zero; 32433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Next line is now safe from overflowing a Py_ssize_t */ 32443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel diff = diff * PyLong_SHIFT + bits_in_digit(a->ob_digit[a_size - 1]) - 32453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel bits_in_digit(b->ob_digit[b_size - 1]); 32463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Now diff = a_bits - b_bits. */ 32473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (diff > DBL_MAX_EXP) 32483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto overflow; 32493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (diff < DBL_MIN_EXP - DBL_MANT_DIG - 1) 32503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto underflow_or_zero; 32513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 32523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Choose value for shift; see comments for step 1 above. */ 32533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shift = MAX(diff, DBL_MIN_EXP) - DBL_MANT_DIG - 2; 32543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 32553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel inexact = 0; 32563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 32573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* x = abs(a * 2**-shift) */ 32583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (shift <= 0) { 32593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i, shift_digits = -shift / PyLong_SHIFT; 32603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit rem; 32613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* x = a << -shift */ 32623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a_size >= PY_SSIZE_T_MAX - 1 - shift_digits) { 32633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* In practice, it's probably impossible to end up 32643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel here. Both a and b would have to be enormous, 32653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel using close to SIZE_T_MAX bytes of memory each. */ 32663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 32673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "intermediate overflow during division"); 32683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto error; 32693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 32703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = _PyLong_New(a_size + shift_digits + 1); 32713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x == NULL) 32723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto error; 32733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < shift_digits; i++) 32743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x->ob_digit[i] = 0; 32753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem = v_lshift(x->ob_digit + shift_digits, a->ob_digit, 32763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_size, -shift % PyLong_SHIFT); 32773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x->ob_digit[a_size + shift_digits] = rem; 32783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 32793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 32803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t shift_digits = shift / PyLong_SHIFT; 32813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit rem; 32823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* x = a >> shift */ 32833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(a_size >= shift_digits); 32843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = _PyLong_New(a_size - shift_digits); 32853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x == NULL) 32863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto error; 32873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rem = v_rshift(x->ob_digit, a->ob_digit + shift_digits, 32883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a_size - shift_digits, shift % PyLong_SHIFT); 32893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* set inexact if any of the bits shifted out is nonzero */ 32903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (rem) 32913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel inexact = 1; 32923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (!inexact && shift_digits > 0) 32933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a->ob_digit[--shift_digits]) 32943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel inexact = 1; 32953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 32963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_normalize(x); 32973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_size = Py_SIZE(x); 32983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 32993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* x //= b. If the remainder is nonzero, set inexact. We own the only 33003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel reference to x, so it's safe to modify it in-place. */ 33013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (b_size == 1) { 33023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit rem = inplace_divrem1(x->ob_digit, x->ob_digit, x_size, 33033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel b->ob_digit[0]); 33043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_normalize(x); 33053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (rem) 33063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel inexact = 1; 33073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 33083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 33093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *div, *rem; 33103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel div = x_divrem(x, b, &rem); 33113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(x); 33123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = div; 33133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x == NULL) 33143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto error; 33153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(rem)) 33163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel inexact = 1; 33173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(rem); 33183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 33193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_size = ABS(Py_SIZE(x)); 33203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(x_size > 0); /* result of division is never zero */ 33213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x_bits = (x_size-1)*PyLong_SHIFT+bits_in_digit(x->ob_digit[x_size-1]); 33223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* The number of extra bits that have to be rounded away. */ 33243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel extra_bits = MAX(x_bits, DBL_MIN_EXP - shift) - DBL_MANT_DIG; 33253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(extra_bits == 2 || extra_bits == 3); 33263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Round by directly modifying the low digit of x. */ 33283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel mask = (digit)1 << (extra_bits - 1); 33293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel low = x->ob_digit[0] | inexact; 33303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (low & mask && low & (3*mask-1)) 33313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel low += mask; 33323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x->ob_digit[0] = low & ~(mask-1U); 33333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Convert x to a double dx; the conversion is exact. */ 33353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel dx = x->ob_digit[--x_size]; 33363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (x_size > 0) 33373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel dx = dx * PyLong_BASE + x->ob_digit[--x_size]; 33383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(x); 33393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Check whether ldexp result will overflow a double. */ 33413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (shift + x_bits >= DBL_MAX_EXP && 33423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (shift + x_bits > DBL_MAX_EXP || dx == ldexp(1.0, (int)x_bits))) 33433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto overflow; 33443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = ldexp(dx, (int)shift); 33453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel success: 33473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 33483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 33493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyFloat_FromDouble(negate ? -result : result); 33503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel underflow_or_zero: 33523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 33533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 33543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyFloat_FromDouble(negate ? -0.0 : 0.0); 33553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel overflow: 33573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_OverflowError, 33583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "integer division result too large for a float"); 33593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel error: 33603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 33613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 33623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 33633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 33643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 33663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_mod(PyObject *v, PyObject *w) 33673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 33683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b, *mod; 33693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP(v, w, &a, &b); 33713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (l_divmod(a, b, NULL, &mod) < 0) 33733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel mod = NULL; 33743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 33753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 33763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)mod; 33773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 33783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 33803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_divmod(PyObject *v, PyObject *w) 33813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 33823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b, *div, *mod; 33833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *z; 33843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP(v, w, &a, &b); 33863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 33873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (l_divmod(a, b, &div, &mod) < 0) { 33883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 33893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 33903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 33913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 33923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = PyTuple_New(2); 33933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z != NULL) { 33943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyTuple_SetItem(z, 0, (PyObject *) div); 33953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyTuple_SetItem(z, 1, (PyObject *) mod); 33963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 33973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 33983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(div); 33993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(mod); 34003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 34013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 34023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 34033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return z; 34043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 34053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 34063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* pow(v, w, x) */ 34073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 34083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_pow(PyObject *v, PyObject *w, PyObject *x) 34093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 34103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b, *c; /* a,b,c = v,w,x */ 34113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int negativeOutput = 0; /* if x<0 return negative output */ 34123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 34133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z = NULL; /* accumulated result */ 34143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i, j, k; /* counters */ 34153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *temp = NULL; 34163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 34173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* 5-ary values. If the exponent is large enough, table is 34183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * precomputed so that table[i] == a**i % c for i in range(32). 34193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 34203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *table[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 34213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 34223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 34233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* a, b, c = v, w, x */ 34243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP(v, w, &a, &b); 34253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyLong_Check(x)) { 34263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c = (PyLongObject *)x; 34273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(x); 34283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 34293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (PyInt_Check(x)) { 34303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c = (PyLongObject *)PyLong_FromLong(PyInt_AS_LONG(x)); 34313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (c == NULL) 34323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Error; 34333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 34343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (x == Py_None) 34353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c = NULL; 34363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 34373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 34383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 34393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(Py_NotImplemented); 34403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return Py_NotImplemented; 34413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 34423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 34433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(b) < 0) { /* if exponent is negative */ 34443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (c) { 34453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_TypeError, "pow() 2nd argument " 34463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "cannot be negative when 3rd argument specified"); 34473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Error; 34483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 34493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 34503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* else return a float. This works because we know 34513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel that this calls float_pow() which converts its 34523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel arguments to double. */ 34533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 34543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 34553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyFloat_Type.tp_as_number->nb_power(v, w, x); 34563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 34573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 34583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 34593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (c) { 34603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* if modulus == 0: 34613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel raise ValueError() */ 34623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(c) == 0) { 34633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_ValueError, 34643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "pow() 3rd argument cannot be 0"); 34653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Error; 34663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 34673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 34683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* if modulus < 0: 34693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negativeOutput = True 34703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel modulus = -modulus */ 34713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(c) < 0) { 34723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negativeOutput = 1; 34733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel temp = (PyLongObject *)_PyLong_Copy(c); 34743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (temp == NULL) 34753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Error; 34763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(c); 34773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c = temp; 34783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel temp = NULL; 34793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c->ob_size = - c->ob_size; 34803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 34813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 34823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* if modulus == 1: 34833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0 */ 34843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if ((Py_SIZE(c) == 1) && (c->ob_digit[0] == 1)) { 34853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = (PyLongObject *)PyLong_FromLong(0L); 34863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Done; 34873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 34883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 34893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Reduce base by modulus in some cases: 34903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 1. If base < 0. Forcing the base non-negative makes things easier. 34913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2. If base is obviously larger than the modulus. The "small 34923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel exponent" case later can multiply directly by base repeatedly, 34933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while the "large exponent" case multiplies directly by base 31 34943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel times. It can be unboundedly faster to multiply by 34953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base % modulus instead. 34963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel We could _always_ do this reduction, but l_divmod() isn't cheap, 34973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel so we only do it when it buys something. */ 34983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(a) < 0 || Py_SIZE(a) > Py_SIZE(c)) { 34993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (l_divmod(a, c, NULL, &temp) < 0) 35003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Error; 35013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 35023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a = temp; 35033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel temp = NULL; 35043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 35053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 35063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 35073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* At this point a, b, and c are guaranteed non-negative UNLESS 35083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c is NULL, in which case a may be negative. */ 35093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 35103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = (PyLongObject *)PyLong_FromLong(1L); 35113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 35123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Error; 35133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 35143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Perform a modular reduction, X = X % c, but leave X alone if c 35153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * is NULL. 35163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 35173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define REDUCE(X) \ 35183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do { \ 35193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (c != NULL) { \ 35203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (l_divmod(X, c, NULL, &temp) < 0) \ 35213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Error; \ 35223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(X); \ 35233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel X = temp; \ 35243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel temp = NULL; \ 35253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } \ 35263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } while(0) 35273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 35283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Multiply two values, then reduce the result: 35293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = X*Y % c. If c is NULL, skip the mod. */ 35303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#define MULT(X, Y, result) \ 35313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel do { \ 35323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel temp = (PyLongObject *)long_mul(X, Y); \ 35333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (temp == NULL) \ 35343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Error; \ 35353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(result); \ 35363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = temp; \ 35373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel temp = NULL; \ 35383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel REDUCE(result); \ 35393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } while(0) 35403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 35413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(b) <= FIVEARY_CUTOFF) { 35423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Left-to-right binary exponentiation (HAC Algorithm 14.79) */ 35433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf */ 35443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = Py_SIZE(b) - 1; i >= 0; --i) { 35453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit bi = b->ob_digit[i]; 35463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 35473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (j = (digit)1 << (PyLong_SHIFT-1); j != 0; j >>= 1) { 35483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel MULT(z, z, z); 35493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (bi & j) 35503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel MULT(z, a, z); 35513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 35523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 35533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 35543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 35553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Left-to-right 5-ary exponentiation (HAC Algorithm 14.82) */ 35563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(z); /* still holds 1L */ 35573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel table[0] = z; 35583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 1; i < 32; ++i) 35593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel MULT(table[i-1], a, table[i]); 35603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 35613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = Py_SIZE(b) - 1; i >= 0; --i) { 35623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const digit bi = b->ob_digit[i]; 35633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 35643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (j = PyLong_SHIFT - 5; j >= 0; j -= 5) { 35653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel const int index = (bi >> j) & 0x1f; 35663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (k = 0; k < 5; ++k) 35673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel MULT(z, z, z); 35683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (index) 35693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel MULT(z, table[index], z); 35703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 35713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 35723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 35733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 35743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (negativeOutput && (Py_SIZE(z) != 0)) { 35753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel temp = (PyLongObject *)long_sub(z, c); 35763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (temp == NULL) 35773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Error; 35783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(z); 35793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = temp; 35803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel temp = NULL; 35813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 35823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto Done; 35833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 35843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Error: 35853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z != NULL) { 35863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(z); 35873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = NULL; 35883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 35893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* fall through */ 35903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Done: 35913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(b) > FIVEARY_CUTOFF) { 35923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < 32; ++i) 35933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(table[i]); 35943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 35953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 35963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 35973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(c); 35983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_XDECREF(temp); 35993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)z; 36003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 36013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 36023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 36033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_invert(PyLongObject *v) 36043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 36053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Implement ~x as -(x+1) */ 36063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *x; 36073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *w; 36083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel w = (PyLongObject *)PyLong_FromLong(1L); 36093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (w == NULL) 36103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 36113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = (PyLongObject *) long_add(v, w); 36123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(w); 36133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x == NULL) 36143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 36153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(x) = -(Py_SIZE(x)); 36163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)x; 36173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 36183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 36193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 36203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_neg(PyLongObject *v) 36213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 36223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z; 36233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (v->ob_size == 0 && PyLong_CheckExact(v)) { 36243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* -0 == 0 */ 36253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(v); 36263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *) v; 36273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 36283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = (PyLongObject *)_PyLong_Copy(v); 36293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z != NULL) 36303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_size = -(v->ob_size); 36313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)z; 36323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 36333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 36343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 36353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_abs(PyLongObject *v) 36363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 36373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (v->ob_size < 0) 36383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_neg(v); 36393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 36403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_long((PyObject *)v); 36413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 36423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 36433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic int 36443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_nonzero(PyLongObject *v) 36453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 36463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return Py_SIZE(v) != 0; 36473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 36483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 36493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 36503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_rshift(PyLongObject *v, PyLongObject *w) 36513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 36523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b; 36533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z = NULL; 36543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t shiftby, newsize, wordshift, loshift, hishift, i, j; 36553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit lomask, himask; 36563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 36573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); 36583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 36593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(a) < 0) { 36603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Right shifting negative numbers is harder */ 36613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a1, *a2; 36623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a1 = (PyLongObject *) long_invert(a); 36633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a1 == NULL) 36643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto rshift_error; 36653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a2 = (PyLongObject *) long_rshift(a1, b); 36663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a1); 36673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a2 == NULL) 36683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto rshift_error; 36693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = (PyLongObject *) long_invert(a2); 36703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a2); 36713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 36723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 36733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shiftby = PyLong_AsSsize_t((PyObject *)b); 36743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (shiftby == -1L && PyErr_Occurred()) 36753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto rshift_error; 36763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (shiftby < 0) { 36773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_ValueError, 36783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "negative shift count"); 36793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto rshift_error; 36803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 36813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel wordshift = shiftby / PyLong_SHIFT; 36823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel newsize = ABS(Py_SIZE(a)) - wordshift; 36833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (newsize <= 0) { 36843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(0); 36853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 36863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 36873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)z; 36883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 36893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel loshift = shiftby % PyLong_SHIFT; 36903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel hishift = PyLong_SHIFT - loshift; 36913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel lomask = ((digit)1 << hishift) - 1; 36923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel himask = PyLong_MASK ^ lomask; 36933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(newsize); 36943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 36953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto rshift_error; 36963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Py_SIZE(a) < 0) 36973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(z) = -(Py_SIZE(z)); 36983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0, j = wordshift; i < newsize; i++, j++) { 36993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = (a->ob_digit[j] >> loshift) & lomask; 37003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (i+1 < newsize) 37013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] |= (a->ob_digit[j+1] << hishift) & himask; 37023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 37033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = long_normalize(z); 37043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 37053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel rshift_error: 37063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 37073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 37083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *) z; 37093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 37113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 37133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_lshift(PyObject *v, PyObject *w) 37143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 37153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* This version due to Tim Peters */ 37163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b; 37173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z = NULL; 37183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t shiftby, oldsize, newsize, wordshift, remshift, i, j; 37193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel twodigits accum; 37203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP(v, w, &a, &b); 37223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel shiftby = PyLong_AsSsize_t((PyObject *)b); 37243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (shiftby == -1L && PyErr_Occurred()) 37253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto lshift_error; 37263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (shiftby < 0) { 37273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_ValueError, "negative shift count"); 37283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto lshift_error; 37293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 37303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* wordshift, remshift = divmod(shiftby, PyLong_SHIFT) */ 37313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel wordshift = shiftby / PyLong_SHIFT; 37323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel remshift = shiftby - wordshift * PyLong_SHIFT; 37333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel oldsize = ABS(a->ob_size); 37353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel newsize = oldsize + wordshift; 37363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (remshift) 37373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ++newsize; 37383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(newsize); 37393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 37403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto lshift_error; 37413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (a->ob_size < 0) 37423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_size = -(z->ob_size); 37433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < wordshift; i++) 37443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = 0; 37453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum = 0; 37463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = wordshift, j = 0; j < oldsize; i++, j++) { 37473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum |= (twodigits)a->ob_digit[j] << remshift; 37483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = (digit)(accum & PyLong_MASK); 37493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel accum >>= PyLong_SHIFT; 37503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 37513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (remshift) 37523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[newsize-1] = (digit)accum; 37533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 37543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(!accum); 37553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = long_normalize(z); 37563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel lshift_error: 37573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 37583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 37593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *) z; 37603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 37613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Compute two's complement of digit vector a[0:m], writing result to 37633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z[0:m]. The digit vector a need not be normalized, but should not 37643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel be entirely zero. a and z may point to the same digit vector. */ 37653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic void 37673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielv_complement(digit *z, digit *a, Py_ssize_t m) 37683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 37693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i; 37703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit carry = 1; 37713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < m; ++i) { 37723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry += a[i] ^ PyLong_MASK; 37733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z[i] = carry & PyLong_MASK; 37743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel carry >>= PyLong_SHIFT; 37753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 37763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(carry == 0); 37773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 37783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Bitwise and/xor/or operations */ 37803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 37823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_bitwise(PyLongObject *a, 37833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int op, /* '&', '|', '^' */ 37843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *b) 37853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 37863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int nega, negb, negz; 37873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t size_a, size_b, size_z, i; 37883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *z; 37893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Bitwise operations for negative numbers operate as though 37913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel on a two's complement representation. So convert arguments 37923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel from sign-magnitude to two's complement, and convert the 37933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result back to sign-magnitude at the end. */ 37943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 37953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* If a is negative, replace it by its two's complement. */ 37963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_a = ABS(Py_SIZE(a)); 37973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel nega = Py_SIZE(a) < 0; 37983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (nega) { 37993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(size_a); 38003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) 38013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 38023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v_complement(z->ob_digit, a->ob_digit, size_a); 38033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel a = z; 38043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 38053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 38063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Keep reference count consistent. */ 38073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(a); 38083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 38093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Same for b. */ 38103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_b = ABS(Py_SIZE(b)); 38113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negb = Py_SIZE(b) < 0; 38123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (negb) { 38133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(size_b); 38143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) { 38153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 38163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 38173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 38183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v_complement(z->ob_digit, b->ob_digit, size_b); 38193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel b = z; 38203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 38213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 38223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(b); 38233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 38243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Swap a and b if necessary to ensure size_a >= size_b. */ 38253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (size_a < size_b) { 38263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = a; a = b; b = z; 38273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_z = size_a; size_a = size_b; size_b = size_z; 38283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negz = nega; nega = negb; negb = negz; 38293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 38303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 38313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* JRH: The original logic here was to allocate the result value (z) 38323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel as the longer of the two operands. However, there are some cases 38333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel where the result is guaranteed to be shorter than that: AND of two 38343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel positives, OR of two negatives: use the shorter number. AND with 38353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel mixed signs: use the positive number. OR with mixed signs: use the 38363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negative number. 38373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel */ 38383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel switch (op) { 38393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case '^': 38403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negz = nega ^ negb; 38413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_z = size_a; 38423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 38433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case '&': 38443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negz = nega & negb; 38453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_z = negb ? size_a : size_b; 38463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 38473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case '|': 38483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel negz = nega | negb; 38493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel size_z = negb ? size_b : size_a; 38503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 38513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel default: 38523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadArgument(); 38533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 38543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 38553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 38563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* We allow an extra digit if z is negative, to make sure that 38573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel the final two's complement of z doesn't overflow. */ 38583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z = _PyLong_New(size_z + negz); 38593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (z == NULL) { 38603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 38613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 38623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 38633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 38643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 38653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Compute digits for overlap of a and b. */ 38663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel switch(op) { 38673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case '&': 38683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < size_b; ++i) 38693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = a->ob_digit[i] & b->ob_digit[i]; 38703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 38713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case '|': 38723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < size_b; ++i) 38733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = a->ob_digit[i] | b->ob_digit[i]; 38743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 38753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel case '^': 38763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < size_b; ++i) 38773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = a->ob_digit[i] ^ b->ob_digit[i]; 38783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel break; 38793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel default: 38803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_BadArgument(); 38813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 38823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 38833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 38843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Copy any remaining digits of a, inverting if necessary. */ 38853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (op == '^' && negb) 38863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (; i < size_z; ++i) 38873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[i] = a->ob_digit[i] ^ PyLong_MASK; 38883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (i < size_z) 38893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel memcpy(&z->ob_digit[i], &a->ob_digit[i], 38903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (size_z-i)*sizeof(digit)); 38913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 38923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Complement result if negative. */ 38933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (negz) { 38943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(z) = -(Py_SIZE(z)); 38953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel z->ob_digit[size_z] = PyLong_MASK; 38963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v_complement(z->ob_digit, z->ob_digit, size_z+1); 38973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 38983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 38993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 39003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 39013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)long_normalize(z); 39023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 39033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 39043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 39053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_and(PyObject *v, PyObject *w) 39063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 39073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b; 39083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *c; 39093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP(v, w, &a, &b); 39103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c = long_bitwise(a, '&', b); 39113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 39123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 39133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return c; 39143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 39153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 39163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 39173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_xor(PyObject *v, PyObject *w) 39183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 39193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b; 39203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *c; 39213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP(v, w, &a, &b); 39223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c = long_bitwise(a, '^', b); 39233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 39243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 39253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return c; 39263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 39273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 39283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 39293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_or(PyObject *v, PyObject *w) 39303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 39313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *a, *b; 39323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *c; 39333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel CONVERT_BINOP(v, w, &a, &b); 39343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel c = long_bitwise(a, '|', b); 39353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(a); 39363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(b); 39373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return c; 39383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 39393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 39403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic int 39413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_coerce(PyObject **pv, PyObject **pw) 39423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 39433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyInt_Check(*pw)) { 39443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel *pw = PyLong_FromLong(PyInt_AS_LONG(*pw)); 39453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (*pw == NULL) 39463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return -1; 39473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(*pv); 39483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0; 39493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 39503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (PyLong_Check(*pw)) { 39513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(*pv); 39523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(*pw); 39533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 0; 39543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 39553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 1; /* Can't do it */ 39563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 39573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 39583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 39593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_long(PyObject *v) 39603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 39613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyLong_CheckExact(v)) 39623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(v); 39633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 39643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel v = _PyLong_Copy((PyLongObject *)v); 39653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return v; 39663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 39673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 39683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 39693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_int(PyObject *v) 39703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 39713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long x; 39723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = PyLong_AsLong(v); 39733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyErr_Occurred()) { 39743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyErr_ExceptionMatches(PyExc_OverflowError)) { 39753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_Clear(); 39763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyLong_CheckExact(v)) { 39773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_INCREF(v); 39783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return v; 39793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 39803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 39813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return _PyLong_Copy((PyLongObject *)v); 39823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 39833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else 39843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 39853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 39863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyInt_FromLong(x); 39873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 39883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 39893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 39903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_float(PyObject *v) 39913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 39923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel double result; 39933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = PyLong_AsDouble(v); 39943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (result == -1.0 && PyErr_Occurred()) 39953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 39963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyFloat_FromDouble(result); 39973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 39983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 39993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 40003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_oct(PyObject *v) 40013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 40023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return _PyLong_Format(v, 8, 1, 0); 40033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 40043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 40053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 40063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_hex(PyObject *v) 40073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 40083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return _PyLong_Format(v, 16, 1, 0); 40093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 40103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 40113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 40123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds); 40133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 40143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 40153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 40163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 40173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *x = NULL; 40183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int base = -909; /* unlikely! */ 40193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel static char *kwlist[] = {"x", "base", 0}; 40203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 40213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (type != &PyLong_Type) 40223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_subtype_new(type, args, kwds); /* Wimp out */ 40233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:long", kwlist, 40243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel &x, &base)) 40253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 40263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x == NULL) { 40273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (base != -909) { 40283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_TypeError, 40293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "long() missing string argument"); 40303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 40313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 40323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyLong_FromLong(0L); 40333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 40343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (base == -909) 40353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyNumber_Long(x); 40363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (PyString_Check(x)) { 40373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Since PyLong_FromString doesn't have a length parameter, 40383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * check here for possible NULs in the string. */ 40393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel char *string = PyString_AS_STRING(x); 40403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (strlen(string) != (size_t)PyString_Size(x)) { 40413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* create a repr() of the input string, 40423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel * just like PyLong_FromString does. */ 40433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *srepr; 40443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel srepr = PyObject_Repr(x); 40453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (srepr == NULL) 40463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 40473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_Format(PyExc_ValueError, 40483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "invalid literal for long() with base %d: %s", 40493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base, PyString_AS_STRING(srepr)); 40503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(srepr); 40513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 40523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 40533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyLong_FromString(PyString_AS_STRING(x), NULL, base); 40543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 40553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#ifdef Py_USING_UNICODE 40563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else if (PyUnicode_Check(x)) 40573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyLong_FromUnicode(PyUnicode_AS_UNICODE(x), 40583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyUnicode_GET_SIZE(x), 40593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel base); 40603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif 40613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel else { 40623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_TypeError, 40633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "long() can't convert non-string with explicit base"); 40643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 40653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 40663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 40673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 40683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel/* Wimpy, slow approach to tp_new calls for subtypes of long: 40693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel first create a regular long from whatever arguments we got, 40703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel then allocate a subtype instance and initialize it from 40713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel the regular long. The regular long is then thrown away. 40723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel*/ 40733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 40743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 40753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 40763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *tmp, *newobj; 40773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t i, n; 40783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 40793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(PyType_IsSubtype(type, &PyLong_Type)); 40803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel tmp = (PyLongObject *)long_new(&PyLong_Type, args, kwds); 40813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (tmp == NULL) 40823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 40833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(PyLong_CheckExact(tmp)); 40843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel n = Py_SIZE(tmp); 40853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (n < 0) 40863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel n = -n; 40873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel newobj = (PyLongObject *)type->tp_alloc(type, n); 40883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (newobj == NULL) { 40893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(tmp); 40903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 40913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 40923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(PyLong_Check(newobj)); 40933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_SIZE(newobj) = Py_SIZE(tmp); 40943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel for (i = 0; i < n; i++) 40953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel newobj->ob_digit[i] = tmp->ob_digit[i]; 40963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(tmp); 40973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)newobj; 40983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 40993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 41013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_getnewargs(PyLongObject *v) 41023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 41033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return Py_BuildValue("(N)", _PyLong_Copy(v)); 41043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 41053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 41073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_get0(PyLongObject *v, void *context) { 41083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyLong_FromLong(0L); 41093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 41103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 41123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_get1(PyLongObject *v, void *context) { 41133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyLong_FromLong(1L); 41143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 41153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 41173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong__format__(PyObject *self, PyObject *args) 41183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 41193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *format_spec; 41203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (!PyArg_ParseTuple(args, "O:__format__", &format_spec)) 41223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 41233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyBytes_Check(format_spec)) 41243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return _PyLong_FormatAdvanced(self, 41253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyBytes_AS_STRING(format_spec), 41263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyBytes_GET_SIZE(format_spec)); 41273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyUnicode_Check(format_spec)) { 41283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* Convert format_spec to a str */ 41293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *result; 41303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject *str_spec = PyObject_Str(format_spec); 41313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (str_spec == NULL) 41333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 41343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = _PyLong_FormatAdvanced(self, 41363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyBytes_AS_STRING(str_spec), 41373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyBytes_GET_SIZE(str_spec)); 41383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(str_spec); 41403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return result; 41413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 41423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyErr_SetString(PyExc_TypeError, "__format__ requires str or unicode"); 41433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 41443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 41453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 41473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_sizeof(PyLongObject *v) 41483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 41493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t res; 41503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel res = v->ob_type->tp_basicsize + ABS(Py_SIZE(v))*sizeof(digit); 41523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyInt_FromSsize_t(res); 41533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 41543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 41563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_bit_length(PyLongObject *v) 41573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 41583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyLongObject *result, *x, *y; 41593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_ssize_t ndigits, msd_bits = 0; 41603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel digit msd; 41613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(v != NULL); 41633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel assert(PyLong_Check(v)); 41643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel ndigits = ABS(Py_SIZE(v)); 41663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (ndigits == 0) 41673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyInt_FromLong(0); 41683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel msd = v->ob_digit[ndigits-1]; 41703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel while (msd >= 32) { 41713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel msd_bits += 6; 41723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel msd >>= 6; 41733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 41743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel msd_bits += (long)(BitLengthTable[msd]); 41753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (ndigits <= PY_SSIZE_T_MAX/PyLong_SHIFT) 41773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return PyInt_FromSsize_t((ndigits-1)*PyLong_SHIFT + msd_bits); 41783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* expression above may overflow; use Python integers instead */ 41803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = (PyLongObject *)PyLong_FromSsize_t(ndigits - 1); 41813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (result == NULL) 41823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 41833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = (PyLongObject *)PyLong_FromLong(PyLong_SHIFT); 41843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x == NULL) 41853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto error; 41863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel y = (PyLongObject *)long_mul(result, x); 41873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(x); 41883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (y == NULL) 41893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto error; 41903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(result); 41913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = y; 41923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 41933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel x = (PyLongObject *)PyLong_FromLong((long)msd_bits); 41943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (x == NULL) 41953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto error; 41963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel y = (PyLongObject *)long_add(result, x); 41973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(x); 41983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (y == NULL) 41993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel goto error; 42003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(result); 42013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel result = y; 42023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 42033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return (PyObject *)result; 42043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 42053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel error: 42063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_DECREF(result); 42073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 42083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 42093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 42103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyDoc_STRVAR(long_bit_length_doc, 42113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel"long.bit_length() -> int or long\n\ 42123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel\n\ 42133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielNumber of bits necessary to represent self in binary.\n\ 42143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel>>> bin(37L)\n\ 42153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel'0b100101'\n\ 42163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel>>> (37L).bit_length()\n\ 42173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel6"); 42183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 42193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#if 0 42203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyObject * 42213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong_is_finite(PyObject *v) 42223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 42233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_RETURN_TRUE; 42243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 42253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif 42263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 42273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyMethodDef long_methods[] = { 42283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"conjugate", (PyCFunction)long_long, METH_NOARGS, 42293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "Returns self, the complex conjugate of any long."}, 42303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"bit_length", (PyCFunction)long_bit_length, METH_NOARGS, 42313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_bit_length_doc}, 42323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#if 0 42333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"is_finite", (PyCFunction)long_is_finite, METH_NOARGS, 42343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "Returns always True."}, 42353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel#endif 42363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"__trunc__", (PyCFunction)long_long, METH_NOARGS, 42373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "Truncating an Integral returns itself."}, 42383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"__getnewargs__", (PyCFunction)long_getnewargs, METH_NOARGS}, 42393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"__format__", (PyCFunction)long__format__, METH_VARARGS}, 42403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"__sizeof__", (PyCFunction)long_sizeof, METH_NOARGS, 42413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "Returns size in memory, in bytes"}, 42423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {NULL, NULL} /* sentinel */ 42433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel}; 42443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 42453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyGetSetDef long_getset[] = { 42463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"real", 42473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (getter)long_long, (setter)NULL, 42483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "the real part of a complex number", 42493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel NULL}, 42503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"imag", 42513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (getter)long_get0, (setter)NULL, 42523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "the imaginary part of a complex number", 42533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel NULL}, 42543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"numerator", 42553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (getter)long_long, (setter)NULL, 42563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "the numerator of a rational number in lowest terms", 42573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel NULL}, 42583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"denominator", 42593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (getter)long_get1, (setter)NULL, 42603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "the denominator of a rational number in lowest terms", 42613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel NULL}, 42623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {NULL} /* Sentinel */ 42633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel}; 42643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 42653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyDoc_STRVAR(long_doc, 42663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel"long(x=0) -> long\n\ 42673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniellong(x, base=10) -> long\n\ 42683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel\n\ 42693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielConvert a number or string to a long integer, or return 0L if no arguments\n\ 42703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielare given. If x is floating point, the conversion truncates towards zero.\n\ 42713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel\n\ 42723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielIf x is not a number or if base is given, then x must be a string or\n\ 42733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielUnicode object representing an integer literal in the given base. The\n\ 42743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielliteral can be preceded by '+' or '-' and be surrounded by whitespace.\n\ 42753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielThe base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to\n\ 42763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielinterpret the base from the string as an integer literal.\n\ 42773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel>>> int('0b100', base=0)\n\ 42783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel4L"); 42793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 42803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyNumberMethods long_as_number = { 42813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (binaryfunc)long_add, /*nb_add*/ 42823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (binaryfunc)long_sub, /*nb_subtract*/ 42833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (binaryfunc)long_mul, /*nb_multiply*/ 42843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_classic_div, /*nb_divide*/ 42853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_mod, /*nb_remainder*/ 42863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_divmod, /*nb_divmod*/ 42873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_pow, /*nb_power*/ 42883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (unaryfunc)long_neg, /*nb_negative*/ 42893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (unaryfunc)long_long, /*tp_positive*/ 42903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (unaryfunc)long_abs, /*tp_absolute*/ 42913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (inquiry)long_nonzero, /*tp_nonzero*/ 42923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (unaryfunc)long_invert, /*nb_invert*/ 42933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_lshift, /*nb_lshift*/ 42943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (binaryfunc)long_rshift, /*nb_rshift*/ 42953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_and, /*nb_and*/ 42963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_xor, /*nb_xor*/ 42973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_or, /*nb_or*/ 42983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_coerce, /*nb_coerce*/ 42993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_int, /*nb_int*/ 43003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_long, /*nb_long*/ 43013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_float, /*nb_float*/ 43023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_oct, /*nb_oct*/ 43033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_hex, /*nb_hex*/ 43043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_add */ 43053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_subtract */ 43063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_multiply */ 43073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_divide */ 43083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_remainder */ 43093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_power */ 43103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_lshift */ 43113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_rshift */ 43123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_and */ 43133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_xor */ 43143ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_or */ 43153ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_div, /* nb_floor_divide */ 43163ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_true_divide, /* nb_true_divide */ 43173ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_floor_divide */ 43183ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* nb_inplace_true_divide */ 43193ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_long, /* nb_index */ 43203ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel}; 43213ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 43223ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyTypeObject PyLong_Type = { 43233ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject_HEAD_INIT(&PyType_Type) 43243ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* ob_size */ 43253ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "long", /* tp_name */ 43263ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel offsetof(PyLongObject, ob_digit), /* tp_basicsize */ 43273ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel sizeof(digit), /* tp_itemsize */ 43283ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_dealloc, /* tp_dealloc */ 43293ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_print */ 43303ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_getattr */ 43313ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_setattr */ 43323ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (cmpfunc)long_compare, /* tp_compare */ 43333ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_repr, /* tp_repr */ 43343ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel &long_as_number, /* tp_as_number */ 43353ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_as_sequence */ 43363ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_as_mapping */ 43373ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel (hashfunc)long_hash, /* tp_hash */ 43383ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_call */ 43393ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_str, /* tp_str */ 43403ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject_GenericGetAttr, /* tp_getattro */ 43413ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_setattro */ 43423ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_as_buffer */ 43433ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES | 43443ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_TPFLAGS_BASETYPE | Py_TPFLAGS_LONG_SUBCLASS, /* tp_flags */ 43453ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_doc, /* tp_doc */ 43463ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_traverse */ 43473ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_clear */ 43483ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_richcompare */ 43493ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_weaklistoffset */ 43503ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_iter */ 43513ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_iternext */ 43523ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_methods, /* tp_methods */ 43533ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_members */ 43543ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_getset, /* tp_getset */ 43553ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_base */ 43563ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_dict */ 43573ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_descr_get */ 43583ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_descr_set */ 43593ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_dictoffset */ 43603ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_init */ 43613ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 0, /* tp_alloc */ 43623ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_new, /* tp_new */ 43633ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject_Del, /* tp_free */ 43643ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel}; 43653ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 43663ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyTypeObject Long_InfoType; 43673ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 43683ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyDoc_STRVAR(long_info__doc__, 43693ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel"sys.long_info\n\ 43703ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel\n\ 43713ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielA struct sequence that holds information about Python's\n\ 43723ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielinternal representation of integers. The attributes are read only."); 43733ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 43743ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyStructSequence_Field long_info_fields[] = { 43753ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"bits_per_digit", "size of a digit in bits"}, 43763ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {"sizeof_digit", "size in bytes of the C type used to represent a digit"}, 43773ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel {NULL, NULL} 43783ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel}; 43793ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 43803ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielstatic PyStructSequence_Desc long_info_desc = { 43813ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel "sys.long_info", /* name */ 43823ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_info__doc__, /* doc */ 43833ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_info_fields, /* fields */ 43843ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 2 /* number of fields */ 43853ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel}; 43863ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 43873ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyObject * 43883ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielPyLong_GetInfo(void) 43893ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 43903ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyObject* long_info; 43913ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel int field = 0; 43923ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel long_info = PyStructSequence_New(&Long_InfoType); 43933ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (long_info == NULL) 43943ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 43953ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyStructSequence_SET_ITEM(long_info, field++, 43963ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyInt_FromLong(PyLong_SHIFT)); 43973ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyStructSequence_SET_ITEM(long_info, field++, 43983ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyInt_FromLong(sizeof(digit))); 43993ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (PyErr_Occurred()) { 44003ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel Py_CLEAR(long_info); 44013ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return NULL; 44023ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel } 44033ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return long_info; 44043ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 44053ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel 44063ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDanielint 44073ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel_PyLong_Init(void) 44083ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel{ 44093ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel /* initialize long_info */ 44103ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel if (Long_InfoType.tp_name == 0) 44113ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel PyStructSequence_InitType(&Long_InfoType, &long_info_desc); 44123ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel return 1; 44133ec97ca490009ed5604ccd7f2653e5a9ecbf3474Daryl McDaniel} 4414