14710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/** @file 24710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Long (arbitrary precision) integer object implementation. 34710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 44710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Copyright (c) 2011, Intel Corporation. All rights reserved.<BR> 54710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm This program and the accompanying materials are licensed and made available under 64710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the terms and conditions of the BSD License that accompanies this distribution. 74710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The full text of the license may be found at 84710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm http://opensource.org/licenses/bsd-license. 94710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm**/ 134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* XXX The functional organization of this file is terrible */ 154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "Python.h" 174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "longintrepr.h" 184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include "structseq.h" 194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include <float.h> 214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include <ctype.h> 224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#include <stddef.h> 234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* For long multiplication, use the O(N**2) school algorithm unless 254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * both operands contain more than KARATSUBA_CUTOFF digits (this 264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * being an internal Python long digit, in base PyLong_BASE). 274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define KARATSUBA_CUTOFF 70 294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define KARATSUBA_SQUARE_CUTOFF (2 * KARATSUBA_CUTOFF) 304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* For exponentiation, use the binary left-to-right algorithm 324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * unless the exponent contains more than FIVEARY_CUTOFF digits. 334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * In that case, do 5 bits at a time. The potential drawback is that 344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * a table of 2**5 intermediate results is computed. 354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define FIVEARY_CUTOFF 8 374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifndef ABS 394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #define ABS(x) ((x) < 0 ? -(x) : (x)) 404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifndef MAX 434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #define MAX(x, y) ((x) < (y) ? (y) : (x)) 444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifndef MIN 474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #define MIN(x, y) ((x) > (y) ? (y) : (x)) 484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define SIGCHECK(PyTryBlock) \ 514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do { \ 524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (--_Py_Ticker < 0) { \ 534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _Py_Ticker = _Py_CheckInterval; \ 544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_CheckSignals()) PyTryBlock \ 554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } \ 564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } while(0) 574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Normalize (remove leading zeros from) a long int object. 594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Doesn't attempt to free the storage--in most cases, due to the nature 604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm of the algorithms used, this could save at most be one word anyway. */ 614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyLongObject * 634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_normalize(register PyLongObject *v) 644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t j = ABS(Py_SIZE(v)); 664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i = j; 674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (i > 0 && v->ob_digit[i-1] == 0) 694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm --i; 704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i != j) 714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(v) = (Py_SIZE(v) < 0) ? -(i) : i; 724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Allocate a new long int object with size digits. 764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Return NULL and set exception if we run out of memory. */ 774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define MAX_LONG_DIGITS \ 794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((PY_SSIZE_T_MAX - offsetof(PyLongObject, ob_digit))/sizeof(digit)) 804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLongObject * 824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyLong_New(Py_ssize_t size) 834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (size > (Py_ssize_t)MAX_LONG_DIGITS) { 854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "too many digits in integer"); 874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* coverity[ampersand_in_size] */ 904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX(nnorwitz): PyObject_NEW_VAR / _PyObject_VAR_SIZE need to detect 914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm overflow */ 924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size); 934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyLong_Copy(PyLongObject *src) 974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *result; 994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 1004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(src != NULL); 1024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = src->ob_size; 1034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i < 0) 1044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = -(i); 1054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = _PyLong_New(i); 1064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (result != NULL) { 1074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result->ob_size = src->ob_size; 1084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--i >= 0) 1094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result->ob_digit[i] = src->ob_digit[i]; 1104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 1114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)result; 1124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 1134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Create a new long int object from a C long int */ 1154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 1174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_FromLong(long ival) 1184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 1194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *v; 1204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned long abs_ival; 1214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned long t; /* unsigned so >> doesn't propagate sign bit */ 1224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ndigits = 0; 1234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int negative = 0; 1244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ival < 0) { 1264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* if LONG_MIN == -LONG_MAX-1 (true on most platforms) then 1274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ANSI C says that the result of -ival is undefined when ival 1284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm == LONG_MIN. Hence the following workaround. */ 1294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm abs_ival = (unsigned long)(-1-ival) + 1; 1304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negative = 1; 1314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 1324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 1334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm abs_ival = (unsigned long)ival; 1344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 1354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Count the number of Python digits. 1374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm We used to pick 5 ("big enough for anything"), but that's a 1384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm waste of time and space given that 5*15 = 75 bits are rarely 1394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm needed. */ 1404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = abs_ival; 1414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (t) { 1424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++ndigits; 1434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t >>= PyLong_SHIFT; 1444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 1454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = _PyLong_New(ndigits); 1464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v != NULL) { 1474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *p = v->ob_digit; 1484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v->ob_size = negative ? -ndigits : ndigits; 1494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = abs_ival; 1504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (t) { 1514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *p++ = (digit)(t & PyLong_MASK); 1524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t >>= PyLong_SHIFT; 1534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 1544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 1554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)v; 1564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 1574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Create a new long int object from a C unsigned long int */ 1594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 1614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_FromUnsignedLong(unsigned long ival) 1624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 1634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *v; 1644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned long t; 1654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ndigits = 0; 1664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Count the number of Python digits. */ 1684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = (unsigned long)ival; 1694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (t) { 1704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++ndigits; 1714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t >>= PyLong_SHIFT; 1724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 1734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = _PyLong_New(ndigits); 1744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v != NULL) { 1754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *p = v->ob_digit; 1764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(v) = ndigits; 1774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (ival) { 1784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *p++ = (digit)(ival & PyLong_MASK); 1794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ival >>= PyLong_SHIFT; 1804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 1814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 1824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)v; 1834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 1844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Create a new long int object from a C double */ 1864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 1884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_FromDouble(double dval) 1894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 1904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *v; 1914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm double frac; 1924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i, ndig, expo, neg; 1934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm neg = 0; 1944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_IS_INFINITY(dval)) { 1954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 1964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "cannot convert float infinity to integer"); 1974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 1984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 1994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_IS_NAN(dval)) { 2004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ValueError, 2014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "cannot convert float NaN to integer"); 2024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 2034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (dval < 0.0) { 2054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm neg = 1; 2064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dval = -dval; 2074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frac = frexp(dval, &expo); /* dval = frac*2**expo; 0.0 <= frac < 1.0 */ 2094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (expo <= 0) 2104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyLong_FromLong(0L); 2114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ndig = (expo-1) / PyLong_SHIFT + 1; /* Number of 'digits' in result */ 2124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = _PyLong_New(ndig); 2134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) 2144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 2154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frac = ldexp(frac, (expo-1) % PyLong_SHIFT + 1); 2164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = ndig; --i >= 0; ) { 2174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit bits = (digit)frac; 2184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v->ob_digit[i] = bits; 2194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frac = frac - (double)bits; 2204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm frac = ldexp(frac, PyLong_SHIFT); 2214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (neg) 2234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(v) = -(Py_SIZE(v)); 2244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)v; 2254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 2264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Checking for overflow in PyLong_AsLong is a PITA since C doesn't define 2284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * anything about what happens when a signed integer operation overflows, 2294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * and some compilers think they're doing you a favor by being "clever" 2304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * then. The bit pattern for the largest postive signed long is 2314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * (unsigned long)LONG_MAX, and for the smallest negative signed long 2324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * it is abs(LONG_MIN), which we could write -(unsigned long)LONG_MIN. 2334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * However, some other compilers warn about applying unary minus to an 2344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * unsigned operand. Hence the weird "0-". 2354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 2364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PY_ABS_LONG_MIN (0-(unsigned long)LONG_MIN) 2374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PY_ABS_SSIZE_T_MIN (0-(size_t)PY_SSIZE_T_MIN) 2384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Get a C long int from a Python long or Python int object. 2404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm On overflow, returns -1 and sets *overflow to 1 or -1 depending 2414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm on the sign of the result. Otherwise *overflow is 0. 2424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm For other errors (e.g., type error), returns -1 and sets an error 2444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm condition. 2454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 2464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong 2484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_AsLongAndOverflow(PyObject *vv, int *overflow) 2494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 2504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This version by Tim Peters */ 2514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyLongObject *v; 2524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned long x, prev; 2534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long res; 2544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 2554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int sign; 2564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int do_decref = 0; /* if nb_int was called */ 2574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *overflow = 0; 2594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv == NULL) { 2604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 2614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 2624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if(PyInt_Check(vv)) 2654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_AsLong(vv); 2664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyLong_Check(vv)) { 2684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyNumberMethods *nb; 2694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nb = vv->ob_type->tp_as_number; 2704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nb == NULL || nb->nb_int == NULL) { 2714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 2724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "an integer is required"); 2734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 2744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm vv = (*nb->nb_int) (vv); 2764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv == NULL) 2774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 2784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do_decref = 1; 2794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if(PyInt_Check(vv)) { 2804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = PyInt_AsLong(vv); 2814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto exit; 2824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyLong_Check(vv)) { 2844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(vv); 2854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 2864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "nb_int should return int object"); 2874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 2884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 2904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = -1; 2924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = (PyLongObject *)vv; 2934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = Py_SIZE(v); 2944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch (i) { 2964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case -1: 2974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = -(sdigit)v->ob_digit[0]; 2984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 2994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case 0: 3004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = 0; 3014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 3024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case 1: 3034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = v->ob_digit[0]; 3044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 3054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: 3064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = 1; 3074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0; 3084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i < 0) { 3094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = -1; 3104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = -(i); 3114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--i >= 0) { 3134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm prev = x; 3144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (x << PyLong_SHIFT) + v->ob_digit[i]; 3154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((x >> PyLong_SHIFT) != prev) { 3164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *overflow = sign; 3174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto exit; 3184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Haven't lost any bits, but casting to long requires extra 3214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * care (see comment above). 3224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 3234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x <= (unsigned long)LONG_MAX) { 3244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = (long)x * sign; 3254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (sign < 0 && x == PY_ABS_LONG_MIN) { 3274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = LONG_MIN; 3284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 3304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *overflow = sign; 3314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* res is already set to -1 */ 3324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exit: 3354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (do_decref) { 3364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(vv); 3374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return res; 3394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 3404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Get a C long int from a long int object. 3424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Returns -1 and sets an error condition if overflow occurs. */ 3434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong 3454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_AsLong(PyObject *obj) 3464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 3474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int overflow; 3484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long result = PyLong_AsLongAndOverflow(obj, &overflow); 3494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (overflow) { 3504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* XXX: could be cute and give a different 3514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm message for overflow == -1 */ 3524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 3534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Python int too large to convert to C long"); 3544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 3564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 3574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Get a Py_ssize_t from a long int object. 3594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Returns -1 and sets an error condition if overflow occurs. */ 3604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPy_ssize_t 3624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_AsSsize_t(PyObject *vv) { 3634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyLongObject *v; 3644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t x, prev; 3654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 3664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int sign; 3674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv == NULL || !PyLong_Check(vv)) { 3694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 3704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 3714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = (PyLongObject *)vv; 3734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = v->ob_size; 3744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = 1; 3754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0; 3764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i < 0) { 3774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = -1; 3784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = -(i); 3794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--i >= 0) { 3814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm prev = x; 3824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (x << PyLong_SHIFT) | v->ob_digit[i]; 3834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((x >> PyLong_SHIFT) != prev) 3844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto overflow; 3854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Haven't lost any bits, but casting to a signed type requires 3874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * extra care (see comment above). 3884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 3894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x <= (size_t)PY_SSIZE_T_MAX) { 3904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (Py_ssize_t)x * sign; 3914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (sign < 0 && x == PY_ABS_SSIZE_T_MIN) { 3934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PY_SSIZE_T_MIN; 3944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 3954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* else overflow */ 3964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm overflow: 3984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 3994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "long int too large to convert to int"); 4004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 4014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 4024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Get a C unsigned long int from a long int object. 4044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Returns -1 and sets an error condition if overflow occurs. */ 4054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmunsigned long 4074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_AsUnsignedLong(PyObject *vv) 4084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 4094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyLongObject *v; 4104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned long x, prev; 4114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 4124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv == NULL || !PyLong_Check(vv)) { 4144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv != NULL && PyInt_Check(vv)) { 4154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long val = PyInt_AsLong(vv); 4164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (val < 0) { 4174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 4184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "can't convert negative value " 4194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "to unsigned long"); 4204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (unsigned long) -1; 4214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return val; 4234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 4254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (unsigned long) -1; 4264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = (PyLongObject *)vv; 4284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = Py_SIZE(v); 4294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0; 4304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i < 0) { 4314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 4324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "can't convert negative value to unsigned long"); 4334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (unsigned long) -1; 4344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--i >= 0) { 4364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm prev = x; 4374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (x << PyLong_SHIFT) | v->ob_digit[i]; 4384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((x >> PyLong_SHIFT) != prev) { 4394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 4404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "long int too large to convert"); 4414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (unsigned long) -1; 4424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return x; 4454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 4464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Get a C unsigned long int from a long int object, ignoring the high bits. 4484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Returns -1 and sets an error condition if an error occurs. */ 4494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmunsigned long 4514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_AsUnsignedLongMask(PyObject *vv) 4524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 4534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyLongObject *v; 4544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned long x; 4554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 4564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int sign; 4574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv == NULL || !PyLong_Check(vv)) { 4594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv != NULL && PyInt_Check(vv)) 4604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_AsUnsignedLongMask(vv); 4614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 4624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (unsigned long) -1; 4634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = (PyLongObject *)vv; 4654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = v->ob_size; 4664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = 1; 4674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0; 4684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i < 0) { 4694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = -1; 4704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = -i; 4714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--i >= 0) { 4734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (x << PyLong_SHIFT) | v->ob_digit[i]; 4744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 4754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return x * sign; 4764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 4774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 4794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyLong_Sign(PyObject *vv) 4804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 4814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *v = (PyLongObject *)vv; 4824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(v != NULL); 4844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyLong_Check(v)); 4854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_SIZE(v) == 0 ? 0 : (Py_SIZE(v) < 0 ? -1 : 1); 4874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 4884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmsize_t 4904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyLong_NumBits(PyObject *vv) 4914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 4924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *v = (PyLongObject *)vv; 4934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t result = 0; 4944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t ndigits; 4954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(v != NULL); 4974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyLong_Check(v)); 4984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ndigits = ABS(Py_SIZE(v)); 4994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0); 5004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ndigits > 0) { 5014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit msd = v->ob_digit[ndigits - 1]; 5024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = (ndigits - 1) * PyLong_SHIFT; 5044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (result / PyLong_SHIFT != (size_t)(ndigits - 1)) 5054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Overflow; 5064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do { 5074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++result; 5084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (result == 0) 5094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Overflow; 5104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msd >>= 1; 5114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } while (msd); 5124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 5144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Overflow: 5164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, "long has too many bits " 5174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "to express in a platform size_t"); 5184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (size_t)-1; 5194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 5204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 5224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyLong_FromByteArray(const unsigned char* bytes, size_t n, 5234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int little_endian, int is_signed) 5244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 5254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const unsigned char* pstartbyte; /* LSB of bytes */ 5264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int incr; /* direction to move pstartbyte */ 5274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const unsigned char* pendbyte; /* MSB of bytes */ 5284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t numsignificantbytes; /* number of bytes that matter */ 5294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t ndigits; /* number of Python long digits */ 5304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject* v; /* result */ 5314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t idigit = 0; /* next free index in v->ob_digit */ 5324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n == 0) 5344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyLong_FromLong(0L); 5354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (little_endian) { 5374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pstartbyte = bytes; 5384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendbyte = bytes + n - 1; 5394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm incr = 1; 5404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 5424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pstartbyte = bytes + n - 1; 5434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pendbyte = bytes; 5444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm incr = -1; 5454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (is_signed) 5484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm is_signed = *pendbyte >= 0x80; 5494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Compute numsignificantbytes. This consists of finding the most 5514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm significant byte. Leading 0 bytes are insignificant if the number 5524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm is positive, and leading 0xff bytes if negative. */ 5534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 5544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t i; 5554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const unsigned char* p = pendbyte; 5564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const int pincr = -incr; /* search MSB to LSB */ 5574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const unsigned char insignficant = is_signed ? 0xff : 0x00; 5584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < n; ++i, p += pincr) { 5604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (*p != insignficant) 5614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 5624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm numsignificantbytes = n - i; 5644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* 2's-comp is a bit tricky here, e.g. 0xff00 == -0x0100, so 5654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm actually has 2 significant bytes. OTOH, 0xff0001 == 5664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm -0x00ffff, so we wouldn't *need* to bump it there; but we 5674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do for 0xffff = -0x0001. To be safe without bothering to 5684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check every case, bump it regardless. */ 5694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (is_signed && numsignificantbytes < n) 5704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++numsignificantbytes; 5714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* How many Python long digits do we need? We have 5744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8*numsignificantbytes bits, and each Python long digit has 5754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLong_SHIFT bits, so it's the ceiling of the quotient. */ 5764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* catch overflow before it happens */ 5774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (numsignificantbytes > (PY_SSIZE_T_MAX - PyLong_SHIFT) / 8) { 5784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 5794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "byte array too long to convert to int"); 5804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 5814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 5824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ndigits = (numsignificantbytes * 8 + PyLong_SHIFT - 1) / PyLong_SHIFT; 5834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = _PyLong_New(ndigits); 5844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) 5854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 5864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Copy the bits over. The tricky parts are computing 2's-comp on 5884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the fly for signed numbers, and dealing with the mismatch between 5894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8-bit bytes and (probably) 15-bit Python digits.*/ 5904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 5914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t i; 5924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits carry = 1; /* for 2's-comp calculation */ 5934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits accum = 0; /* sliding register */ 5944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned int accumbits = 0; /* number of bits in accum */ 5954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const unsigned char* p = pstartbyte; 5964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < numsignificantbytes; ++i, p += incr) { 5984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits thisbyte = *p; 5994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Compute correction for 2's comp, if needed. */ 6004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (is_signed) { 6014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm thisbyte = (0xff ^ thisbyte) + carry; 6024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry = thisbyte >> 8; 6034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm thisbyte &= 0xff; 6044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Because we're going LSB to MSB, thisbyte is 6064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm more significant than what's already in accum, 6074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm so needs to be prepended to accum. */ 6084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum |= (twodigits)thisbyte << accumbits; 6094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accumbits += 8; 6104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (accumbits >= PyLong_SHIFT) { 6114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* There's enough to fill a Python digit. */ 6124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(idigit < ndigits); 6134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v->ob_digit[idigit] = (digit)(accum & PyLong_MASK); 6144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++idigit; 6154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum >>= PyLong_SHIFT; 6164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accumbits -= PyLong_SHIFT; 6174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(accumbits < PyLong_SHIFT); 6184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(accumbits < PyLong_SHIFT); 6214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (accumbits) { 6224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(idigit < ndigits); 6234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v->ob_digit[idigit] = (digit)accum; 6244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++idigit; 6254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(v) = is_signed ? -idigit : idigit; 6294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)long_normalize(v); 6304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 6314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 6334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyLong_AsByteArray(PyLongObject* v, 6344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned char* bytes, size_t n, 6354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int little_endian, int is_signed) 6364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 6374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; /* index into v->ob_digit */ 6384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t ndigits; /* |v->ob_size| */ 6394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits accum; /* sliding register */ 6404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned int accumbits; /* # bits in accum */ 6414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int do_twos_comp; /* store 2's-comp? is_signed and v < 0 */ 6424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit carry; /* for computing 2's-comp */ 6434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t j; /* # bytes filled */ 6444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned char* p; /* pointer to next byte in bytes */ 6454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int pincr; /* direction to move p */ 6464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(v != NULL && PyLong_Check(v)); 6484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(v) < 0) { 6504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ndigits = -(Py_SIZE(v)); 6514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!is_signed) { 6524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 6534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "can't convert negative long to unsigned"); 6544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 6554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do_twos_comp = 1; 6574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 6594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ndigits = Py_SIZE(v); 6604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do_twos_comp = 0; 6614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (little_endian) { 6644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = bytes; 6654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pincr = 1; 6664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 6684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = bytes + n - 1; 6694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pincr = -1; 6704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Copy over all the Python digits. 6734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm It's crucial that every Python digit except for the MSD contribute 6744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exactly PyLong_SHIFT bits to the total, so first assert that the long is 6754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm normalized. */ 6764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0); 6774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm j = 0; 6784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum = 0; 6794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accumbits = 0; 6804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry = do_twos_comp ? 1 : 0; 6814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < ndigits; ++i) { 6824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit thisdigit = v->ob_digit[i]; 6834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (do_twos_comp) { 6844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm thisdigit = (thisdigit ^ PyLong_MASK) + carry; 6854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry = thisdigit >> PyLong_SHIFT; 6864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm thisdigit &= PyLong_MASK; 6874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 6884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Because we're going LSB to MSB, thisdigit is more 6894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm significant than what's already in accum, so needs to be 6904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm prepended to accum. */ 6914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum |= (twodigits)thisdigit << accumbits; 6924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The most-significant digit may be (probably is) at least 6944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm partly empty. */ 6954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i == ndigits - 1) { 6964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Count # of sign bits -- they needn't be stored, 6974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * although for signed conversion we need later to 6984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * make sure at least one sign bit gets stored. */ 6994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit s = do_twos_comp ? thisdigit ^ PyLong_MASK : thisdigit; 7004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (s != 0) { 7014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s >>= 1; 7024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accumbits++; 7034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 7044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 7054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 7064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accumbits += PyLong_SHIFT; 7074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Store as many bytes as possible. */ 7094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (accumbits >= 8) { 7104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (j >= n) 7114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Overflow; 7124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++j; 7134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *p = (unsigned char)(accum & 0xff); 7144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p += pincr; 7154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accumbits -= 8; 7164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum >>= 8; 7174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 7184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 7194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Store the straggler (if any). */ 7214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(accumbits < 8); 7224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(carry == 0); /* else do_twos_comp and *every* digit was 0 */ 7234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (accumbits > 0) { 7244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (j >= n) 7254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Overflow; 7264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++j; 7274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (do_twos_comp) { 7284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Fill leading bits of the byte with sign bits 7294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (appropriately pretending that the long had an 7304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm infinite supply of sign bits). */ 7314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum |= (~(twodigits)0) << accumbits; 7324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 7334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *p = (unsigned char)(accum & 0xff); 7344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p += pincr; 7354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 7364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (j == n && n > 0 && is_signed) { 7374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The main loop filled the byte array exactly, so the code 7384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm just above didn't get to ensure there's a sign bit, and the 7394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm loop below wouldn't add one either. Make sure a sign bit 7404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exists. */ 7414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned char msb = *(p - pincr); 7424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int sign_bit_set = msb >= 0x80; 7434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(accumbits == 0); 7444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (sign_bit_set == do_twos_comp) 7454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 7464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 7474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Overflow; 7484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 7494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Fill remaining bytes with copies of the sign bit. */ 7514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { 7524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned char signbyte = do_twos_comp ? 0xffU : 0U; 7534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for ( ; j < n; ++j, p += pincr) 7544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *p = signbyte; 7554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 7564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 7584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Overflow: 7604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, "long too big to convert"); 7614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 7624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 7644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Create a new long (or int) object from a C pointer */ 7664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 7684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_FromVoidPtr(void *p) 7694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 7704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if SIZEOF_VOID_P <= SIZEOF_LONG 7714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((long)p < 0) 7724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyLong_FromUnsignedLong((unsigned long)p); 7734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_FromLong((long)p); 7744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 7754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifndef HAVE_LONG_LONG 7774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# error "PyLong_FromVoidPtr: sizeof(void*) > sizeof(long), but no long long" 7784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 7794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if SIZEOF_LONG_LONG < SIZEOF_VOID_P 7804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# error "PyLong_FromVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)" 7814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 7824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* optimize null pointers */ 7834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (p == NULL) 7844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_FromLong(0); 7854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)p); 7864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */ 7884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 7894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Get a C pointer from a long object (or an int object in some cases) */ 7914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmvoid * 7934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_AsVoidPtr(PyObject *vv) 7944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 7954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This function will allow int or long objects. If vv is neither, 7964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm then the PyLong_AsLong*() functions will raise the exception: 7974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyExc_SystemError, "bad argument to internal function" 7984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 7994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if SIZEOF_VOID_P <= SIZEOF_LONG 8004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long x; 8014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_Check(vv)) 8034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyInt_AS_LONG(vv); 8044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0) 8054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyLong_AsLong(vv); 8064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 8074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyLong_AsUnsignedLong(vv); 8084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 8094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifndef HAVE_LONG_LONG 8114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long" 8124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 8134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if SIZEOF_LONG_LONG < SIZEOF_VOID_P 8144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# error "PyLong_AsVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)" 8154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 8164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PY_LONG_LONG x; 8174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_Check(vv)) 8194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyInt_AS_LONG(vv); 8204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyLong_Check(vv) && _PyLong_Sign(vv) < 0) 8214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyLong_AsLongLong(vv); 8224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 8234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyLong_AsUnsignedLongLong(vv); 8244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */ 8264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == -1 && PyErr_Occurred()) 8284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 8294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (void *)x; 8304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 8314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef HAVE_LONG_LONG 8334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Initial PY_LONG_LONG support by Chris Herborth (chrish@qnx.com), later 8354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * rewritten to use the newer PyLong_{As,From}ByteArray API. 8364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 8374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define IS_LITTLE_ENDIAN (int)*(unsigned char*)&one 8394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define PY_ABS_LLONG_MIN (0-(unsigned PY_LONG_LONG)PY_LLONG_MIN) 8404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Create a new long int object from a C PY_LONG_LONG int. */ 8424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 8444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_FromLongLong(PY_LONG_LONG ival) 8454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 8464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *v; 8474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned PY_LONG_LONG abs_ival; 8484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned PY_LONG_LONG t; /* unsigned so >> doesn't propagate sign bit */ 8494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ndigits = 0; 8504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int negative = 0; 8514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ival < 0) { 8534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* avoid signed overflow on negation; see comments 8544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm in PyLong_FromLong above. */ 8554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm abs_ival = (unsigned PY_LONG_LONG)(-1-ival) + 1; 8564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negative = 1; 8574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 8584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 8594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm abs_ival = (unsigned PY_LONG_LONG)ival; 8604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 8614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Count the number of Python digits. 8634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm We used to pick 5 ("big enough for anything"), but that's a 8644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm waste of time and space given that 5*15 = 75 bits are rarely 8654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm needed. */ 8664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = abs_ival; 8674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (t) { 8684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++ndigits; 8694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t >>= PyLong_SHIFT; 8704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 8714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = _PyLong_New(ndigits); 8724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v != NULL) { 8734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *p = v->ob_digit; 8744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(v) = negative ? -ndigits : ndigits; 8754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = abs_ival; 8764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (t) { 8774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *p++ = (digit)(t & PyLong_MASK); 8784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t >>= PyLong_SHIFT; 8794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 8804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 8814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)v; 8824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 8834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Create a new long int object from a C unsigned PY_LONG_LONG int. */ 8854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 8874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival) 8884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 8894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *v; 8904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned PY_LONG_LONG t; 8914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ndigits = 0; 8924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Count the number of Python digits. */ 8944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = (unsigned PY_LONG_LONG)ival; 8954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (t) { 8964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++ndigits; 8974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t >>= PyLong_SHIFT; 8984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 8994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = _PyLong_New(ndigits); 9004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v != NULL) { 9014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *p = v->ob_digit; 9024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(v) = ndigits; 9034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (ival) { 9044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *p++ = (digit)(ival & PyLong_MASK); 9054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ival >>= PyLong_SHIFT; 9064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)v; 9094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 9104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Create a new long int object from a C Py_ssize_t. */ 9124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 9144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_FromSsize_t(Py_ssize_t ival) 9154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 9164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t bytes = ival; 9174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int one = 1; 9184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyLong_FromByteArray((unsigned char *)&bytes, 9194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 1); 9204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 9214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Create a new long int object from a C size_t. */ 9234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 9254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_FromSize_t(size_t ival) 9264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 9274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_t bytes = ival; 9284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int one = 1; 9294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyLong_FromByteArray((unsigned char *)&bytes, 9304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SIZEOF_SIZE_T, IS_LITTLE_ENDIAN, 0); 9314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 9324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Get a C PY_LONG_LONG int from a long int object. 9344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Return -1 and set an error if overflow occurs. */ 9354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPY_LONG_LONG 9374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_AsLongLong(PyObject *vv) 9384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 9394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PY_LONG_LONG bytes; 9404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int one = 1; 9414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int res; 9424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv == NULL) { 9444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 9454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 9464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyLong_Check(vv)) { 9484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyNumberMethods *nb; 9494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *io; 9504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_Check(vv)) 9514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PY_LONG_LONG)PyInt_AsLong(vv); 9524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((nb = vv->ob_type->tp_as_number) == NULL || 9534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nb->nb_int == NULL) { 9544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, "an integer is required"); 9554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 9564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm io = (*nb->nb_int) (vv); 9584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (io == NULL) 9594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 9604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_Check(io)) { 9614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bytes = PyInt_AsLong(io); 9624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(io); 9634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return bytes; 9644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyLong_Check(io)) { 9664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bytes = PyLong_AsLongLong(io); 9674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(io); 9684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return bytes; 9694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(io); 9714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, "integer conversion failed"); 9724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 9734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = _PyLong_AsByteArray((PyLongObject *)vv, (unsigned char *)&bytes, 9764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1); 9774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */ 9794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (res < 0) 9804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PY_LONG_LONG)-1; 9814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 9824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return bytes; 9834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 9844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Get a C unsigned PY_LONG_LONG int from a long int object. 9864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Return -1 and set an error if overflow occurs. */ 9874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmunsigned PY_LONG_LONG 9894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_AsUnsignedLongLong(PyObject *vv) 9904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 9914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned PY_LONG_LONG bytes; 9924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int one = 1; 9934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int res; 9944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv == NULL || !PyLong_Check(vv)) { 9964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 9974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (unsigned PY_LONG_LONG)-1; 9984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 9994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = _PyLong_AsByteArray((PyLongObject *)vv, (unsigned char *)&bytes, 10014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0); 10024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Plan 9 can't handle PY_LONG_LONG in ? : expressions */ 10044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (res < 0) 10054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (unsigned PY_LONG_LONG)res; 10064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 10074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return bytes; 10084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 10094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Get a C unsigned long int from a long int object, ignoring the high bits. 10114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Returns -1 and sets an error condition if an error occurs. */ 10124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmunsigned PY_LONG_LONG 10144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_AsUnsignedLongLongMask(PyObject *vv) 10154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 10164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyLongObject *v; 10174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned PY_LONG_LONG x; 10184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 10194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int sign; 10204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv == NULL || !PyLong_Check(vv)) { 10224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 10234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (unsigned long) -1; 10244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = (PyLongObject *)vv; 10264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = v->ob_size; 10274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = 1; 10284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0; 10294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i < 0) { 10304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = -1; 10314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = -i; 10324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--i >= 0) { 10344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (x << PyLong_SHIFT) | v->ob_digit[i]; 10354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return x * sign; 10374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 10384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Get a C long long int from a Python long or Python int object. 10404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm On overflow, returns -1 and sets *overflow to 1 or -1 depending 10414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm on the sign of the result. Otherwise *overflow is 0. 10424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm For other errors (e.g., type error), returns -1 and sets an error 10444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm condition. 10454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 10464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPY_LONG_LONG 10484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_AsLongLongAndOverflow(PyObject *vv, int *overflow) 10494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 10504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This version by Tim Peters */ 10514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyLongObject *v; 10524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned PY_LONG_LONG x, prev; 10534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PY_LONG_LONG res; 10544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 10554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int sign; 10564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int do_decref = 0; /* if nb_int was called */ 10574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *overflow = 0; 10594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv == NULL) { 10604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 10614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 10624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_Check(vv)) 10654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_AsLong(vv); 10664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyLong_Check(vv)) { 10684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyNumberMethods *nb; 10694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nb = vv->ob_type->tp_as_number; 10704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nb == NULL || nb->nb_int == NULL) { 10714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 10724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "an integer is required"); 10734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 10744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm vv = (*nb->nb_int) (vv); 10764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (vv == NULL) 10774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 10784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do_decref = 1; 10794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if(PyInt_Check(vv)) { 10804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = PyInt_AsLong(vv); 10814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto exit; 10824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyLong_Check(vv)) { 10844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(vv); 10854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 10864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "nb_int should return int object"); 10874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 10884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 10904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = -1; 10924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = (PyLongObject *)vv; 10934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = Py_SIZE(v); 10944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch (i) { 10964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case -1: 10974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = -(sdigit)v->ob_digit[0]; 10984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 10994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case 0: 11004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = 0; 11014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 11024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case 1: 11034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = v->ob_digit[0]; 11044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 11054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: 11064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = 1; 11074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0; 11084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i < 0) { 11094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = -1; 11104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = -(i); 11114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--i >= 0) { 11134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm prev = x; 11144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (x << PyLong_SHIFT) + v->ob_digit[i]; 11154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((x >> PyLong_SHIFT) != prev) { 11164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *overflow = sign; 11174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto exit; 11184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Haven't lost any bits, but casting to long requires extra 11214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * care (see comment above). 11224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 11234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x <= (unsigned PY_LONG_LONG)PY_LLONG_MAX) { 11244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = (PY_LONG_LONG)x * sign; 11254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (sign < 0 && x == PY_ABS_LLONG_MIN) { 11274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = PY_LLONG_MIN; 11284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 11304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *overflow = sign; 11314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* res is already set to -1 */ 11324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exit: 11354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (do_decref) { 11364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(vv); 11374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return res; 11394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 11404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#undef IS_LITTLE_ENDIAN 11424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif /* HAVE_LONG_LONG */ 11444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 11474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmconvert_binop(PyObject *v, PyObject *w, PyLongObject **a, PyLongObject **b) { 11484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyLong_Check(v)) { 11494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *a = (PyLongObject *) v; 11504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(v); 11514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyInt_Check(v)) { 11534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *a = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(v)); 11544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 11564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 11574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyLong_Check(w)) { 11594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *b = (PyLongObject *) w; 11604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(w); 11614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyInt_Check(w)) { 11634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *b = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(w)); 11644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 11664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(*a); 11674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 11684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1; 11704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 11714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define CONVERT_BINOP(v, w, a, b) \ 11734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do { \ 11744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!convert_binop(v, w, a, b)) { \ 11754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_NotImplemented); \ 11764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_NotImplemented; \ 11774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } \ 11784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } while(0) \ 11794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* bits_in_digit(d) returns the unique integer k such that 2**(k-1) <= d < 11814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2**k if d is nonzero, else 0. */ 11824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic const unsigned char BitLengthTable[32] = { 11844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 11854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 11864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 11874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 11894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbits_in_digit(digit d) 11904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 11914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int d_bits = 0; 11924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (d >= 32) { 11934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d_bits += 6; 11944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d >>= 6; 11954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 11964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d_bits += (int)BitLengthTable[d]; 11974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return d_bits; 11984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 11994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* x[0:m] and y[0:n] are digit vectors, LSD first, m >= n required. x[0:n] 12014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * is modified in place, by adding y to it. Carries are propagated as far as 12024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * x[m-1], and the remaining carry (0 or 1) is returned. 12034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 12044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic digit 12054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmv_iadd(digit *x, Py_ssize_t m, digit *y, Py_ssize_t n) 12064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 12074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 12084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit carry = 0; 12094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(m >= n); 12114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < n; ++i) { 12124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry += x[i] + y[i]; 12134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x[i] = carry & PyLong_MASK; 12144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry >>= PyLong_SHIFT; 12154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert((carry & 1) == carry); 12164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; carry && i < m; ++i) { 12184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry += x[i]; 12194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x[i] = carry & PyLong_MASK; 12204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry >>= PyLong_SHIFT; 12214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert((carry & 1) == carry); 12224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return carry; 12244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 12254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* x[0:m] and y[0:n] are digit vectors, LSD first, m >= n required. x[0:n] 12274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * is modified in place, by subtracting y from it. Borrows are propagated as 12284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * far as x[m-1], and the remaining borrow (0 or 1) is returned. 12294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 12304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic digit 12314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmv_isub(digit *x, Py_ssize_t m, digit *y, Py_ssize_t n) 12324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 12334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 12344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit borrow = 0; 12354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(m >= n); 12374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < n; ++i) { 12384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow = x[i] - y[i] - borrow; 12394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x[i] = borrow & PyLong_MASK; 12404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow >>= PyLong_SHIFT; 12414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow &= 1; /* keep only 1 sign bit */ 12424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; borrow && i < m; ++i) { 12444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow = x[i] - borrow; 12454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x[i] = borrow & PyLong_MASK; 12464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow >>= PyLong_SHIFT; 12474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow &= 1; 12484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return borrow; 12504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 12514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Shift digit vector a[0:m] d bits left, with 0 <= d < PyLong_SHIFT. Put 12534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * result in z[0:m], and return the d bits shifted out of the top. 12544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 12554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic digit 12564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmv_lshift(digit *z, digit *a, Py_ssize_t m, int d) 12574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 12584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 12594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit carry = 0; 12604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(0 <= d && d < PyLong_SHIFT); 12624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i=0; i < m; i++) { 12634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits acc = (twodigits)a[i] << d | carry; 12644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z[i] = (digit)acc & PyLong_MASK; 12654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry = (digit)(acc >> PyLong_SHIFT); 12664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return carry; 12684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 12694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Shift digit vector a[0:m] d bits right, with 0 <= d < PyLong_SHIFT. Put 12714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * result in z[0:m], and return the d bits shifted out of the bottom. 12724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 12734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic digit 12744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmv_rshift(digit *z, digit *a, Py_ssize_t m, int d) 12754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 12764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 12774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit carry = 0; 12784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit mask = ((digit)1 << d) - 1U; 12794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(0 <= d && d < PyLong_SHIFT); 12814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i=m; i-- > 0;) { 12824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits acc = (twodigits)carry << PyLong_SHIFT | a[i]; 12834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry = (digit)acc & mask; 12844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z[i] = (digit)(acc >> d); 12854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 12864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return carry; 12874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 12884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Divide long pin, w/ size digits, by non-zero digit n, storing quotient 12904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm in pout, and returning the remainder. pin and pout point at the LSD. 12914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm It's OK for pin == pout on entry, which saves oodles of mallocs/frees in 12924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _PyLong_Format, but that should be done with great care since longs are 12934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm immutable. */ 12944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic digit 12964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylminplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n) 12974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 12984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits rem = 0; 12994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(n > 0 && n <= PyLong_MASK); 13014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pin += size; 13024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pout += size; 13034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--size >= 0) { 13044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit hi; 13054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem = (rem << PyLong_SHIFT) | *--pin; 13064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--pout = hi = (digit)(rem / n); 13074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem -= (twodigits)hi * n; 13084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (digit)rem; 13104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 13114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Divide a long integer by a digit, returning both the quotient 13134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (as function result) and the remainder (through *prem). 13144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The sign of a is ignored; n should not be zero. */ 13154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyLongObject * 13174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdivrem1(PyLongObject *a, digit n, digit *prem) 13184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 13194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const Py_ssize_t size = ABS(Py_SIZE(a)); 13204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z; 13214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(n > 0 && n <= PyLong_MASK); 13234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(size); 13244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 13254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 13264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *prem = inplace_divrem1(z->ob_digit, a->ob_digit, size, n); 13274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_normalize(z); 13284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 13294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Convert a long integer to a base 10 string. Returns a new non-shared 13314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm string. (Return value is non-shared so that callers can modify the 13324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm returned value if necessary.) */ 13334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 13354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_to_decimal_string(PyObject *aa, int addL) 13364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 13374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *scratch, *a; 13384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *str; 13394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size, strlen, size_a, i, j; 13404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *pout, *pin, rem, tenpow; 13414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *p; 13424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int negative; 13434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = (PyLongObject *)aa; 13454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a == NULL || !PyLong_Check(a)) { 13464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 13474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 13484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_a = ABS(Py_SIZE(a)); 13504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negative = Py_SIZE(a) < 0; 13514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* quick and dirty upper bound for the number of digits 13534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm required to express a in base _PyLong_DECIMAL_BASE: 13544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #digits = 1 + floor(log2(a) / log2(_PyLong_DECIMAL_BASE)) 13564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm But log2(a) < size_a * PyLong_SHIFT, and 13584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm log2(_PyLong_DECIMAL_BASE) = log2(10) * _PyLong_DECIMAL_SHIFT 13594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm > 3 * _PyLong_DECIMAL_SHIFT 13604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 13614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (size_a > PY_SSIZE_T_MAX / PyLong_SHIFT) { 13624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 13634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "long is too large to format"); 13644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 13654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* the expression size_a * PyLong_SHIFT is now safe from overflow */ 13674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size = 1 + size_a * PyLong_SHIFT / (3 * _PyLong_DECIMAL_SHIFT); 13684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm scratch = _PyLong_New(size); 13694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (scratch == NULL) 13704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 13714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* convert array of base _PyLong_BASE digits in pin to an array of 13734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base _PyLong_DECIMAL_BASE digits in pout, following Knuth (TAOCP, 13744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Volume 2 (3rd edn), section 4.4, Method 1b). */ 13754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pin = a->ob_digit; 13764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pout = scratch->ob_digit; 13774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size = 0; 13784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = size_a; --i >= 0; ) { 13794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit hi = pin[i]; 13804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (j = 0; j < size; j++) { 13814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits z = (twodigits)pout[j] << PyLong_SHIFT | hi; 13824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hi = (digit)(z / _PyLong_DECIMAL_BASE); 13834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pout[j] = (digit)(z - (twodigits)hi * 13844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _PyLong_DECIMAL_BASE); 13854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (hi) { 13874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pout[size++] = hi % _PyLong_DECIMAL_BASE; 13884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hi /= _PyLong_DECIMAL_BASE; 13894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* check for keyboard interrupt */ 13914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SIGCHECK({ 13924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(scratch); 13934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 13944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm }); 13954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 13964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* pout should have at least one digit, so that the case when a = 0 13974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm works correctly */ 13984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (size == 0) 13994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pout[size++] = 0; 14004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* calculate exact length of output string, and allocate */ 14024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm strlen = (addL != 0) + negative + 14034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1 + (size - 1) * _PyLong_DECIMAL_SHIFT; 14044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tenpow = 10; 14054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem = pout[size-1]; 14064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (rem >= tenpow) { 14074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tenpow *= 10; 14084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm strlen++; 14094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm str = PyString_FromStringAndSize(NULL, strlen); 14114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (str == NULL) { 14124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(scratch); 14134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 14144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* fill the string right-to-left */ 14174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = PyString_AS_STRING(str) + strlen; 14184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *p = '\0'; 14194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (addL) 14204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = 'L'; 14214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* pout[0] through pout[size-2] contribute exactly 14224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _PyLong_DECIMAL_SHIFT digits each */ 14234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i=0; i < size - 1; i++) { 14244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem = pout[i]; 14254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (j = 0; j < _PyLong_DECIMAL_SHIFT; j++) { 14264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = '0' + rem % 10; 14274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem /= 10; 14284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* pout[size-1]: always produce at least one decimal digit */ 14314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem = pout[i]; 14324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do { 14334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = '0' + rem % 10; 14344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem /= 10; 14354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } while (rem != 0); 14364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* and sign */ 14384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (negative) 14394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = '-'; 14404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* check we've counted correctly */ 14424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(p == PyString_AS_STRING(str)); 14434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(scratch); 14444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)str; 14454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 14464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Convert the long to a string object with given base, 14484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm appending a base prefix of 0[box] if base is 2, 8 or 16. 14494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Add a trailing "L" if addL is non-zero. 14504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm If newstyle is zero, then use the pre-2.6 behavior of octal having 14514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a leading "0", instead of the prefix "0o" */ 14524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyAPI_FUNC(PyObject *) 14534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyLong_Format(PyObject *aa, int base, int addL, int newstyle) 14544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 14554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register PyLongObject *a = (PyLongObject *)aa; 14564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyStringObject *str; 14574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i, sz; 14584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size_a; 14594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *p; 14604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int bits; 14614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char sign = '\0'; 14624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (base == 10) 14644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_to_decimal_string((PyObject *)a, addL); 14654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a == NULL || !PyLong_Check(a)) { 14674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 14684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 14694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(base >= 2 && base <= 36); 14714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_a = ABS(Py_SIZE(a)); 14724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Compute a rough upper bound for the length of the string */ 14744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = base; 14754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bits = 0; 14764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (i > 1) { 14774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++bits; 14784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i >>= 1; 14794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = 5 + (addL ? 1 : 0); 14814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* ensure we don't get signed overflow in sz calculation */ 14824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (size_a > (PY_SSIZE_T_MAX - i) / PyLong_SHIFT) { 14834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 14844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "long is too large to format"); 14854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 14864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 14874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sz = i + 1 + (size_a * PyLong_SHIFT - 1) / bits; 14884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(sz >= 0); 14894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm str = (PyStringObject *) PyString_FromStringAndSize((char *)0, sz); 14904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (str == NULL) 14914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 14924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm p = PyString_AS_STRING(str) + sz; 14934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *p = '\0'; 14944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (addL) 14954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = 'L'; 14964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a->ob_size < 0) 14974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = '-'; 14984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 14994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a->ob_size == 0) { 15004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = '0'; 15014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if ((base & (base - 1)) == 0) { 15034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* JRH: special case for power-of-2 bases */ 15044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits accum = 0; 15054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int accumbits = 0; /* # of bits in accum */ 15064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int basebits = 1; /* # of bits in base-1 */ 15074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = base; 15084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while ((i >>= 1) > 1) 15094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++basebits; 15104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < size_a; ++i) { 15124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum |= (twodigits)a->ob_digit[i] << accumbits; 15134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accumbits += PyLong_SHIFT; 15144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(accumbits >= basebits); 15154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do { 15164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char cdigit = (char)(accum & (base - 1)); 15174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm cdigit += (cdigit < 10) ? '0' : 'a'-10; 15184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(p > PyString_AS_STRING(str)); 15194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = cdigit; 15204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accumbits -= basebits; 15214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum >>= basebits; 15224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } while (i < size_a-1 ? accumbits >= basebits : accum > 0); 15234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 15264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Not 0, and base not a power of 2. Divide repeatedly by 15274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base, but for speed use the highest power of base that 15284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fits in a digit. */ 15294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size = size_a; 15304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *pin = a->ob_digit; 15314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *scratch; 15324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* powbasw <- largest power of base that fits in a digit. */ 15334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit powbase = base; /* powbase == base ** power */ 15344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int power = 1; 15354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (;;) { 15364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits newpow = powbase * (twodigits)base; 15374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (newpow >> PyLong_SHIFT) 15384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* doesn't fit in a digit */ 15394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 15404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm powbase = (digit)newpow; 15414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++power; 15424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Get a scratch area for repeated division. */ 15454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm scratch = _PyLong_New(size); 15464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (scratch == NULL) { 15474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(str); 15484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 15494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Repeatedly divide by powbase. */ 15524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do { 15534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int ntostore = power; 15544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit rem = inplace_divrem1(scratch->ob_digit, 15554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pin, size, powbase); 15564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pin = scratch->ob_digit; /* no need to use a again */ 15574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pin[size - 1] == 0) 15584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm --size; 15594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SIGCHECK({ 15604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(scratch); 15614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(str); 15624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 15634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm }); 15644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Break rem into digits. */ 15664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(ntostore > 0); 15674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do { 15684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit nextrem = (digit)(rem / base); 15694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char c = (char)(rem - nextrem * base); 15704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(p > PyString_AS_STRING(str)); 15714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c += (c < 10) ? '0' : 'a'-10; 15724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = c; 15734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem = nextrem; 15744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm --ntostore; 15754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Termination is a bit delicate: must not 15764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm store leading zeroes, so must get out if 15774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm remaining quotient and rem are both 0. */ 15784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } while (ntostore && (size || rem)); 15794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } while (size != 0); 15804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(scratch); 15814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 15834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (base == 2) { 15844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = 'b'; 15854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = '0'; 15864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (base == 8) { 15884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (newstyle) { 15894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = 'o'; 15904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = '0'; 15914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 15934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (size_a != 0) 15944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = '0'; 15954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 15964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (base == 16) { 15974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = 'x'; 15984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = '0'; 15994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 16004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (base != 10) { 16014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = '#'; 16024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = '0' + base%10; 16034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (base > 10) 16044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = '0' + base/10; 16054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 16064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (sign) 16074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--p = sign; 16084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (p != PyString_AS_STRING(str)) { 16094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *q = PyString_AS_STRING(str); 16104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(p > q); 16114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do { 16124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } while ((*q++ = *p++) != '\0'); 16134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm q--; 16144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _PyString_Resize((PyObject **)&str, 16154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (Py_ssize_t) (q - PyString_AS_STRING(str))); 16164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 16174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)str; 16184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 16194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Table of digit values for 8-bit string -> integer conversion. 16214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * '0' maps to 0, ..., '9' maps to 9. 16224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * 'a' and 'A' map to 10, ..., 'z' and 'Z' map to 35. 16234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * All other indices map to 37. 16244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * Note that when converting a base B string, a char c is a legitimate 16254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * base B digit iff _PyLong_DigitValue[Py_CHARMASK(c)] < B. 16264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 16274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint _PyLong_DigitValue[256] = { 16284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 37, 37, 37, 37, 37, 37, 16324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 16334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 37, 37, 37, 37, 16344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 16354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 37, 37, 37, 37, 37, 16364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 16444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 16454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* *str points to the first digit in a string of base `base` digits. base 16474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * is a power of 2 (2, 4, 8, 16, or 32). *str is set to point to the first 16484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * non-digit (which may be *str!). A normalized long is returned. 16494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * The point to this routine is that it takes time linear in the number of 16504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * string characters. 16514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 16524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyLongObject * 16534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_from_binary_base(char **str, int base) 16544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 16554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *p = *str; 16564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *start = p; 16574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int bits_per_char; 16584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t n; 16594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z; 16604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits accum; 16614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int bits_in_accum; 16624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *pdigit; 16634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(base >= 2 && base <= 32 && (base & (base - 1)) == 0); 16654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = base; 16664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (bits_per_char = -1; n; ++bits_per_char) 16674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n >>= 1; 16684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* n <- total # of bits needed, while setting p to end-of-string */ 16694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (_PyLong_DigitValue[Py_CHARMASK(*p)] < base) 16704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++p; 16714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *str = p; 16724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* n <- # of Python digits needed, = ceiling(n/PyLong_SHIFT). */ 16734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = (p - start) * bits_per_char + PyLong_SHIFT - 1; 16744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n / bits_per_char < p - start) { 16754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ValueError, 16764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "long string too large to convert"); 16774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 16784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 16794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = n / PyLong_SHIFT; 16804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(n); 16814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 16824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 16834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Read string from right, and fill in long from left; i.e., 16844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * from least to most significant in both. 16854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 16864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum = 0; 16874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bits_in_accum = 0; 16884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pdigit = z->ob_digit; 16894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--p >= start) { 16904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int k = _PyLong_DigitValue[Py_CHARMASK(*p)]; 16914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(k >= 0 && k < base); 16924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum |= (twodigits)k << bits_in_accum; 16934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bits_in_accum += bits_per_char; 16944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bits_in_accum >= PyLong_SHIFT) { 16954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pdigit++ = (digit)(accum & PyLong_MASK); 16964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(pdigit - z->ob_digit <= n); 16974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum >>= PyLong_SHIFT; 16984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bits_in_accum -= PyLong_SHIFT; 16994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(bits_in_accum < PyLong_SHIFT); 17004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bits_in_accum) { 17034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(bits_in_accum <= PyLong_SHIFT); 17044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pdigit++ = (digit)accum; 17054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(pdigit - z->ob_digit <= n); 17064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (pdigit - z->ob_digit < n) 17084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pdigit++ = 0; 17094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_normalize(z); 17104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 17114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 17134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_FromString(char *str, char **pend, int base) 17144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 17154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int sign = 1; 17164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *start, *orig_str = str; 17174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z; 17184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *strobj, *strrepr; 17194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t slen; 17204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((base != 0 && base < 2) || base > 36) { 17224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ValueError, 17234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "long() arg 2 must be >= 2 and <= 36"); 17244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 17254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (*str != '\0' && isspace(Py_CHARMASK(*str))) 17274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm str++; 17284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (*str == '+') 17294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++str; 17304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (*str == '-') { 17314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++str; 17324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = -1; 17334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (*str != '\0' && isspace(Py_CHARMASK(*str))) 17354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm str++; 17364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (base == 0) { 17374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* No base given. Deduce the base from the contents 17384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm of the string */ 17394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (str[0] != '0') 17404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base = 10; 17414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (str[1] == 'x' || str[1] == 'X') 17424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base = 16; 17434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (str[1] == 'o' || str[1] == 'O') 17444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base = 8; 17454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (str[1] == 'b' || str[1] == 'B') 17464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base = 2; 17474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 17484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* "old" (C-style) octal literal, still valid in 17494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2.x, although illegal in 3.x */ 17504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base = 8; 17514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 17524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Whether or not we were deducing the base, skip leading chars 17534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm as needed */ 17544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (str[0] == '0' && 17554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ((base == 16 && (str[1] == 'x' || str[1] == 'X')) || 17564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (base == 8 && (str[1] == 'o' || str[1] == 'O')) || 17574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (base == 2 && (str[1] == 'b' || str[1] == 'B')))) 17584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm str += 2; 17594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm start = str; 17614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((base & (base - 1)) == 0) 17624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = long_from_binary_base(&str, base); 17634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 17644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/*** 17654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmBinary bases can be converted in time linear in the number of digits, because 17664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPython's representation base is binary. Other bases (including decimal!) use 17674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmthe simple quadratic-time algorithm below, complicated by some speed tricks. 17684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmFirst some math: the largest integer that can be expressed in N base-B digits 17704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmis B**N-1. Consequently, if we have an N-digit input in base B, the worst- 17714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmcase number of Python digits needed to hold it is the smallest integer n s.t. 17724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLong_BASE**n-1 >= B**N-1 [or, adding 1 to both sides] 17744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLong_BASE**n >= B**N [taking logs to base PyLong_BASE] 17754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n >= log(B**N)/log(PyLong_BASE) = N * log(B)/log(PyLong_BASE) 17764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmThe static array log_base_PyLong_BASE[base] == log(base)/log(PyLong_BASE) so 17784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmwe can compute this quickly. A Python long with that much space is reserved 17794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmnear the start, and the result is computed into it. 17804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmThe input string is actually treated as being in base base**i (i.e., i digits 17824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmare processed at a time), where two more static arrays hold: 17834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm convwidth_base[base] = the largest integer i such that 17854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base**i <= PyLong_BASE 17864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm convmultmax_base[base] = base ** convwidth_base[base] 17874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmThe first of these is the largest i such that i consecutive input digits 17894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmmust fit in a single Python digit. The second is effectively the input 17904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbase we're really using. 17914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmViewing the input as a sequence <c0, c1, ..., c_n-1> of digits in base 17934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmconvmultmax_base[base], the result is "simply" 17944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (((c0*B + c1)*B + c2)*B + c3)*B + ... ))) + c_n-1 17964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmwhere B = convmultmax_base[base]. 17984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 17994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmError analysis: as above, the number of Python digits `n` needed is worst- 18004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmcase 18014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n >= N * log(B)/log(PyLong_BASE) 18034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmwhere `N` is the number of input digits in base `B`. This is computed via 18054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_z = (Py_ssize_t)((scan - str) * log_base_PyLong_BASE[base]) + 1; 18074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbelow. Two numeric concerns are how much space this can waste, and whether 18094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmthe computed result can be too small. To be concrete, assume PyLong_BASE = 18104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm2**15, which is the default (and it's unlikely anyone changes that). 18114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmWaste isn't a problem: provided the first input digit isn't 0, the difference 18134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbetween the worst-case input with N digits and the smallest input with N 18144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdigits is about a factor of B, but B is small compared to PyLong_BASE so at 18154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmmost one allocated Python digit can remain unused on that count. If 18164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmN*log(B)/log(PyLong_BASE) is mathematically an exact integer, then truncating 18174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmthat and adding 1 returns a result 1 larger than necessary. However, that 18184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmcan't happen: whenever B is a power of 2, long_from_binary_base() is called 18194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylminstead, and it's impossible for B**i to be an integer power of 2**15 when B 18204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmis not a power of 2 (i.e., it's impossible for N*log(B)/log(PyLong_BASE) to be 18214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylman exact integer when B is not a power of 2, since B**i has a prime factor 18224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmother than 2 in that case, but (2**15)**j's only prime factor is 2). 18234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmThe computed result can be too small if the true value of 18254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmN*log(B)/log(PyLong_BASE) is a little bit larger than an exact integer, but 18264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdue to roundoff errors (in computing log(B), log(PyLong_BASE), their quotient, 18274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmand/or multiplying that by N) yields a numeric result a little less than that 18284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylminteger. Unfortunately, "how close can a transcendental function get to an 18294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylminteger over some range?" questions are generally theoretically intractable. 18304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmComputer analysis via continued fractions is practical: expand 18314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlog(B)/log(PyLong_BASE) via continued fractions, giving a sequence i/j of "the 18324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbest" rational approximations. Then j*log(B)/log(PyLong_BASE) is 18334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmapproximately equal to (the integer) i. This shows that we can get very close 18344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmto being in trouble, but very rarely. For example, 76573 is a denominator in 18354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmone of the continued-fraction approximations to log(10)/log(2**15), and 18364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmindeed: 18374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm >>> log(10)/log(2**15)*76573 18394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 16958.000000654003 18404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmis very close to an integer. If we were working with IEEE single-precision, 18424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmrounding errors could kill us. Finding worst cases in IEEE double-precision 18434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmrequires better-than-double-precision log() functions, and Tim didn't bother. 18444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmInstead the code checks to see whether the allocated space is enough as each 18454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmnew Python digit is added, and copies the whole thing to a larger long if not. 18464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmThis should happen extremely rarely, and in fact I don't have a test case 18474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmthat triggers it(!). Instead the code was tested by artificially allocating 18484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmjust 1 digit at the start, so that the copying code was exercised for every 18494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdigit beyond the first. 18504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm***/ 18514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm register twodigits c; /* current input character */ 18524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size_z; 18534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i; 18544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int convwidth; 18554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits convmultmax, convmult; 18564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *pz, *pzstop; 18574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char* scan; 18584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm static double log_base_PyLong_BASE[37] = {0.0e0,}; 18604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm static int convwidth_base[37] = {0,}; 18614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm static twodigits convmultmax_base[37] = {0,}; 18624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (log_base_PyLong_BASE[base] == 0.0) { 18644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits convmax = base; 18654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int i = 1; 18664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm log_base_PyLong_BASE[base] = (log((double)base) / 18684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm log((double)PyLong_BASE)); 18694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (;;) { 18704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits next = convmax * base; 18714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (next > PyLong_BASE) 18724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 18734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm convmax = next; 18744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++i; 18754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm convmultmax_base[base] = convmax; 18774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(i > 0); 18784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm convwidth_base[base] = i; 18794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 18804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Find length of the string of numeric characters. */ 18824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm scan = str; 18834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (_PyLong_DigitValue[Py_CHARMASK(*scan)] < base) 18844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++scan; 18854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 18864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Create a long object that can contain the largest possible 18874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * integer with this base and length. Note that there's no 18884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * need to initialize z->ob_digit -- no slot is read up before 18894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * being stored into. 18904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 18914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_z = (Py_ssize_t)((scan - str) * log_base_PyLong_BASE[base]) + 1; 18924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Uncomment next line to test exceedingly rare copy code */ 18934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* size_z = 1; */ 18944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(size_z > 0); 18954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(size_z); 18964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 18974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 18984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(z) = 0; 18994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* `convwidth` consecutive input digits are treated as a single 19014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * digit in base `convmultmax`. 19024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 19034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm convwidth = convwidth_base[base]; 19044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm convmultmax = convmultmax_base[base]; 19054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Work ;-) */ 19074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (str < scan) { 19084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* grab up to convwidth digits from the input string */ 19094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = (digit)_PyLong_DigitValue[Py_CHARMASK(*str++)]; 19104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 1; i < convwidth && str != scan; ++i, ++str) { 19114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = (twodigits)(c * base + 19124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _PyLong_DigitValue[Py_CHARMASK(*str)]); 19134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(c < PyLong_BASE); 19144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm convmult = convmultmax; 19174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Calculate the shift only if we couldn't get 19184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * convwidth digits. 19194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 19204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i != convwidth) { 19214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm convmult = base; 19224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for ( ; i > 1; --i) 19234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm convmult *= base; 19244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Multiply z by convmult, and add c. */ 19274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pz = z->ob_digit; 19284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pzstop = pz + Py_SIZE(z); 19294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; pz < pzstop; ++pz) { 19304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c += (twodigits)*pz * convmult; 19314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pz = (digit)(c & PyLong_MASK); 19324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c >>= PyLong_SHIFT; 19334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* carry off the current end? */ 19354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c) { 19364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(c < PyLong_BASE); 19374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(z) < size_z) { 19384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pz = (digit)c; 19394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++Py_SIZE(z); 19404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 19424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *tmp; 19434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Extremely rare. Get more space. */ 19444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(Py_SIZE(z) == size_z); 19454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp = _PyLong_New(size_z + 1); 19464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tmp == NULL) { 19474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(z); 19484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 19494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(tmp->ob_digit, 19514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit, 19524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sizeof(digit) * size_z); 19534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(z); 19544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = tmp; 19554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[size_z] = (digit)c; 19564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++size_z; 19574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 19614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 19624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 19634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (str == start) 19644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto onError; 19654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (sign < 0) 19664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(z) = -(Py_SIZE(z)); 19674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (*str == 'L' || *str == 'l') 19684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm str++; 19694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (*str && isspace(Py_CHARMASK(*str))) 19704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm str++; 19714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (*str != '\0') 19724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto onError; 19734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pend) 19744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pend = str; 19754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *) z; 19764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm onError: 19784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(z); 19794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm slen = strlen(orig_str) < 200 ? strlen(orig_str) : 200; 19804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm strobj = PyString_FromStringAndSize(orig_str, slen); 19814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (strobj == NULL) 19824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 19834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm strrepr = PyObject_Repr(strobj); 19844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(strobj); 19854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (strrepr == NULL) 19864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 19874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_ValueError, 19884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "invalid literal for long() with base %d: %s", 19894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base, PyString_AS_STRING(strrepr)); 19904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(strrepr); 19914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 19924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 19934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 19944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 19954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 19964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_FromUnicode(Py_UNICODE *u, Py_ssize_t length, int base) 19974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 19984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *result; 19994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *buffer = (char *)PyMem_MALLOC(length+1); 20004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (buffer == NULL) 20024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 20034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyUnicode_EncodeDecimal(u, length, buffer, NULL)) { 20054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyMem_FREE(buffer); 20064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 20074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = PyLong_FromString(buffer, NULL, base); 20094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyMem_FREE(buffer); 20104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 20114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 20124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 20134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* forward */ 20154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyLongObject *x_divrem 20164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (PyLongObject *, PyLongObject *, PyLongObject **); 20174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject *long_long(PyObject *v); 20184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Long division with remainder, top-level routine */ 20204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 20224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_divrem(PyLongObject *a, PyLongObject *b, 20234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject **pdiv, PyLongObject **prem) 20244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 20254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); 20264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z; 20274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (size_b == 0) { 20294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ZeroDivisionError, 20304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "long division or modulo by zero"); 20314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 20324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (size_a < size_b || 20344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (size_a == size_b && 20354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a->ob_digit[size_a-1] < b->ob_digit[size_b-1])) { 20364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* |a| < |b|. */ 20374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pdiv = _PyLong_New(0); 20384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (*pdiv == NULL) 20394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 20404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(a); 20414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *prem = (PyLongObject *) a; 20424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 20434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (size_b == 1) { 20454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit rem = 0; 20464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = divrem1(a, b->ob_digit[0], &rem); 20474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 20484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 20494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *prem = (PyLongObject *) PyLong_FromLong((long)rem); 20504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (*prem == NULL) { 20514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(z); 20524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 20534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 20564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = x_divrem(a, b, prem); 20574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 20584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 20594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 20604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Set the signs. 20614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The quotient z has the sign of a*b; 20624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the remainder r has the sign of a, 20634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm so a = b*z + r. */ 20644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((a->ob_size < 0) != (b->ob_size < 0)) 20654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_size = -(z->ob_size); 20664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a->ob_size < 0 && (*prem)->ob_size != 0) 20674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (*prem)->ob_size = -((*prem)->ob_size); 20684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pdiv = z; 20694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 20704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 20714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Unsigned long division with remainder -- the algorithm. The arguments v1 20734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm and w1 should satisfy 2 <= ABS(Py_SIZE(w1)) <= ABS(Py_SIZE(v1)). */ 20744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyLongObject * 20764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmx_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem) 20774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 20784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *v, *w, *a; 20794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i, k, size_v, size_w; 20804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int d; 20814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit wm1, wm2, carry, q, r, vtop, *v0, *vk, *w0, *ak; 20824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits vv; 20834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sdigit zhi; 20844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm stwodigits z; 20854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* We follow Knuth [The Art of Computer Programming, Vol. 2 (3rd 20874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm edn.), section 4.3.1, Algorithm D], except that we don't explicitly 20884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm handle the special case when the initial estimate q for a quotient 20894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit is >= PyLong_BASE: the max value for q is PyLong_BASE+1, and 20904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm that won't overflow a digit. */ 20914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 20924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* allocate space; w will also be used to hold the final remainder */ 20934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_v = ABS(Py_SIZE(v1)); 20944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_w = ABS(Py_SIZE(w1)); 20954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(size_v >= size_w && size_w >= 2); /* Assert checks by div() */ 20964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = _PyLong_New(size_v+1); 20974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL) { 20984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *prem = NULL; 20994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 21004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = _PyLong_New(size_w); 21024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == NULL) { 21034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 21044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *prem = NULL; 21054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 21064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* normalize: shift w1 left so that its top digit is >= PyLong_BASE/2. 21094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shift v1 left by the same amount. Results go into w and v. */ 21104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d = PyLong_SHIFT - bits_in_digit(w1->ob_digit[size_w-1]); 21114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry = v_lshift(w->ob_digit, w1->ob_digit, size_w, d); 21124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(carry == 0); 21134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry = v_lshift(v->ob_digit, v1->ob_digit, size_v, d); 21144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (carry != 0 || v->ob_digit[size_v-1] >= w->ob_digit[size_w-1]) { 21154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v->ob_digit[size_v] = carry; 21164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_v++; 21174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Now v->ob_digit[size_v-1] < w->ob_digit[size_w-1], so quotient has 21204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm at most (and usually exactly) k = size_v - size_w digits. */ 21214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm k = size_v - size_w; 21224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(k >= 0); 21234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = _PyLong_New(k); 21244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a == NULL) { 21254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 21264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 21274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *prem = NULL; 21284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 21294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v0 = v->ob_digit; 21314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w0 = w->ob_digit; 21324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm wm1 = w0[size_w-1]; 21334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm wm2 = w0[size_w-2]; 21344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (vk = v0+k, ak = a->ob_digit + k; vk-- > v0;) { 21354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* inner loop: divide vk[0:size_w+1] by w0[0:size_w], giving 21364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm single-digit quotient q, remainder in vk[0:size_w]. */ 21374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SIGCHECK({ 21394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 21404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 21414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 21424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *prem = NULL; 21434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 21444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm }); 21454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* estimate quotient digit q; may overestimate by 1 (rare) */ 21474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm vtop = vk[size_w]; 21484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(vtop <= wm1); 21494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm vv = ((twodigits)vtop << PyLong_SHIFT) | vk[size_w-1]; 21504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm q = (digit)(vv / wm1); 21514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r = (digit)(vv - (twodigits)wm1 * q); /* r = vv % wm1 */ 21524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while ((twodigits)wm2 * q > (((twodigits)r << PyLong_SHIFT) 21534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm | vk[size_w-2])) { 21544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm --q; 21554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm r += wm1; 21564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (r >= PyLong_BASE) 21574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 21584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(q <= PyLong_BASE); 21604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* subtract q*w0[0:size_w] from vk[0:size_w+1] */ 21624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm zhi = 0; 21634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < size_w; ++i) { 21644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* invariants: -PyLong_BASE <= -q <= zhi <= 0; 21654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm -PyLong_BASE * q <= z < PyLong_BASE */ 21664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = (sdigit)vk[i] + zhi - 21674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (stwodigits)q * (stwodigits)w0[i]; 21684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm vk[i] = (digit)z & PyLong_MASK; 21694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm zhi = (sdigit)Py_ARITHMETIC_RIGHT_SHIFT(stwodigits, 21704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z, PyLong_SHIFT); 21714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* add w back if q was too large (this branch taken rarely) */ 21744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert((sdigit)vtop + zhi == -1 || (sdigit)vtop + zhi == 0); 21754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((sdigit)vtop + zhi < 0) { 21764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry = 0; 21774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < size_w; ++i) { 21784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry += vk[i] + w0[i]; 21794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm vk[i] = carry & PyLong_MASK; 21804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry >>= PyLong_SHIFT; 21814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm --q; 21834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* store quotient digit */ 21864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(q < PyLong_BASE); 21874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *--ak = q; 21884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 21894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* unshift remainder; we reuse w to store the result */ 21914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry = v_rshift(w0, v0, size_w, d); 21924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(carry==0); 21934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(v); 21944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *prem = long_normalize(w); 21964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_normalize(a); 21974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 21984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 21994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* For a nonzero PyLong a, express a in the form x * 2**e, with 0.5 <= 22004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm abs(x) < 1.0 and e >= 0; return x and put e in *e. Here x is 22014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rounded to DBL_MANT_DIG significant bits using round-half-to-even. 22024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm If a == 0, return 0.0 and set *e = 0. If the resulting exponent 22034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm e is larger than PY_SSIZE_T_MAX, raise OverflowError and return 22044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm -1.0. */ 22054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* attempt to define 2.0**DBL_MANT_DIG as a compile-time constant */ 22074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if DBL_MANT_DIG == 53 22084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define EXP2_DBL_MANT_DIG 9007199254740992.0 22094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#else 22104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define EXP2_DBL_MANT_DIG (ldexp(1.0, DBL_MANT_DIG)) 22114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 22124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdouble 22144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyLong_Frexp(PyLongObject *a, Py_ssize_t *e) 22154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 22164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t a_size, a_bits, shift_digits, shift_bits, x_size; 22174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* See below for why x_digits is always large enough. */ 22184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit rem, x_digits[2 + (DBL_MANT_DIG + 1) / PyLong_SHIFT]; 22194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm double dx; 22204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Correction term for round-half-to-even rounding. For a digit x, 22214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "x + half_even_correction[x & 7]" gives x rounded to the nearest 22224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm multiple of 4, rounding ties to a multiple of 8. */ 22234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm static const int half_even_correction[8] = {0, -1, -2, 1, 0, -1, 2, 1}; 22244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_size = ABS(Py_SIZE(a)); 22264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a_size == 0) { 22274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Special case for 0: significand 0.0, exponent 0. */ 22284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *e = 0; 22294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0.0; 22304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_bits = bits_in_digit(a->ob_digit[a_size-1]); 22324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The following is an overflow-free version of the check 22334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "if ((a_size - 1) * PyLong_SHIFT + a_bits > PY_SSIZE_T_MAX) ..." */ 22344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a_size >= (PY_SSIZE_T_MAX - 1) / PyLong_SHIFT + 1 && 22354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (a_size > (PY_SSIZE_T_MAX - 1) / PyLong_SHIFT + 1 || 22364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_bits > (PY_SSIZE_T_MAX - 1) % PyLong_SHIFT + 1)) 22374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto overflow; 22384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_bits = (a_size - 1) * PyLong_SHIFT + a_bits; 22394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Shift the first DBL_MANT_DIG + 2 bits of a into x_digits[0:x_size] 22414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (shifting left if a_bits <= DBL_MANT_DIG + 2). 22424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Number of digits needed for result: write // for floor division. 22444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Then if shifting left, we end up using 22454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1 + a_size + (DBL_MANT_DIG + 2 - a_bits) // PyLong_SHIFT 22474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digits. If shifting right, we use 22494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_size - (a_bits - DBL_MANT_DIG - 2) // PyLong_SHIFT 22514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digits. Using a_size = 1 + (a_bits - 1) // PyLong_SHIFT along with 22534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the inequalities 22544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm m // PyLong_SHIFT + n // PyLong_SHIFT <= (m + n) // PyLong_SHIFT 22564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm m // PyLong_SHIFT - n // PyLong_SHIFT <= 22574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1 + (m - n - 1) // PyLong_SHIFT, 22584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm valid for any integers m and n, we find that x_size satisfies 22604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_size <= 2 + (DBL_MANT_DIG + 1) // PyLong_SHIFT 22624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm in both cases. 22644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 22654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a_bits <= DBL_MANT_DIG + 2) { 22664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shift_digits = (DBL_MANT_DIG + 2 - a_bits) / PyLong_SHIFT; 22674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shift_bits = (DBL_MANT_DIG + 2 - a_bits) % PyLong_SHIFT; 22684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_size = 0; 22694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (x_size < shift_digits) 22704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_digits[x_size++] = 0; 22714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem = v_lshift(x_digits + x_size, a->ob_digit, a_size, 22724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (int)shift_bits); 22734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_size += a_size; 22744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_digits[x_size++] = rem; 22754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 22774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shift_digits = (a_bits - DBL_MANT_DIG - 2) / PyLong_SHIFT; 22784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shift_bits = (a_bits - DBL_MANT_DIG - 2) % PyLong_SHIFT; 22794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem = v_rshift(x_digits, a->ob_digit + shift_digits, 22804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_size - shift_digits, (int)shift_bits); 22814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_size = a_size - shift_digits; 22824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* For correct rounding below, we need the least significant 22834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bit of x to be 'sticky' for this shift: if any of the bits 22844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shifted out was nonzero, we set the least significant bit 22854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm of x. */ 22864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (rem) 22874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_digits[0] |= 1; 22884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 22894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (shift_digits > 0) 22904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a->ob_digit[--shift_digits]) { 22914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_digits[0] |= 1; 22924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 22934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 22954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(1 <= x_size && 22964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_size <= (Py_ssize_t)(sizeof(x_digits)/sizeof(digit))); 22974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 22984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Round, and convert to double. */ 22994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_digits[0] += half_even_correction[x_digits[0] & 7]; 23004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dx = x_digits[--x_size]; 23014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (x_size > 0) 23024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dx = dx * PyLong_BASE + x_digits[--x_size]; 23034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Rescale; make correction if result is 1.0. */ 23054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dx /= 4.0 * EXP2_DBL_MANT_DIG; 23064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (dx == 1.0) { 23074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a_bits == PY_SSIZE_T_MAX) 23084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto overflow; 23094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dx = 0.5; 23104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_bits += 1; 23114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *e = a_bits; 23144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_SIZE(a) < 0 ? -dx : dx; 23154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm overflow: 23174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* exponent > PY_SSIZE_T_MAX */ 23184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 23194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "huge integer: number of bits overflows a Py_ssize_t"); 23204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *e = 0; 23214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1.0; 23224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 23234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Get a C double from a long int object. Rounds to the nearest double, 23254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm using the round-half-to-even rule in the case of a tie. */ 23264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdouble 23284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_AsDouble(PyObject *v) 23294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 23304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t exponent; 23314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm double x; 23324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v == NULL || !PyLong_Check(v)) { 23344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadInternalCall(); 23354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1.0; 23364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = _PyLong_Frexp((PyLongObject *)v, &exponent); 23384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((x == -1.0 && PyErr_Occurred()) || exponent > DBL_MAX_EXP) { 23394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 23404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "long int too large to convert to float"); 23414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1.0; 23424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return ldexp(x, (int)exponent); 23444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 23454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Methods */ 23474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void 23494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_dealloc(PyObject *v) 23504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 23514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_TYPE(v)->tp_free(v); 23524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 23534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 23554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_repr(PyObject *v) 23564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 23574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyLong_Format(v, 10, 1, 0); 23584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 23594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 23614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_str(PyObject *v) 23624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 23634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyLong_Format(v, 10, 0, 0); 23644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 23654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 23674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_compare(PyLongObject *a, PyLongObject *b) 23684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 23694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t sign; 23704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(a) != Py_SIZE(b)) { 23724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = Py_SIZE(a) - Py_SIZE(b); 23734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 23754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i = ABS(Py_SIZE(a)); 23764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i]) 23774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ; 23784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i < 0) 23794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = 0; 23804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 23814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = (sdigit)a->ob_digit[i] - (sdigit)b->ob_digit[i]; 23824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(a) < 0) 23834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = -sign; 23844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 23864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return sign < 0 ? -1 : sign > 0 ? 1 : 0; 23874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 23884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic long 23904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_hash(PyLongObject *v) 23914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 23924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unsigned long x; 23934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 23944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int sign; 23954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 23964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This is designed so that Python ints and longs with the 23974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm same value hash to the same value, otherwise comparisons 23984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm of mapping keys will turn out weird */ 23994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = v->ob_size; 24004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = 1; 24014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0; 24024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i < 0) { 24034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = -1; 24044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = -(i); 24054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The following loop produces a C unsigned long x such that x is 24074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm congruent to the absolute value of v modulo ULONG_MAX. The 24084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm resulting x is nonzero if and only if v is. */ 24094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--i >= 0) { 24104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Force a native long #-bits (32 or 64) circular shift */ 24114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (x >> (8*SIZEOF_LONG-PyLong_SHIFT)) | (x << PyLong_SHIFT); 24124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x += v->ob_digit[i]; 24134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* If the addition above overflowed we compensate by 24144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm incrementing. This preserves the value modulo 24154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ULONG_MAX. */ 24164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x < v->ob_digit[i]) 24174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x++; 24184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = x * sign; 24204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == (unsigned long)-1) 24214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (unsigned long)-2; 24224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (long)x; 24234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 24244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Add the absolute values of two long integers. */ 24274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyLongObject * 24294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmx_add(PyLongObject *a, PyLongObject *b) 24304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 24314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); 24324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z; 24334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 24344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit carry = 0; 24354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Ensure a is the larger of the two: */ 24374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (size_a < size_b) { 24384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { PyLongObject *temp = a; a = b; b = temp; } 24394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { Py_ssize_t size_temp = size_a; 24404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_a = size_b; 24414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_b = size_temp; } 24424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(size_a+1); 24444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 24454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 24464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < size_b; ++i) { 24474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry += a->ob_digit[i] + b->ob_digit[i]; 24484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = carry & PyLong_MASK; 24494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry >>= PyLong_SHIFT; 24504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; i < size_a; ++i) { 24524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry += a->ob_digit[i]; 24534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = carry & PyLong_MASK; 24544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry >>= PyLong_SHIFT; 24554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = carry; 24574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_normalize(z); 24584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 24594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Subtract the absolute values of two integers. */ 24614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyLongObject * 24634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmx_sub(PyLongObject *a, PyLongObject *b) 24644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 24654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size_a = ABS(Py_SIZE(a)), size_b = ABS(Py_SIZE(b)); 24664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z; 24674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 24684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int sign = 1; 24694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit borrow = 0; 24704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Ensure a is the larger of the two: */ 24724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (size_a < size_b) { 24734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = -1; 24744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { PyLongObject *temp = a; a = b; b = temp; } 24754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { Py_ssize_t size_temp = size_a; 24764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_a = size_b; 24774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_b = size_temp; } 24784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (size_a == size_b) { 24804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Find highest digit where a and b differ: */ 24814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = size_a; 24824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i]) 24834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ; 24844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i < 0) 24854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyLong_New(0); 24864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a->ob_digit[i] < b->ob_digit[i]) { 24874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sign = -1; 24884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm { PyLongObject *temp = a; a = b; b = temp; } 24894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_a = size_b = i+1; 24914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 24924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(size_a); 24934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 24944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 24954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < size_b; ++i) { 24964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The following assumes unsigned arithmetic 24974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm works module 2**N for some N>PyLong_SHIFT. */ 24984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow = a->ob_digit[i] - b->ob_digit[i] - borrow; 24994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = borrow & PyLong_MASK; 25004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow >>= PyLong_SHIFT; 25014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow &= 1; /* Keep only one sign bit */ 25024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; i < size_a; ++i) { 25044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow = a->ob_digit[i] - borrow; 25054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = borrow & PyLong_MASK; 25064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow >>= PyLong_SHIFT; 25074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm borrow &= 1; /* Keep only one sign bit */ 25084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(borrow == 0); 25104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (sign < 0) 25114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_size = -(z->ob_size); 25124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_normalize(z); 25134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 25144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 25164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_add(PyLongObject *v, PyLongObject *w) 25174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 25184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b, *z; 25194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); 25214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a->ob_size < 0) { 25234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (b->ob_size < 0) { 25244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = x_add(a, b); 25254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z != NULL && z->ob_size != 0) 25264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_size = -(z->ob_size); 25274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 25294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = x_sub(b, a); 25304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 25324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (b->ob_size < 0) 25334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = x_sub(a, b); 25344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 25354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = x_add(a, b); 25364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 25384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 25394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)z; 25404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 25414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 25434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_sub(PyLongObject *v, PyLongObject *w) 25444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 25454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b, *z; 25464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); 25484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a->ob_size < 0) { 25504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (b->ob_size < 0) 25514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = x_sub(a, b); 25524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 25534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = x_add(a, b); 25544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z != NULL && z->ob_size != 0) 25554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_size = -(z->ob_size); 25564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 25584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (b->ob_size < 0) 25594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = x_add(a, b); 25604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 25614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = x_sub(a, b); 25624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 25634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 25644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 25654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)z; 25664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 25674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Grade school multiplication, ignoring the signs. 25694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * Returns the absolute value of the product, or NULL if error. 25704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 25714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyLongObject * 25724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmx_mul(PyLongObject *a, PyLongObject *b) 25734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 25744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z; 25754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size_a = ABS(Py_SIZE(a)); 25764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size_b = ABS(Py_SIZE(b)); 25774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 25784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(size_a + size_b); 25804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 25814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 25824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memset(z->ob_digit, 0, Py_SIZE(z) * sizeof(digit)); 25844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a == b) { 25854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Efficient squaring per HAC, Algorithm 14.16: 25864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf 25874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * Gives slightly less than a 2x speedup when a == b, 25884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * via exploiting that each entry in the multiplication 25894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * pyramid appears twice (except for the size_a squares). 25904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 25914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < size_a; ++i) { 25924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits carry; 25934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits f = a->ob_digit[i]; 25944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *pz = z->ob_digit + (i << 1); 25954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *pa = a->ob_digit + i + 1; 25964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *paend = a->ob_digit + size_a; 25974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 25984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SIGCHECK({ 25994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(z); 26004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 26014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm }); 26024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry = *pz + f * f; 26044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pz++ = (digit)(carry & PyLong_MASK); 26054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry >>= PyLong_SHIFT; 26064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(carry <= PyLong_MASK); 26074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Now f is added in twice in each column of the 26094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * pyramid it appears. Same as adding f<<1 once. 26104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 26114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f <<= 1; 26124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (pa < paend) { 26134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry += *pz + *pa++ * f; 26144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pz++ = (digit)(carry & PyLong_MASK); 26154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry >>= PyLong_SHIFT; 26164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(carry <= (PyLong_MASK << 1)); 26174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (carry) { 26194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry += *pz; 26204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pz++ = (digit)(carry & PyLong_MASK); 26214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry >>= PyLong_SHIFT; 26224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (carry) 26244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pz += (digit)(carry & PyLong_MASK); 26254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert((carry >> PyLong_SHIFT) == 0); 26264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { /* a is not the same as b -- gradeschool long mult */ 26294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < size_a; ++i) { 26304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits carry = 0; 26314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits f = a->ob_digit[i]; 26324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *pz = z->ob_digit + i; 26334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *pb = b->ob_digit; 26344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit *pbend = b->ob_digit + size_b; 26354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm SIGCHECK({ 26374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(z); 26384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 26394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm }); 26404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (pb < pbend) { 26424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry += *pz + *pb++ * f; 26434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pz++ = (digit)(carry & PyLong_MASK); 26444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry >>= PyLong_SHIFT; 26454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(carry <= PyLong_MASK); 26464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (carry) 26484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pz += (digit)(carry & PyLong_MASK); 26494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert((carry >> PyLong_SHIFT) == 0); 26504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_normalize(z); 26534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 26544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* A helper for Karatsuba multiplication (k_mul). 26564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Takes a long "n" and an integer "size" representing the place to 26574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm split, and sets low and high such that abs(n) == (high << size) + low, 26584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm viewing the shift as being by digits. The sign bit is ignored, and 26594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the return values are >= 0. 26604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Returns 0 on success, -1 on failure. 26614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 26624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 26634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmkmul_split(PyLongObject *n, 26644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size, 26654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject **high, 26664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject **low) 26674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 26684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *hi, *lo; 26694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size_lo, size_hi; 26704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const Py_ssize_t size_n = ABS(Py_SIZE(n)); 26714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_lo = MIN(size_n, size); 26734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_hi = size_n - size_lo; 26744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((hi = _PyLong_New(size_hi)) == NULL) 26764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 26774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((lo = _PyLong_New(size_lo)) == NULL) { 26784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(hi); 26794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 26804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 26814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(lo->ob_digit, n->ob_digit, size_lo * sizeof(digit)); 26834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(hi->ob_digit, n->ob_digit + size_lo, size_hi * sizeof(digit)); 26844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *high = long_normalize(hi); 26864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *low = long_normalize(lo); 26874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 26884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 26894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyLongObject *k_lopsided_mul(PyLongObject *a, PyLongObject *b); 26914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 26924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Karatsuba multiplication. Ignores the input signs, and returns the 26934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * absolute value of the product (or NULL if error). 26944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * See Knuth Vol. 2 Chapter 4.3.3 (Pp. 294-295). 26954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 26964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyLongObject * 26974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmk_mul(PyLongObject *a, PyLongObject *b) 26984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 26994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t asize = ABS(Py_SIZE(a)); 27004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t bsize = ABS(Py_SIZE(b)); 27014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *ah = NULL; 27024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *al = NULL; 27034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *bh = NULL; 27044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *bl = NULL; 27054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *ret = NULL; 27064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *t1, *t2, *t3; 27074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t shift; /* the number of digits we split off */ 27084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 27094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* (ah*X+al)(bh*X+bl) = ah*bh*X*X + (ah*bl + al*bh)*X + al*bl 27114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * Let k = (ah+al)*(bh+bl) = ah*bl + al*bh + ah*bh + al*bl 27124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * Then the original product is 27134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * ah*bh*X*X + (k - ah*bh - al*bl)*X + al*bl 27144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * By picking X to be a power of 2, "*X" is just shifting, and it's 27154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * been reduced to 3 multiplies on numbers half the size. 27164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 27174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* We want to split based on the larger number; fiddle so that b 27194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * is largest. 27204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 27214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (asize > bsize) { 27224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t1 = a; 27234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = b; 27244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = t1; 27254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = asize; 27274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm asize = bsize; 27284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bsize = i; 27294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Use gradeschool math when either number is too small. */ 27324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = a == b ? KARATSUBA_SQUARE_CUTOFF : KARATSUBA_CUTOFF; 27334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (asize <= i) { 27344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (asize == 0) 27354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyLong_New(0); 27364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 27374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return x_mul(a, b); 27384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* If a is small compared to b, splitting on b gives a degenerate 27414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * case with ah==0, and Karatsuba may be (even much) less efficient 27424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * than "grade school" then. However, we can still win, by viewing 27434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * b as a string of "big digits", each of width a->ob_size. That 27444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * leads to a sequence of balanced calls to k_mul. 27454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 27464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (2 * asize <= bsize) 27474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return k_lopsided_mul(a, b); 27484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Split a & b into hi & lo pieces. */ 27504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shift = bsize >> 1; 27514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (kmul_split(a, shift, &ah, &al) < 0) goto fail; 27524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(Py_SIZE(ah) > 0); /* the split isn't degenerate */ 27534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a == b) { 27554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bh = ah; 27564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bl = al; 27574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(bh); 27584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(bl); 27594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 27604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (kmul_split(b, shift, &bh, &bl) < 0) goto fail; 27614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The plan: 27634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * 1. Allocate result space (asize + bsize digits: that's always 27644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * enough). 27654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * 2. Compute ah*bh, and copy into result at 2*shift. 27664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * 3. Compute al*bl, and copy into result at 0. Note that this 27674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * can't overlap with #2. 27684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * 4. Subtract al*bl from the result, starting at shift. This may 27694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * underflow (borrow out of the high digit), but we don't care: 27704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * we're effectively doing unsigned arithmetic mod 27714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * PyLong_BASE**(sizea + sizeb), and so long as the *final* result fits, 27724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * borrows and carries out of the high digit can be ignored. 27734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * 5. Subtract ah*bh from the result, starting at shift. 27744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * 6. Compute (ah+al)*(bh+bl), and add it into the result starting 27754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * at shift. 27764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 27774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* 1. Allocate result space. */ 27794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = _PyLong_New(asize + bsize); 27804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret == NULL) goto fail; 27814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_DEBUG 27824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Fill with trash, to catch reference to uninitialized digits. */ 27834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memset(ret->ob_digit, 0xDF, Py_SIZE(ret) * sizeof(digit)); 27844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 27854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* 2. t1 <- ah*bh, and copy into high digits of result. */ 27874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((t1 = k_mul(ah, bh)) == NULL) goto fail; 27884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(Py_SIZE(t1) >= 0); 27894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(2*shift + Py_SIZE(t1) <= Py_SIZE(ret)); 27904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(ret->ob_digit + 2*shift, t1->ob_digit, 27914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(t1) * sizeof(digit)); 27924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Zero-out the digits higher than the ah*bh copy. */ 27944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = Py_SIZE(ret) - 2*shift - Py_SIZE(t1); 27954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i) 27964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memset(ret->ob_digit + 2*shift + Py_SIZE(t1), 0, 27974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i * sizeof(digit)); 27984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 27994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* 3. t2 <- al*bl, and copy into the low digits. */ 28004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((t2 = k_mul(al, bl)) == NULL) { 28014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(t1); 28024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 28034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(Py_SIZE(t2) >= 0); 28054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(Py_SIZE(t2) <= 2*shift); /* no overlap with high digits */ 28064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(ret->ob_digit, t2->ob_digit, Py_SIZE(t2) * sizeof(digit)); 28074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Zero out remaining digits. */ 28094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = 2*shift - Py_SIZE(t2); /* number of uninitialized digits */ 28104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i) 28114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memset(ret->ob_digit + Py_SIZE(t2), 0, i * sizeof(digit)); 28124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* 4 & 5. Subtract ah*bh (t1) and al*bl (t2). We do al*bl first 28144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * because it's fresher in cache. 28154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 28164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = Py_SIZE(ret) - shift; /* # digits after shift */ 28174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, Py_SIZE(t2)); 28184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(t2); 28194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, Py_SIZE(t1)); 28214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(t1); 28224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* 6. t3 <- (ah+al)(bh+bl), and add into result. */ 28244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((t1 = x_add(ah, al)) == NULL) goto fail; 28254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(ah); 28264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(al); 28274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ah = al = NULL; 28284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a == b) { 28304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t2 = t1; 28314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(t2); 28324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if ((t2 = x_add(bh, bl)) == NULL) { 28344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(t1); 28354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 28364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 28374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(bh); 28384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(bl); 28394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bh = bl = NULL; 28404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t3 = k_mul(t1, t2); 28424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(t1); 28434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(t2); 28444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (t3 == NULL) goto fail; 28454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(Py_SIZE(t3) >= 0); 28464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Add t3. It's not obvious why we can't run out of room here. 28484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * See the (*) comment after this function. 28494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 28504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, Py_SIZE(t3)); 28514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(t3); 28524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_normalize(ret); 28544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fail: 28564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(ret); 28574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(ah); 28584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(al); 28594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(bh); 28604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(bl); 28614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 28624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 28634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* (*) Why adding t3 can't "run out of room" above. 28654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmLet f(x) mean the floor of x and c(x) mean the ceiling of x. Some facts 28674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmto start with: 28684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm1. For any integer i, i = c(i/2) + f(i/2). In particular, 28704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bsize = c(bsize/2) + f(bsize/2). 28714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm2. shift = f(bsize/2) 28724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm3. asize <= bsize 28734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm4. Since we call k_lopsided_mul if asize*2 <= bsize, asize*2 > bsize in this 28744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm routine, so asize > bsize/2 >= f(bsize/2) in this routine. 28754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmWe allocated asize + bsize result digits, and add t3 into them at an offset 28774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmof shift. This leaves asize+bsize-shift allocated digit positions for t3 28784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmto fit into, = (by #1 and #2) asize + f(bsize/2) + c(bsize/2) - f(bsize/2) = 28794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmasize + c(bsize/2) available digit positions. 28804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbh has c(bsize/2) digits, and bl at most f(size/2) digits. So bh+hl has 28824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmat most c(bsize/2) digits + 1 bit. 28834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmIf asize == bsize, ah has c(bsize/2) digits, else ah has at most f(bsize/2) 28854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdigits, and al has at most f(bsize/2) digits in any case. So ah+al has at 28864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmmost (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 1 bit. 28874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmThe product (ah+al)*(bh+bl) therefore has at most 28894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c(bsize/2) + (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 2 bits 28914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 28924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmand we have asize + c(bsize/2) available digit positions. We need to show 28934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmthis is always enough. An instance of c(bsize/2) cancels out in both, so 28944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmthe question reduces to whether asize digits is enough to hold 28954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm(asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 2 bits. If asize < bsize, 28964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmthen we're asking whether asize digits >= f(bsize/2) digits + 2 bits. By #4, 28974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmasize is at least f(bsize/2)+1 digits, so this in turn reduces to whether 1 28984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdigit is enough to hold 2 bits. This is so since PyLong_SHIFT=15 >= 2. If 28994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmasize == bsize, then we're asking whether bsize digits is enough to hold 29004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmc(bsize/2) digits + 2 bits, or equivalently (by #1) whether f(bsize/2) digits 29014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmis enough to hold 2 bits. This is so if bsize >= 2, which holds because 29024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbsize >= KARATSUBA_CUTOFF >= 2. 29034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmNote that since there's always enough room for (ah+al)*(bh+bl), and that's 29054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclearly >= each of ah*bh and al*bl, there's always enough room to subtract 29064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmah*bh and al*bl too. 29074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 29084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* b has at least twice the digits of a, and a is big enough that Karatsuba 29104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * would pay off *if* the inputs had balanced sizes. View b as a sequence 29114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * of slices, each with a->ob_size digits, and multiply the slices by a, 29124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * one at a time. This gives k_mul balanced inputs to work with, and is 29134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * also cache-friendly (we compute one double-width slice of the result 29144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * at a time, then move on, never backtracking except for the helpful 29154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * single-width slice overlap between successive partial sums). 29164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 29174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyLongObject * 29184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmk_lopsided_mul(PyLongObject *a, PyLongObject *b) 29194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 29204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const Py_ssize_t asize = ABS(Py_SIZE(a)); 29214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t bsize = ABS(Py_SIZE(b)); 29224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t nbdone; /* # of b digits already multiplied */ 29234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *ret; 29244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *bslice = NULL; 29254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(asize > KARATSUBA_CUTOFF); 29274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(2 * asize <= bsize); 29284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Allocate result space, and zero it out. */ 29304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ret = _PyLong_New(asize + bsize); 29314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ret == NULL) 29324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 29334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memset(ret->ob_digit, 0, Py_SIZE(ret) * sizeof(digit)); 29344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Successive slices of b are copied into bslice. */ 29364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bslice = _PyLong_New(asize); 29374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bslice == NULL) 29384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 29394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nbdone = 0; 29414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (bsize > 0) { 29424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *product; 29434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const Py_ssize_t nbtouse = MIN(bsize, asize); 29444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Multiply the next slice of b by a. */ 29464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(bslice->ob_digit, b->ob_digit + nbdone, 29474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nbtouse * sizeof(digit)); 29484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(bslice) = nbtouse; 29494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm product = k_mul(a, bslice); 29504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (product == NULL) 29514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto fail; 29524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Add into result. */ 29544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (void)v_iadd(ret->ob_digit + nbdone, Py_SIZE(ret) - nbdone, 29554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm product->ob_digit, Py_SIZE(product)); 29564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(product); 29574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bsize -= nbtouse; 29594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nbdone += nbtouse; 29604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(bslice); 29634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_normalize(ret); 29644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fail: 29664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(ret); 29674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(bslice); 29684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 29694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 29704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 29724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_mul(PyLongObject *v, PyLongObject *w) 29734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 29744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b, *z; 29754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!convert_binop((PyObject *)v, (PyObject *)w, &a, &b)) { 29774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_NotImplemented); 29784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_NotImplemented; 29794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 29804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = k_mul(a, b); 29824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Negate if exactly one of the inputs is negative. */ 29834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (((a->ob_size ^ b->ob_size) < 0) && z) 29844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_size = -(z->ob_size); 29854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 29864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 29874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)z; 29884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 29894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 29904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* The / and % operators are now defined in terms of divmod(). 29914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The expression a mod b has the value a - b*floor(a/b). 29924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The long_divrem function gives the remainder after division of 29934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm |a| by |b|, with the sign of a. This is also expressed 29944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm as a - b*trunc(a/b), if trunc truncates towards zero. 29954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Some examples: 29964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a b a rem b a mod b 29974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13 10 3 3 29984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm -13 10 -3 7 29994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13 -10 3 -7 30004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm -13 -10 -3 -3 30014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm So, to get from rem to mod, we have to add b if a and b 30024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm have different signs. We then subtract one from the 'div' 30034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm part of the outcome to keep the invariant intact. */ 30044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Compute 30064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * *pdiv, *pmod = divmod(v, w) 30074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * NULL can be passed for pdiv or pmod, in which case that part of 30084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * the result is simply thrown away. The caller owns a reference to 30094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * each of these it requests (does not pass NULL for). 30104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 30114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 30124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylml_divmod(PyLongObject *v, PyLongObject *w, 30134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject **pdiv, PyLongObject **pmod) 30144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 30154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *div, *mod; 30164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (long_divrem(v, w, &div, &mod) < 0) 30184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 30194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((Py_SIZE(mod) < 0 && Py_SIZE(w) > 0) || 30204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (Py_SIZE(mod) > 0 && Py_SIZE(w) < 0)) { 30214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *temp; 30224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *one; 30234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm temp = (PyLongObject *) long_add(mod, w); 30244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(mod); 30254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mod = temp; 30264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (mod == NULL) { 30274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(div); 30284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 30294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm one = (PyLongObject *) PyLong_FromLong(1L); 30314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (one == NULL || 30324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (temp = (PyLongObject *) long_sub(div, one)) == NULL) { 30334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(mod); 30344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(div); 30354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(one); 30364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 30374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(one); 30394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(div); 30404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm div = temp; 30414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 30424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pdiv != NULL) 30434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pdiv = div; 30444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 30454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(div); 30464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (pmod != NULL) 30484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pmod = mod; 30494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 30504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(mod); 30514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 30534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 30544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 30564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_div(PyObject *v, PyObject *w) 30574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 30584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b, *div; 30594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP(v, w, &a, &b); 30614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (l_divmod(a, b, &div, NULL) < 0) 30624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm div = NULL; 30634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 30644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 30654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)div; 30664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 30674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 30694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_classic_div(PyObject *v, PyObject *w) 30704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 30714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b, *div; 30724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP(v, w, &a, &b); 30744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_DivisionWarningFlag && 30754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Warn(PyExc_DeprecationWarning, "classic long division") < 0) 30764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm div = NULL; 30774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (l_divmod(a, b, &div, NULL) < 0) 30784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm div = NULL; 30794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 30804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 30814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)div; 30824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 30834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* PyLong/PyLong -> float, with correctly rounded result. */ 30854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define MANT_DIG_DIGITS (DBL_MANT_DIG / PyLong_SHIFT) 30874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define MANT_DIG_BITS (DBL_MANT_DIG % PyLong_SHIFT) 30884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 30904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_true_divide(PyObject *v, PyObject *w) 30914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 30924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b, *x; 30934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t a_size, b_size, shift, extra_bits, diff, x_size, x_bits; 30944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit mask, low; 30954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int inexact, negate, a_is_small, b_is_small; 30964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm double dx, result; 30974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 30984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP(v, w, &a, &b); 30994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* 31014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Method in a nutshell: 31024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0. reduce to case a, b > 0; filter out obvious underflow/overflow 31044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1. choose a suitable integer 'shift' 31054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2. use integer arithmetic to compute x = floor(2**-shift*a/b) 31064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3. adjust x for correct rounding 31074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4. convert x to a double dx with the same value 31084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5. return ldexp(dx, shift). 31094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm In more detail: 31114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0. For any a, a/0 raises ZeroDivisionError; for nonzero b, 0/b 31134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm returns either 0.0 or -0.0, depending on the sign of b. For a and 31144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b both nonzero, ignore signs of a and b, and add the sign back in 31154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm at the end. Now write a_bits and b_bits for the bit lengths of a 31164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm and b respectively (that is, a_bits = 1 + floor(log_2(a)); likewise 31174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for b). Then 31184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2**(a_bits - b_bits - 1) < a/b < 2**(a_bits - b_bits + 1). 31204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm So if a_bits - b_bits > DBL_MAX_EXP then a/b > 2**DBL_MAX_EXP and 31224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm so overflows. Similarly, if a_bits - b_bits < DBL_MIN_EXP - 31234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm DBL_MANT_DIG - 1 then a/b underflows to 0. With these cases out of 31244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the way, we can assume that 31254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm DBL_MIN_EXP - DBL_MANT_DIG - 1 <= a_bits - b_bits <= DBL_MAX_EXP. 31274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1. The integer 'shift' is chosen so that x has the right number of 31294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bits for a double, plus two or three extra bits that will be used 31304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm in the rounding decisions. Writing a_bits and b_bits for the 31314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm number of significant bits in a and b respectively, a 31324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm straightforward formula for shift is: 31334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shift = a_bits - b_bits - DBL_MANT_DIG - 2 31354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm This is fine in the usual case, but if a/b is smaller than the 31374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm smallest normal float then it can lead to double rounding on an 31384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm IEEE 754 platform, giving incorrectly rounded results. So we 31394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm adjust the formula slightly. The actual formula used is: 31404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shift = MAX(a_bits - b_bits, DBL_MIN_EXP) - DBL_MANT_DIG - 2 31424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2. The quantity x is computed by first shifting a (left -shift bits 31444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if shift <= 0, right shift bits if shift > 0) and then dividing by 31454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b. For both the shift and the division, we keep track of whether 31464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the result is inexact, in a flag 'inexact'; this information is 31474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm needed at the rounding stage. 31484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm With the choice of shift above, together with our assumption that 31504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_bits - b_bits >= DBL_MIN_EXP - DBL_MANT_DIG - 1, it follows 31514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm that x >= 1. 31524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3. Now x * 2**shift <= a/b < (x+1) * 2**shift. We want to replace 31544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm this with an exactly representable float of the form 31554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm round(x/2**extra_bits) * 2**(extra_bits+shift). 31574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm For float representability, we need x/2**extra_bits < 31594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2**DBL_MANT_DIG and extra_bits + shift >= DBL_MIN_EXP - 31604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm DBL_MANT_DIG. This translates to the condition: 31614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm extra_bits >= MAX(x_bits, DBL_MIN_EXP - shift) - DBL_MANT_DIG 31634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm To round, we just modify the bottom digit of x in-place; this can 31654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm end up giving a digit with value > PyLONG_MASK, but that's not a 31664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm problem since digits can hold values up to 2*PyLONG_MASK+1. 31674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm With the original choices for shift above, extra_bits will always 31694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm be 2 or 3. Then rounding under the round-half-to-even rule, we 31704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm round up iff the most significant of the extra bits is 1, and 31714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm either: (a) the computation of x in step 2 had an inexact result, 31724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm or (b) at least one other of the extra bits is 1, or (c) the least 31734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm significant bit of x (above those to be rounded) is 1. 31744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4. Conversion to a double is straightforward; all floating-point 31764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm operations involved in the conversion are exact, so there's no 31774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm danger of rounding errors. 31784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5. Use ldexp(x, shift) to compute x*2**shift, the final result. 31804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The result will always be exactly representable as a double, except 31814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm in the case that it overflows. To avoid dependence on the exact 31824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm behaviour of ldexp on overflow, we check for overflow before 31834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm applying ldexp. The result of ldexp is adjusted for sign before 31844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm returning. 31854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 31864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Reduce to case where a and b are both positive. */ 31884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_size = ABS(Py_SIZE(a)); 31894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b_size = ABS(Py_SIZE(b)); 31904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negate = (Py_SIZE(a) < 0) ^ (Py_SIZE(b) < 0); 31914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (b_size == 0) { 31924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ZeroDivisionError, 31934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "division by zero"); 31944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 31954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 31964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a_size == 0) 31974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto underflow_or_zero; 31984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 31994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Fast path for a and b small (exactly representable in a double). 32004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Relies on floating-point division being correctly rounded; results 32014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm may be subject to double rounding on x86 machines that operate with 32024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the x87 FPU set to 64-bit precision. */ 32034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_is_small = a_size <= MANT_DIG_DIGITS || 32044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (a_size == MANT_DIG_DIGITS+1 && 32054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a->ob_digit[MANT_DIG_DIGITS] >> MANT_DIG_BITS == 0); 32064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b_is_small = b_size <= MANT_DIG_DIGITS || 32074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (b_size == MANT_DIG_DIGITS+1 && 32084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b->ob_digit[MANT_DIG_DIGITS] >> MANT_DIG_BITS == 0); 32094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a_is_small && b_is_small) { 32104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm double da, db; 32114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm da = a->ob_digit[--a_size]; 32124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (a_size > 0) 32134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm da = da * PyLong_BASE + a->ob_digit[--a_size]; 32144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm db = b->ob_digit[--b_size]; 32154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (b_size > 0) 32164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm db = db * PyLong_BASE + b->ob_digit[--b_size]; 32174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = da / db; 32184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto success; 32194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Catch obvious cases of underflow and overflow */ 32224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm diff = a_size - b_size; 32234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (diff > PY_SSIZE_T_MAX/PyLong_SHIFT - 1) 32244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Extreme overflow */ 32254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto overflow; 32264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (diff < 1 - PY_SSIZE_T_MAX/PyLong_SHIFT) 32274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Extreme underflow */ 32284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto underflow_or_zero; 32294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Next line is now safe from overflowing a Py_ssize_t */ 32304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm diff = diff * PyLong_SHIFT + bits_in_digit(a->ob_digit[a_size - 1]) - 32314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bits_in_digit(b->ob_digit[b_size - 1]); 32324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Now diff = a_bits - b_bits. */ 32334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (diff > DBL_MAX_EXP) 32344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto overflow; 32354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (diff < DBL_MIN_EXP - DBL_MANT_DIG - 1) 32364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto underflow_or_zero; 32374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Choose value for shift; see comments for step 1 above. */ 32394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shift = MAX(diff, DBL_MIN_EXP) - DBL_MANT_DIG - 2; 32404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inexact = 0; 32424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* x = abs(a * 2**-shift) */ 32444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (shift <= 0) { 32454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i, shift_digits = -shift / PyLong_SHIFT; 32464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit rem; 32474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* x = a << -shift */ 32484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a_size >= PY_SSIZE_T_MAX - 1 - shift_digits) { 32494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* In practice, it's probably impossible to end up 32504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm here. Both a and b would have to be enormous, 32514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm using close to SIZE_T_MAX bytes of memory each. */ 32524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 32534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "intermediate overflow during division"); 32544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 32554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = _PyLong_New(a_size + shift_digits + 1); 32574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) 32584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 32594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < shift_digits; i++) 32604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x->ob_digit[i] = 0; 32614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem = v_lshift(x->ob_digit + shift_digits, a->ob_digit, 32624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_size, -shift % PyLong_SHIFT); 32634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x->ob_digit[a_size + shift_digits] = rem; 32644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 32664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t shift_digits = shift / PyLong_SHIFT; 32674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit rem; 32684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* x = a >> shift */ 32694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(a_size >= shift_digits); 32704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = _PyLong_New(a_size - shift_digits); 32714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) 32724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 32734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rem = v_rshift(x->ob_digit, a->ob_digit + shift_digits, 32744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a_size - shift_digits, shift % PyLong_SHIFT); 32754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* set inexact if any of the bits shifted out is nonzero */ 32764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (rem) 32774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inexact = 1; 32784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (!inexact && shift_digits > 0) 32794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a->ob_digit[--shift_digits]) 32804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inexact = 1; 32814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_normalize(x); 32834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_size = Py_SIZE(x); 32844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 32854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* x //= b. If the remainder is nonzero, set inexact. We own the only 32864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm reference to x, so it's safe to modify it in-place. */ 32874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (b_size == 1) { 32884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit rem = inplace_divrem1(x->ob_digit, x->ob_digit, x_size, 32894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b->ob_digit[0]); 32904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_normalize(x); 32914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (rem) 32924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inexact = 1; 32934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 32944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 32954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *div, *rem; 32964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm div = x_divrem(x, b, &rem); 32974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(x); 32984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = div; 32994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) 33004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 33014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(rem)) 33024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inexact = 1; 33034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(rem); 33044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 33054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_size = ABS(Py_SIZE(x)); 33064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(x_size > 0); /* result of division is never zero */ 33074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x_bits = (x_size-1)*PyLong_SHIFT+bits_in_digit(x->ob_digit[x_size-1]); 33084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* The number of extra bits that have to be rounded away. */ 33104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm extra_bits = MAX(x_bits, DBL_MIN_EXP - shift) - DBL_MANT_DIG; 33114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(extra_bits == 2 || extra_bits == 3); 33124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Round by directly modifying the low digit of x. */ 33144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mask = (digit)1 << (extra_bits - 1); 33154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm low = x->ob_digit[0] | inexact; 33164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (low & mask && low & (3*mask-1)) 33174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm low += mask; 33184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x->ob_digit[0] = low & ~(mask-1U); 33194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Convert x to a double dx; the conversion is exact. */ 33214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dx = x->ob_digit[--x_size]; 33224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (x_size > 0) 33234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm dx = dx * PyLong_BASE + x->ob_digit[--x_size]; 33244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(x); 33254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Check whether ldexp result will overflow a double. */ 33274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (shift + x_bits >= DBL_MAX_EXP && 33284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (shift + x_bits > DBL_MAX_EXP || dx == ldexp(1.0, (int)x_bits))) 33294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto overflow; 33304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = ldexp(dx, (int)shift); 33314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm success: 33334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 33344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 33354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyFloat_FromDouble(negate ? -result : result); 33364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm underflow_or_zero: 33384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 33394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 33404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyFloat_FromDouble(negate ? -0.0 : 0.0); 33414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm overflow: 33434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_OverflowError, 33444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "integer division result too large for a float"); 33454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm error: 33464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 33474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 33484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 33494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 33504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 33524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_mod(PyObject *v, PyObject *w) 33534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 33544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b, *mod; 33554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP(v, w, &a, &b); 33574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (l_divmod(a, b, NULL, &mod) < 0) 33594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mod = NULL; 33604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 33614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 33624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)mod; 33634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 33644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 33664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_divmod(PyObject *v, PyObject *w) 33674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 33684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b, *div, *mod; 33694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *z; 33704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP(v, w, &a, &b); 33724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (l_divmod(a, b, &div, &mod) < 0) { 33744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 33754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 33764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 33774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 33784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = PyTuple_New(2); 33794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z != NULL) { 33804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_SetItem(z, 0, (PyObject *) div); 33814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyTuple_SetItem(z, 1, (PyObject *) mod); 33824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 33834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 33844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(div); 33854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(mod); 33864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 33874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 33884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 33894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return z; 33904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 33914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* pow(v, w, x) */ 33934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 33944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_pow(PyObject *v, PyObject *w, PyObject *x) 33954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 33964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b, *c; /* a,b,c = v,w,x */ 33974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int negativeOutput = 0; /* if x<0 return negative output */ 33984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 33994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z = NULL; /* accumulated result */ 34004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i, j, k; /* counters */ 34014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *temp = NULL; 34024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* 5-ary values. If the exponent is large enough, table is 34044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * precomputed so that table[i] == a**i % c for i in range(32). 34054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 34064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *table[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 34074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 34084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* a, b, c = v, w, x */ 34104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP(v, w, &a, &b); 34114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyLong_Check(x)) { 34124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = (PyLongObject *)x; 34134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(x); 34144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyInt_Check(x)) { 34164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = (PyLongObject *)PyLong_FromLong(PyInt_AS_LONG(x)); 34174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c == NULL) 34184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 34194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (x == Py_None) 34214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = NULL; 34224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 34234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 34244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 34254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(Py_NotImplemented); 34264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_NotImplemented; 34274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(b) < 0) { /* if exponent is negative */ 34304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c) { 34314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, "pow() 2nd argument " 34324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "cannot be negative when 3rd argument specified"); 34334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 34344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 34364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* else return a float. This works because we know 34374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm that this calls float_pow() which converts its 34384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm arguments to double. */ 34394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 34404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 34414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyFloat_Type.tp_as_number->nb_power(v, w, x); 34424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c) { 34464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* if modulus == 0: 34474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise ValueError() */ 34484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(c) == 0) { 34494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ValueError, 34504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "pow() 3rd argument cannot be 0"); 34514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 34524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* if modulus < 0: 34554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negativeOutput = True 34564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm modulus = -modulus */ 34574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(c) < 0) { 34584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negativeOutput = 1; 34594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm temp = (PyLongObject *)_PyLong_Copy(c); 34604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (temp == NULL) 34614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 34624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(c); 34634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = temp; 34644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm temp = NULL; 34654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c->ob_size = - c->ob_size; 34664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* if modulus == 1: 34694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0 */ 34704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ((Py_SIZE(c) == 1) && (c->ob_digit[0] == 1)) { 34714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = (PyLongObject *)PyLong_FromLong(0L); 34724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Done; 34734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* if base < 0: 34764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base = base % modulus 34774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Having the base positive just makes things easier. */ 34784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(a) < 0) { 34794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (l_divmod(a, c, NULL, &temp) < 0) 34804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 34814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 34824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = temp; 34834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm temp = NULL; 34844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 34864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* At this point a, b, and c are guaranteed non-negative UNLESS 34884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c is NULL, in which case a may be negative. */ 34894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = (PyLongObject *)PyLong_FromLong(1L); 34914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 34924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 34934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Perform a modular reduction, X = X % c, but leave X alone if c 34954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * is NULL. 34964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 34974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define REDUCE(X) \ 34984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do { \ 34994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (c != NULL) { \ 35004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (l_divmod(X, c, NULL, &temp) < 0) \ 35014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; \ 35024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(X); \ 35034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm X = temp; \ 35044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm temp = NULL; \ 35054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } \ 35064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } while(0) 35074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Multiply two values, then reduce the result: 35094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = X*Y % c. If c is NULL, skip the mod. */ 35104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#define MULT(X, Y, result) \ 35114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm do { \ 35124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm temp = (PyLongObject *)long_mul(X, Y); \ 35134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (temp == NULL) \ 35144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; \ 35154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(result); \ 35164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = temp; \ 35174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm temp = NULL; \ 35184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm REDUCE(result); \ 35194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } while(0) 35204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(b) <= FIVEARY_CUTOFF) { 35224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Left-to-right binary exponentiation (HAC Algorithm 14.79) */ 35234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf */ 35244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = Py_SIZE(b) - 1; i >= 0; --i) { 35254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit bi = b->ob_digit[i]; 35264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (j = (digit)1 << (PyLong_SHIFT-1); j != 0; j >>= 1) { 35284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm MULT(z, z, z); 35294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (bi & j) 35304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm MULT(z, a, z); 35314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 35354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Left-to-right 5-ary exponentiation (HAC Algorithm 14.82) */ 35364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(z); /* still holds 1L */ 35374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm table[0] = z; 35384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 1; i < 32; ++i) 35394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm MULT(table[i-1], a, table[i]); 35404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = Py_SIZE(b) - 1; i >= 0; --i) { 35424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const digit bi = b->ob_digit[i]; 35434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (j = PyLong_SHIFT - 5; j >= 0; j -= 5) { 35454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm const int index = (bi >> j) & 0x1f; 35464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (k = 0; k < 5; ++k) 35474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm MULT(z, z, z); 35484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (index) 35494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm MULT(z, table[index], z); 35504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (negativeOutput && (Py_SIZE(z) != 0)) { 35554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm temp = (PyLongObject *)long_sub(z, c); 35564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (temp == NULL) 35574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Error; 35584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(z); 35594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = temp; 35604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm temp = NULL; 35614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto Done; 35634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Error: 35654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z != NULL) { 35664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(z); 35674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = NULL; 35684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* fall through */ 35704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Done: 35714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(b) > FIVEARY_CUTOFF) { 35724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < 32; ++i) 35734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(table[i]); 35744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 35754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 35764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 35774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(c); 35784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_XDECREF(temp); 35794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)z; 35804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 35814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 35834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_invert(PyLongObject *v) 35844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 35854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Implement ~x as -(x+1) */ 35864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *x; 35874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *w; 35884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm w = (PyLongObject *)PyLong_FromLong(1L); 35894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (w == NULL) 35904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 35914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (PyLongObject *) long_add(v, w); 35924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(w); 35934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) 35944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 35954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(x) = -(Py_SIZE(x)); 35964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)x; 35974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 35984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 35994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 36004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_neg(PyLongObject *v) 36014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 36024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z; 36034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v->ob_size == 0 && PyLong_CheckExact(v)) { 36044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* -0 == 0 */ 36054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(v); 36064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *) v; 36074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = (PyLongObject *)_PyLong_Copy(v); 36094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z != NULL) 36104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_size = -(v->ob_size); 36114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)z; 36124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 36134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 36154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_abs(PyLongObject *v) 36164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 36174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (v->ob_size < 0) 36184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_neg(v); 36194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 36204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_long((PyObject *)v); 36214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 36224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 36244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_nonzero(PyLongObject *v) 36254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 36264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_SIZE(v) != 0; 36274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 36284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 36304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_rshift(PyLongObject *v, PyLongObject *w) 36314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 36324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b; 36334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z = NULL; 36344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t shiftby, newsize, wordshift, loshift, hishift, i, j; 36354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit lomask, himask; 36364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b); 36384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(a) < 0) { 36404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Right shifting negative numbers is harder */ 36414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a1, *a2; 36424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a1 = (PyLongObject *) long_invert(a); 36434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a1 == NULL) 36444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto rshift_error; 36454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a2 = (PyLongObject *) long_rshift(a1, b); 36464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a1); 36474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a2 == NULL) 36484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto rshift_error; 36494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = (PyLongObject *) long_invert(a2); 36504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a2); 36514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 36534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shiftby = PyLong_AsSsize_t((PyObject *)b); 36544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (shiftby == -1L && PyErr_Occurred()) 36554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto rshift_error; 36564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (shiftby < 0) { 36574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ValueError, 36584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "negative shift count"); 36594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto rshift_error; 36604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm wordshift = shiftby / PyLong_SHIFT; 36624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newsize = ABS(Py_SIZE(a)) - wordshift; 36634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (newsize <= 0) { 36644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(0); 36654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 36664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 36674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)z; 36684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm loshift = shiftby % PyLong_SHIFT; 36704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm hishift = PyLong_SHIFT - loshift; 36714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lomask = ((digit)1 << hishift) - 1; 36724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm himask = PyLong_MASK ^ lomask; 36734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(newsize); 36744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 36754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto rshift_error; 36764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Py_SIZE(a) < 0) 36774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(z) = -(Py_SIZE(z)); 36784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0, j = wordshift; i < newsize; i++, j++) { 36794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = (a->ob_digit[j] >> loshift) & lomask; 36804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (i+1 < newsize) 36814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] |= (a->ob_digit[j+1] << hishift) & himask; 36824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = long_normalize(z); 36844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 36854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rshift_error: 36864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 36874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 36884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *) z; 36894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 36914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 36924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 36934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_lshift(PyObject *v, PyObject *w) 36944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 36954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* This version due to Tim Peters */ 36964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b; 36974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z = NULL; 36984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t shiftby, oldsize, newsize, wordshift, remshift, i, j; 36994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm twodigits accum; 37004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP(v, w, &a, &b); 37024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shiftby = PyLong_AsSsize_t((PyObject *)b); 37044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (shiftby == -1L && PyErr_Occurred()) 37054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto lshift_error; 37064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (shiftby < 0) { 37074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_ValueError, "negative shift count"); 37084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto lshift_error; 37094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 37104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* wordshift, remshift = divmod(shiftby, PyLong_SHIFT) */ 37114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm wordshift = shiftby / PyLong_SHIFT; 37124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm remshift = shiftby - wordshift * PyLong_SHIFT; 37134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm oldsize = ABS(a->ob_size); 37154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newsize = oldsize + wordshift; 37164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (remshift) 37174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ++newsize; 37184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(newsize); 37194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 37204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto lshift_error; 37214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (a->ob_size < 0) 37224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_size = -(z->ob_size); 37234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < wordshift; i++) 37244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = 0; 37254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum = 0; 37264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = wordshift, j = 0; j < oldsize; i++, j++) { 37274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum |= (twodigits)a->ob_digit[j] << remshift; 37284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = (digit)(accum & PyLong_MASK); 37294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accum >>= PyLong_SHIFT; 37304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 37314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (remshift) 37324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[newsize-1] = (digit)accum; 37334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 37344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(!accum); 37354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = long_normalize(z); 37364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lshift_error: 37374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 37384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 37394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *) z; 37404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 37414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Compute two's complement of digit vector a[0:m], writing result to 37434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z[0:m]. The digit vector a need not be normalized, but should not 37444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm be entirely zero. a and z may point to the same digit vector. */ 37454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic void 37474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmv_complement(digit *z, digit *a, Py_ssize_t m) 37484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 37494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i; 37504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit carry = 1; 37514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < m; ++i) { 37524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry += a[i] ^ PyLong_MASK; 37534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z[i] = carry & PyLong_MASK; 37544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm carry >>= PyLong_SHIFT; 37554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 37564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(carry == 0); 37574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 37584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Bitwise and/xor/or operations */ 37604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 37624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_bitwise(PyLongObject *a, 37634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int op, /* '&', '|', '^' */ 37644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *b) 37654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 37664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int nega, negb, negz; 37674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t size_a, size_b, size_z, i; 37684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *z; 37694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Bitwise operations for negative numbers operate as though 37714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm on a two's complement representation. So convert arguments 37724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from sign-magnitude to two's complement, and convert the 37734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result back to sign-magnitude at the end. */ 37744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* If a is negative, replace it by its two's complement. */ 37764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_a = ABS(Py_SIZE(a)); 37774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nega = Py_SIZE(a) < 0; 37784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (nega) { 37794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(size_a); 37804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) 37814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 37824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v_complement(z->ob_digit, a->ob_digit, size_a); 37834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = z; 37844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 37854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 37864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Keep reference count consistent. */ 37874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(a); 37884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 37894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Same for b. */ 37904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_b = ABS(Py_SIZE(b)); 37914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negb = Py_SIZE(b) < 0; 37924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (negb) { 37934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(size_b); 37944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) { 37954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 37964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 37974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 37984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v_complement(z->ob_digit, b->ob_digit, size_b); 37994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = z; 38004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 38024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(b); 38034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Swap a and b if necessary to ensure size_a >= size_b. */ 38054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (size_a < size_b) { 38064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = a; a = b; b = z; 38074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_z = size_a; size_a = size_b; size_b = size_z; 38084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negz = nega; nega = negb; negb = negz; 38094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* JRH: The original logic here was to allocate the result value (z) 38124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm as the longer of the two operands. However, there are some cases 38134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm where the result is guaranteed to be shorter than that: AND of two 38144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm positives, OR of two negatives: use the shorter number. AND with 38154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mixed signs: use the positive number. OR with mixed signs: use the 38164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negative number. 38174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm */ 38184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch (op) { 38194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case '^': 38204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negz = nega ^ negb; 38214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_z = size_a; 38224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 38234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case '&': 38244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negz = nega & negb; 38254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_z = negb ? size_a : size_b; 38264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 38274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case '|': 38284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negz = nega | negb; 38294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm size_z = negb ? size_b : size_a; 38304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 38314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: 38324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadArgument(); 38334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 38344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* We allow an extra digit if z is negative, to make sure that 38374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the final two's complement of z doesn't overflow. */ 38384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = _PyLong_New(size_z + negz); 38394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (z == NULL) { 38404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 38414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 38424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 38434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Compute digits for overlap of a and b. */ 38464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm switch(op) { 38474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case '&': 38484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < size_b; ++i) 38494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = a->ob_digit[i] & b->ob_digit[i]; 38504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 38514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case '|': 38524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < size_b; ++i) 38534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = a->ob_digit[i] | b->ob_digit[i]; 38544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 38554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm case '^': 38564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < size_b; ++i) 38574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = a->ob_digit[i] ^ b->ob_digit[i]; 38584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break; 38594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm default: 38604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_BadArgument(); 38614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 38624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Copy any remaining digits of a, inverting if necessary. */ 38654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (op == '^' && negb) 38664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (; i < size_z; ++i) 38674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[i] = a->ob_digit[i] ^ PyLong_MASK; 38684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (i < size_z) 38694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm memcpy(&z->ob_digit[i], &a->ob_digit[i], 38704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (size_z-i)*sizeof(digit)); 38714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Complement result if negative. */ 38734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (negz) { 38744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(z) = -(Py_SIZE(z)); 38754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z->ob_digit[size_z] = PyLong_MASK; 38764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v_complement(z->ob_digit, z->ob_digit, size_z+1); 38774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 38784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 38804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 38814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)long_normalize(z); 38824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 38834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 38854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_and(PyObject *v, PyObject *w) 38864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 38874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b; 38884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *c; 38894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP(v, w, &a, &b); 38904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = long_bitwise(a, '&', b); 38914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 38924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 38934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return c; 38944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 38954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 38964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 38974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_xor(PyObject *v, PyObject *w) 38984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 38994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b; 39004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *c; 39014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP(v, w, &a, &b); 39024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = long_bitwise(a, '^', b); 39034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 39044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 39054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return c; 39064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 39074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 39094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_or(PyObject *v, PyObject *w) 39104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 39114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *a, *b; 39124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *c; 39134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm CONVERT_BINOP(v, w, &a, &b); 39144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = long_bitwise(a, '|', b); 39154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(a); 39164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(b); 39174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return c; 39184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 39194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic int 39214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_coerce(PyObject **pv, PyObject **pw) 39224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 39234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyInt_Check(*pw)) { 39244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm *pw = PyLong_FromLong(PyInt_AS_LONG(*pw)); 39254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (*pw == NULL) 39264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1; 39274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(*pv); 39284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 39294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 39304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyLong_Check(*pw)) { 39314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(*pv); 39324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(*pw); 39334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0; 39344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 39354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1; /* Can't do it */ 39364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 39374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 39394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_long(PyObject *v) 39404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 39414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyLong_CheckExact(v)) 39424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(v); 39434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 39444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = _PyLong_Copy((PyLongObject *)v); 39454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 39464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 39474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 39494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_int(PyObject *v) 39504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 39514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long x; 39524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = PyLong_AsLong(v); 39534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_Occurred()) { 39544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_ExceptionMatches(PyExc_OverflowError)) { 39554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Clear(); 39564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyLong_CheckExact(v)) { 39574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_INCREF(v); 39584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return v; 39594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 39604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 39614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyLong_Copy((PyLongObject *)v); 39624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 39634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else 39644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 39654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 39664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_FromLong(x); 39674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 39684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 39704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_float(PyObject *v) 39714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 39724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm double result; 39734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = PyLong_AsDouble(v); 39744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (result == -1.0 && PyErr_Occurred()) 39754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 39764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyFloat_FromDouble(result); 39774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 39784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 39804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_oct(PyObject *v) 39814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 39824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyLong_Format(v, 8, 1, 0); 39834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 39844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 39864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_hex(PyObject *v) 39874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 39884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyLong_Format(v, 16, 1, 0); 39894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 39904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 39924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds); 39934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 39944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 39954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 39964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 39974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *x = NULL; 39984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int base = -909; /* unlikely! */ 39994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm static char *kwlist[] = {"x", "base", 0}; 40004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (type != &PyLong_Type) 40024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_subtype_new(type, args, kwds); /* Wimp out */ 40034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:long", kwlist, 40044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm &x, &base)) 40054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 40064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) 40074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyLong_FromLong(0L); 40084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (base == -909) 40094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyNumber_Long(x); 40104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyString_Check(x)) { 40114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Since PyLong_FromString doesn't have a length parameter, 40124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * check here for possible NULs in the string. */ 40134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm char *string = PyString_AS_STRING(x); 40144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (strlen(string) != (size_t)PyString_Size(x)) { 40154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* create a repr() of the input string, 40164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm * just like PyLong_FromString does. */ 40174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *srepr; 40184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm srepr = PyObject_Repr(x); 40194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (srepr == NULL) 40204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 40214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_Format(PyExc_ValueError, 40224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "invalid literal for long() with base %d: %s", 40234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base, PyString_AS_STRING(srepr)); 40244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(srepr); 40254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 40264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 40274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyLong_FromString(PyString_AS_STRING(x), NULL, base); 40284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 40294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#ifdef Py_USING_UNICODE 40304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else if (PyUnicode_Check(x)) 40314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyLong_FromUnicode(PyUnicode_AS_UNICODE(x), 40324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyUnicode_GET_SIZE(x), 40334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm base); 40344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 40354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else { 40364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, 40374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "long() can't convert non-string with explicit base"); 40384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 40394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 40404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 40414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm/* Wimpy, slow approach to tp_new calls for subtypes of long: 40434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm first create a regular long from whatever arguments we got, 40444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm then allocate a subtype instance and initialize it from 40454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm the regular long. The regular long is then thrown away. 40464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm*/ 40474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 40484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 40494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 40504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *tmp, *newobj; 40514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t i, n; 40524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyType_IsSubtype(type, &PyLong_Type)); 40544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmp = (PyLongObject *)long_new(&PyLong_Type, args, kwds); 40554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (tmp == NULL) 40564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 40574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyLong_CheckExact(tmp)); 40584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = Py_SIZE(tmp); 40594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (n < 0) 40604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = -n; 40614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newobj = (PyLongObject *)type->tp_alloc(type, n); 40624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (newobj == NULL) { 40634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(tmp); 40644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 40654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 40664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyLong_Check(newobj)); 40674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_SIZE(newobj) = Py_SIZE(tmp); 40684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (i = 0; i < n; i++) 40694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newobj->ob_digit[i] = tmp->ob_digit[i]; 40704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(tmp); 40714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)newobj; 40724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 40734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 40754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_getnewargs(PyLongObject *v) 40764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 40774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return Py_BuildValue("(N)", _PyLong_Copy(v)); 40784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 40794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 40814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_get0(PyLongObject *v, void *context) { 40824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyLong_FromLong(0L); 40834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 40844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 40864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_get1(PyLongObject *v, void *context) { 40874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyLong_FromLong(1L); 40884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 40894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 40914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong__format__(PyObject *self, PyObject *args) 40924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 40934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *format_spec; 40944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 40954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (!PyArg_ParseTuple(args, "O:__format__", &format_spec)) 40964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 40974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyBytes_Check(format_spec)) 40984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return _PyLong_FormatAdvanced(self, 40994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyBytes_AS_STRING(format_spec), 41004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyBytes_GET_SIZE(format_spec)); 41014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyUnicode_Check(format_spec)) { 41024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* Convert format_spec to a str */ 41034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *result; 41044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject *str_spec = PyObject_Str(format_spec); 41054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (str_spec == NULL) 41074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 41084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = _PyLong_FormatAdvanced(self, 41104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyBytes_AS_STRING(str_spec), 41114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyBytes_GET_SIZE(str_spec)); 41124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(str_spec); 41144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result; 41154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyErr_SetString(PyExc_TypeError, "__format__ requires str or unicode"); 41174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 41184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 41194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 41214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_sizeof(PyLongObject *v) 41224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 41234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t res; 41244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm res = v->ob_type->tp_basicsize + ABS(Py_SIZE(v))*sizeof(digit); 41264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_FromSsize_t(res); 41274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 41284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 41304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_bit_length(PyLongObject *v) 41314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 41324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyLongObject *result, *x, *y; 41334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_ssize_t ndigits, msd_bits = 0; 41344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm digit msd; 41354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(v != NULL); 41374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert(PyLong_Check(v)); 41384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ndigits = ABS(Py_SIZE(v)); 41404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ndigits == 0) 41414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_FromLong(0); 41424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msd = v->ob_digit[ndigits-1]; 41444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while (msd >= 32) { 41454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msd_bits += 6; 41464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msd >>= 6; 41474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 41484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msd_bits += (long)(BitLengthTable[msd]); 41494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (ndigits <= PY_SSIZE_T_MAX/PyLong_SHIFT) 41514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return PyInt_FromSsize_t((ndigits-1)*PyLong_SHIFT + msd_bits); 41524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* expression above may overflow; use Python integers instead */ 41544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = (PyLongObject *)PyLong_FromSsize_t(ndigits - 1); 41554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (result == NULL) 41564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 41574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (PyLongObject *)PyLong_FromLong(PyLong_SHIFT); 41584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) 41594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 41604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm y = (PyLongObject *)long_mul(result, x); 41614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(x); 41624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (y == NULL) 41634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 41644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(result); 41654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = y; 41664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (PyLongObject *)PyLong_FromLong((long)msd_bits); 41684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (x == NULL) 41694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 41704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm y = (PyLongObject *)long_add(result, x); 41714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(x); 41724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (y == NULL) 41734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm goto error; 41744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(result); 41754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = y; 41764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (PyObject *)result; 41784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm error: 41804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_DECREF(result); 41814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 41824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 41834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(long_bit_length_doc, 41854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"long.bit_length() -> int or long\n\ 41864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm\n\ 41874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmNumber of bits necessary to represent self in binary.\n\ 41884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> bin(37L)\n\ 41894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm'0b100101'\n\ 41904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm>>> (37L).bit_length()\n\ 41914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm6"); 41924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 41934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if 0 41944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyObject * 41954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmlong_is_finite(PyObject *v) 41964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 41974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_RETURN_TRUE; 41984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 41994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 42004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 42014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyMethodDef long_methods[] = { 42024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"conjugate", (PyCFunction)long_long, METH_NOARGS, 42034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Returns self, the complex conjugate of any long."}, 42044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"bit_length", (PyCFunction)long_bit_length, METH_NOARGS, 42054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_bit_length_doc}, 42064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#if 0 42074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"is_finite", (PyCFunction)long_is_finite, METH_NOARGS, 42084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Returns always True."}, 42094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#endif 42104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"__trunc__", (PyCFunction)long_long, METH_NOARGS, 42114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Truncating an Integral returns itself."}, 42124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"__getnewargs__", (PyCFunction)long_getnewargs, METH_NOARGS}, 42134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"__format__", (PyCFunction)long__format__, METH_VARARGS}, 42144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"__sizeof__", (PyCFunction)long_sizeof, METH_NOARGS, 42154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Returns size in memory, in bytes"}, 42164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {NULL, NULL} /* sentinel */ 42174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 42184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 42194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyGetSetDef long_getset[] = { 42204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"real", 42214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (getter)long_long, (setter)NULL, 42224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "the real part of a complex number", 42234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NULL}, 42244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"imag", 42254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (getter)long_get0, (setter)NULL, 42264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "the imaginary part of a complex number", 42274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NULL}, 42284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"numerator", 42294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (getter)long_long, (setter)NULL, 42304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "the numerator of a rational number in lowest terms", 42314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NULL}, 42324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"denominator", 42334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (getter)long_get1, (setter)NULL, 42344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "the denominator of a rational number in lowest terms", 42354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm NULL}, 42364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {NULL} /* Sentinel */ 42374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 42384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 42394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(long_doc, 42404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"long(x[, base]) -> integer\n\ 42414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm\n\ 42424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmConvert a string or number to a long integer, if possible. A floating\n\ 42434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmpoint argument will be truncated towards zero (this does not include a\n\ 42444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstring representation of a floating point number!) When converting a\n\ 42454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstring, use the optional base. It is an error to supply a base when\n\ 42464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmconverting a non-string."); 42474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 42484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyNumberMethods long_as_number = { 42494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (binaryfunc)long_add, /*nb_add*/ 42504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (binaryfunc)long_sub, /*nb_subtract*/ 42514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (binaryfunc)long_mul, /*nb_multiply*/ 42524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_classic_div, /*nb_divide*/ 42534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_mod, /*nb_remainder*/ 42544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_divmod, /*nb_divmod*/ 42554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_pow, /*nb_power*/ 42564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (unaryfunc)long_neg, /*nb_negative*/ 42574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (unaryfunc)long_long, /*tp_positive*/ 42584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (unaryfunc)long_abs, /*tp_absolute*/ 42594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (inquiry)long_nonzero, /*tp_nonzero*/ 42604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (unaryfunc)long_invert, /*nb_invert*/ 42614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_lshift, /*nb_lshift*/ 42624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (binaryfunc)long_rshift, /*nb_rshift*/ 42634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_and, /*nb_and*/ 42644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_xor, /*nb_xor*/ 42654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_or, /*nb_or*/ 42664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_coerce, /*nb_coerce*/ 42674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_int, /*nb_int*/ 42684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_long, /*nb_long*/ 42694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_float, /*nb_float*/ 42704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_oct, /*nb_oct*/ 42714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_hex, /*nb_hex*/ 42724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_add */ 42734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_subtract */ 42744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_multiply */ 42754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_divide */ 42764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_remainder */ 42774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_power */ 42784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_lshift */ 42794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_rshift */ 42804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_and */ 42814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_xor */ 42824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_or */ 42834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_div, /* nb_floor_divide */ 42844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_true_divide, /* nb_true_divide */ 42854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_floor_divide */ 42864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* nb_inplace_true_divide */ 42874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_long, /* nb_index */ 42884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 42894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 42904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyTypeObject PyLong_Type = { 42914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_HEAD_INIT(&PyType_Type) 42924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* ob_size */ 42934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "long", /* tp_name */ 42944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm offsetof(PyLongObject, ob_digit), /* tp_basicsize */ 42954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sizeof(digit), /* tp_itemsize */ 42964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_dealloc, /* tp_dealloc */ 42974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_print */ 42984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_getattr */ 42994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_setattr */ 43004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (cmpfunc)long_compare, /* tp_compare */ 43014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_repr, /* tp_repr */ 43024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm &long_as_number, /* tp_as_number */ 43034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_as_sequence */ 43044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_as_mapping */ 43054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (hashfunc)long_hash, /* tp_hash */ 43064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_call */ 43074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_str, /* tp_str */ 43084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_GenericGetAttr, /* tp_getattro */ 43094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_setattro */ 43104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_as_buffer */ 43114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES | 43124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_TPFLAGS_BASETYPE | Py_TPFLAGS_LONG_SUBCLASS, /* tp_flags */ 43134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_doc, /* tp_doc */ 43144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_traverse */ 43154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_clear */ 43164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_richcompare */ 43174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_weaklistoffset */ 43184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_iter */ 43194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_iternext */ 43204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_methods, /* tp_methods */ 43214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_members */ 43224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_getset, /* tp_getset */ 43234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_base */ 43244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_dict */ 43254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_descr_get */ 43264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_descr_set */ 43274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_dictoffset */ 43284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_init */ 43294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0, /* tp_alloc */ 43304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_new, /* tp_new */ 43314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject_Del, /* tp_free */ 43324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 43334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 43344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyTypeObject Long_InfoType; 43354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 43364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyDoc_STRVAR(long_info__doc__, 43374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"sys.long_info\n\ 43384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm\n\ 43394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmA struct sequence that holds information about Python's\n\ 43404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylminternal representation of integers. The attributes are read only."); 43414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 43424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyStructSequence_Field long_info_fields[] = { 43434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"bits_per_digit", "size of a digit in bits"}, 43444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {"sizeof_digit", "size in bytes of the C type used to represent a digit"}, 43454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {NULL, NULL} 43464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 43474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 43484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmstatic PyStructSequence_Desc long_info_desc = { 43494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "sys.long_info", /* name */ 43504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_info__doc__, /* doc */ 43514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_info_fields, /* fields */ 43524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2 /* number of fields */ 43534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm}; 43544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 43554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyObject * 43564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmPyLong_GetInfo(void) 43574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 43584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyObject* long_info; 43594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm int field = 0; 43604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm long_info = PyStructSequence_New(&Long_InfoType); 43614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (long_info == NULL) 43624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 43634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyStructSequence_SET_ITEM(long_info, field++, 43644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyInt_FromLong(PyLong_SHIFT)); 43654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyStructSequence_SET_ITEM(long_info, field++, 43664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyInt_FromLong(sizeof(digit))); 43674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (PyErr_Occurred()) { 43684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Py_CLEAR(long_info); 43694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return NULL; 43704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm } 43714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return long_info; 43724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 43734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 43744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmint 43754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm_PyLong_Init(void) 43764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm{ 43774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm /* initialize long_info */ 43784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (Long_InfoType.tp_name == 0) 43794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm PyStructSequence_InitType(&Long_InfoType, &long_info_desc); 43804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1; 43814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm} 4382